def test_dot(): A = np.random.standard_normal((20, 12)) B = np.random.standard_normal((10, 20)) C = rr.astransform(B).dot(rr.astransform(A)) assert_equal(C.shape, (10, 12)) Z = np.random.standard_normal(12) assert_array_almost_equal(C.dot(Z), B.dot(A.dot(Z))) assert_equal(C.ndim, 2)
def choose_lambda(X, quantile=0.95, ndraw=10000): """ Choose a value of `lam` for the square-root LASSO based on an empirical quantile of the distribution of $$ \frac{\|X^T\epsilon\|_{\infty}}{\|\epsilon\|_2}. $$ Parameters ---------- X : np.float((n, p)) Design matrix. quantile : float What quantile should we use? ndraw : int How many draws? """ X = rr.astransform(X) n, p = X.output_shape[0], X.input_shape[0] E = np.random.standard_normal((n, ndraw)) E /= np.sqrt(np.sum(E**2, 0))[None,:] return np.percentile(np.fabs(X.adjoint_map(E)).max(0), 100*quantile)
def test_misc(): X = np.random.standard_normal((40, 5)) power_L(X) Xa = rr.astransform(X) np.testing.assert_allclose(todense(Xa), X) reshapeA = adjoint(reshape((30, ), (6, 5))) assert_raises(NotImplementedError, todense, reshapeA)
def test_misc(): X = np.random.standard_normal((40, 5)) power_L(X) Xa = rr.astransform(X) np.testing.assert_allclose(todense(Xa), X) reshapeA = adjoint(reshape((30,), (6,5))) assert_raises(NotImplementedError, todense, reshapeA)
def choose_lambda_with_randomization(X, randomization, quantile=0.90, ndraw=10000): X = rr.astransform(X) n, p = X.output_shape[0], X.input_shape[0] E = np.random.standard_normal((n, ndraw)) E /= np.sqrt(np.sum(E**2, 0))[None,:] dist1 = np.fabs(X.adjoint_map(E)).max(0) dist2 = np.fabs(randomization.sample((ndraw,))).max(0) return np.percentile(dist1+dist2, 100*quantile)
def solve_sqrt_lasso_skinny(X, Y, weights=None, initial=None, quadratic=None, solve_args={}): """ Solve the square-root LASSO optimization problem: $$ \text{minimize}_{\beta} \|y-X\beta\|_2 + D |\beta|, $$ where $D$ is the diagonal matrix with weights on its diagonal. Parameters ---------- y : np.float((n,)) The target, in the model $y = X\beta$ X : np.float((n, p)) The data, in the model $y = X\beta$ weights : np.float Coefficients of the L-1 penalty in optimization problem, note that different coordinates can have different coefficients. initial : np.float(p) Initial point for optimization. solve_args : dict Arguments passed to regreg solver. quadratic : `regreg.identity_quadratic` A quadratic term added to objective function. """ X = rr.astransform(X) n, p = X.output_shape[0], X.input_shape[0] if weights is None: lam = choose_lambda(X) weights = lam * np.ones((p, )) weight_dict = dict(zip(np.arange(p), 2 * weights)) penalty = rr.mixed_lasso(range(p) + [rr.NONNEGATIVE], lagrange=1., weights=weight_dict) loss = sqlasso_objective_skinny(X, Y) problem = rr.simple_problem(loss, penalty) problem.coefs[-1] = np.linalg.norm(Y) if initial is not None: problem.coefs[:-1] = initial soln = problem.solve(quadratic, **solve_args) _loss = sqlasso_objective(X, Y) return soln[:-1], _loss
def fit(self, solve_args={'min_its': 200}): Y, M, p, weights = self.Y, self.M, self.Y.shape[ 0], self.feature_weights Y0 = Y - Y.mean() coef = solve_sqrt_lasso(M.T, Y0, weights=weights, solve_args=solve_args)[0] self.active = active = coef != 0 self.inactive = inactive = ~active if active.sum(): jumps = self.merge_intervals(M.slices[active]) M_inactive = copy(M) M_inactive.update_slices(M.slices[inactive]) X = M.form_matrix(M.slices[active])[0] R = np.identity(p) - X.dot(np.linalg.pinv(X)) L_inactive = M_inactive.dot(rr.astransform(R)) L = lasso.sqrt_lasso(X, Y0, weights[active]) L.fit(solve_args={'min_its': 200}, lasso_solution=coef[active]) C = L.constraints.linear_part.dot(X.T) L_inactive_neg = ra.scalar_multiply(L_inactive, -1.) irrep = L_inactive.dot( X.dot(-np.diag(L.active_signs).dot(L.constraints.offset))) full_lin = ra.vstack([L_inactive, L_inactive_neg, C]) full_offset = np.hstack([ irrep + L._multiplier * weights[inactive], -irrep + L._multiplier * weights[inactive], L.constraints.offset ]) full_con = constraints(full_lin, full_offset, covariance=L._sigma_hat**2 * np.identity(p)) print full_con(Y - Y.mean()) fit = X.dot(coef[active]) + Y.mean() segments = np.array([jumps[:-1], jumps[1:]]).T Xr = M.form_matrix(segments)[0] relaxed_fit = Xr.dot(np.linalg.pinv(Xr).dot(Y)) + Y.mean() # S = L.summary('onesided') # pS = pd.DataFrame(S) # pS['interval'] = [M.slices[i] for i in np.nonzero(active)[0]] # pS = pS.reindex(columns=['interval', 'pval', 'lasso', 'onestep']) pS = None else: fit = relaxed_fit = Y.mean() * np.ones(self.p) pS = None segments = np.array([[0, self.p]]) return fit, relaxed_fit, pS, segments
def __init__(self, X, Y): self.X = rr.astransform(X) n, p = self.X.output_shape[0], self.X.input_shape[0] self.Y = Y if n > p: self._quadratic_term = np.dot(X.T, X) self._linear_term = -2 * np.dot(X.T, Y) self._constant_term = (Y**2).sum() self._sqerror = rr.squared_error(X, Y)
def __init__(self, X, Y, quadratic=None, initial=None, offset=None): rr.smooth_atom.__init__(self, rr.astransform(X).input_shape, coef=1., offset=offset, quadratic=quadratic, initial=initial) self.X = X self.Y = Y self.data = (X, Y) self._sqerror = rr.squared_error(X, Y)
def __init__(self, X, Y, quadratic=None, initial=None, offset=None): X = rr.astransform(X) rr.smooth_atom.__init__(self, X.input_shape, coef=1., offset=offset, quadratic=quadratic, initial=initial) self.X = X self.Y = Y self._sqerror = rr.squared_error(X, Y)
def solve_sqrt_lasso_fat(X, Y, weights=None, initial=None, quadratic=None, solve_args={}): """ Solve the square-root LASSO optimization problem: $$ \text{minimize}_{\beta} \|y-X\beta\|_2 + D |\beta|, $$ where $D$ is the diagonal matrix with weights on its diagonal. Parameters ---------- y : np.float((n,)) The target, in the model $y = X\beta$ X : np.float((n, p)) The data, in the model $y = X\beta$ weights : np.float Coefficients of the L-1 penalty in optimization problem, note that different coordinates can have different coefficients. initial : np.float(p) Initial point for optimization. solve_args : dict Arguments passed to regreg solver. quadratic : `regreg.identity_quadratic` A quadratic term added to objective function. """ X = rr.astransform(X) n, p = X.output_shape[0], X.input_shape[0] if weights is None: lam = choose_lambda(X) weights = lam * np.ones((p,)) loss = sqlasso_objective(X, Y) penalty = rr.weighted_l1norm(weights, lagrange=1.) problem = rr.simple_problem(loss, penalty) if initial is not None: problem.coefs[:] = initial soln = problem.solve(quadratic, **solve_args) return soln, loss
def test_regreg_transform(): A, b = np.random.standard_normal((4, 30)), np.random.standard_normal(4) A = rr.astransform(A) con = AC.constraints(A, b, covariance=np.identity(30)) while True: Z = np.random.standard_normal(30) # conditional distribution if con.value(Z) < 0: break C = np.random.standard_normal((2, 30)) conditional = con.conditional(C, C.dot(Z)) W = np.random.standard_normal(30) print(conditional.pivot(W, Z)) print(con.pivot(W, Z))
def solve_sqrt_lasso(X, Y, weights=None, initial=None, **solve_kwargs): """ Solve the square-root LASSO optimization problem: $$ \text{minimize}_{\beta} \|y-X\beta\|_2 + D |\beta|, $$ where $D$ is the diagonal matrix with weights on its diagonal. Parameters ---------- y : np.float((n,)) The target, in the model $y = X\beta$ X : np.float((n, p)) The data, in the model $y = X\beta$ weights : np.float Coefficients of the L-1 penalty in optimization problem, note that different coordinates can have different coefficients. initial : np.float(p) Initial point for optimization. solve_kwargs : dict Arguments passed to regreg solver. """ X = rr.astransform(X) n, p = X.output_shape[0], X.input_shape[0] if weights is None: lam = choose_lambda(X) weights = lam * np.ones((p, )) loss = sqlasso_objective(X, Y) penalty = rr.weighted_l1norm(weights, lagrange=1.) problem = rr.simple_problem(loss, penalty) if initial is not None: problem.coefs[:] = initial soln = problem.solve(**solve_kwargs) return soln
def solve_sqrt_lasso(X, Y, weights=None, initial=None, **solve_kwargs): """ Solve the square-root LASSO optimization problem: $$ \text{minimize}_{\beta} \|y-X\beta\|_2 + D |\beta|, $$ where $D$ is the diagonal matrix with weights on its diagonal. Parameters ---------- y : np.float((n,)) The target, in the model $y = X\beta$ X : np.float((n, p)) The data, in the model $y = X\beta$ weights : np.float Coefficients of the L-1 penalty in optimization problem, note that different coordinates can have different coefficients. initial : np.float(p) Initial point for optimization. solve_kwargs : dict Arguments passed to regreg solver. """ X = rr.astransform(X) n, p = X.output_shape[0], X.input_shape[0] if n < p: return solve_sqrt_lasso_alt(X, Y, weights=weights, initial=initial, **solve_kwargs) else: return solve_sqrt_lasso_fat(X, Y, weights=weights, initial=initial, **solve_kwargs)