def normalize(self,crossvalidate=False,train_set=False,test_set=False): #if not hasattr(self, 'X'): if not crossvalidate: self.design = np.array(self.design) self.X = rr.normalize(self.design,center=True,scale=True) self.Y_signs = np.array(self.Y) self.Y_binary = (self.Y_signs + 1) / 2. else: train_design = np.array([self.design[i] for i in train_set]) test_design = np.array([self.design[i] for i in test_set]) self.X = rr.normalize(train_design,center=True,scale=True) self.X_test = rr.normalize(test_design,center=True,scale=True) print len(train_set) #print train_set print len(self.Y) self.Y_train = [self.Y[i] for i in train_set] self.Y_test = [self.Y[i] for i in test_set] self.Y_signs = np.array(self.Y_train) self.Y_binary = (self.Y_signs + 1) / 2. self.Y_signs_test = np.array(self.Y_test) self.Y_binary_test = (self.Y_signs_test + 1) / 2 self.p = self.X.primal_shape
def test_scaling_and_centering(): """ This test verifies that the normalized transform of affine correctly implements the linear transform that multiplies first by X, then centers. """ # N - number of data points # P - number of columns in design == number of betas N, P = 40, 30 # an arbitrary positive offset for data and design offset = 50 # design - with no colum of ones! X = np.random.normal(size=(N, P)) + offset L = rr.normalize(X, center=True, scale=True) # the default # coef for loss scalings = np.std(X, 0) scaling_matrix = np.diag(1. / scalings) for _ in range(10): beta = np.random.normal(size=(P, )) v = L.linear_map(beta) v2 = np.dot(X, np.dot(scaling_matrix, beta)) v2 -= v2.mean() np.testing.assert_almost_equal(v, v2) y = np.random.standard_normal(N) u1 = L.adjoint_map(y) y2 = y - y.mean() u2 = np.dot(scaling_matrix, np.dot(X.T, y2)) np.testing.assert_almost_equal(u1, u2)
def test_scaling(): """ This test verifies that the normalized transform of affine correctly implements the linear transform that multiplies first by X, then centers. """ # N - number of data points # P - number of columns in design == number of betas N, P = 40, 30 # an arbitrary positive offset for data and design offset = 50 # design - with ones as last column X = np.ones((N, P)) X[:, :-1] = np.random.normal(size=(N, P - 1)) + offset L = rr.normalize(X, center=False, scale=True) # coef for loss scalings = np.sqrt((X**2).sum(0) / N) scaling_matrix = np.diag(1. / scalings) for _ in range(10): beta = np.random.normal(size=(P, )) v = L.linear_map(beta) v2 = np.dot(X, np.dot(scaling_matrix, beta)) v3 = L.affine_map(beta) np.testing.assert_almost_equal(v, v2) np.testing.assert_almost_equal(v, v3) y = np.random.standard_normal(N) u1 = L.adjoint_map(y) u2 = np.dot(scaling_matrix, np.dot(X.T, y)) np.testing.assert_almost_equal(u1, u2)
def test_centering(): """ This test verifies that the normalized transform of affine correctly implements the linear transform that multiplies first by X, then centers. """ # N - number of data points # P - number of columns in design == number of betas N, P = 40, 30 # an arbitrary positive offset for data and design offset = 50 # design - with ones as last column X = np.ones((N, P)) X[:, :-1] = np.random.normal(size=(N, P - 1)) + offset X2 = X - X.mean(axis=0)[np.newaxis, :] L = rr.normalize(X, center=True, scale=False) # coef for loss for _ in range(10): beta = np.random.normal(size=(P, )) v = L.linear_map(beta) v2 = np.dot(X, beta) v2 -= v2.mean() v3 = np.dot(X2, beta) v4 = L.affine_map(beta) np.testing.assert_almost_equal(v, v3) np.testing.assert_almost_equal(v, v2) np.testing.assert_almost_equal(v, v4) y = np.random.standard_normal(N) u1 = L.adjoint_map(y) y2 = y - y.mean() u2 = np.dot(X.T, y2) np.testing.assert_almost_equal(u1, u2)
def test_scaling_and_centering(): """ This test verifies that the normalized transform of affine correctly implements the linear transform that multiplies first by X, then centers. """ # N - number of data points # P - number of columns in design == number of betas N, P = 40, 30 # an arbitrary positive offset for data and design offset = 50 # design - with no colum of ones! X = np.random.normal(size=(N,P)) + offset L = rr.normalize(X, center=True, scale=True) # the default # coef for loss scalings = np.std(X, 0) scaling_matrix = np.diag(1./scalings) for _ in range(10): beta = np.random.normal(size=(P,)) v = L.linear_map(beta) v2 = np.dot(X, np.dot(scaling_matrix, beta)) v2 -= v2.mean() np.testing.assert_almost_equal(v, v2) y = np.random.standard_normal(N) u1 = L.adjoint_map(y) y2 = y - y.mean() u2 = np.dot(scaling_matrix, np.dot(X.T, y2)) np.testing.assert_almost_equal(u1, u2)
def test_centering(): """ This test verifies that the normalized transform of affine correctly implements the linear transform that multiplies first by X, then centers. """ # N - number of data points # P - number of columns in design == number of betas N, P = 40, 30 # an arbitrary positive offset for data and design offset = 50 # design - with ones as last column X = np.ones((N,P)) X[:,:-1] = np.random.normal(size=(N,P-1)) + offset X2 = X - X.mean(axis=0)[np.newaxis,:] L = rr.normalize(X, center=True, scale=False) # coef for loss for _ in range(10): beta = np.random.normal(size=(P,)) v = L.linear_map(beta) v2 = np.dot(X, beta) v2 -= v2.mean() v3 = np.dot(X2, beta) v4 = L.affine_map(beta) np.testing.assert_almost_equal(v, v3) np.testing.assert_almost_equal(v, v2) np.testing.assert_almost_equal(v, v4) y = np.random.standard_normal(N) u1 = L.adjoint_map(y) y2 = y - y.mean() u2 = np.dot(X.T, y2) np.testing.assert_almost_equal(u1, u2)
def test_scaling(): """ This test verifies that the normalized transform of affine correctly implements the linear transform that multiplies first by X, then centers. """ # N - number of data points # P - number of columns in design == number of betas N, P = 40, 30 # an arbitrary positive offset for data and design offset = 50 # design - with ones as last column X = np.ones((N,P)) X[:,:-1] = np.random.normal(size=(N,P-1)) + offset L = rr.normalize(X, center=False, scale=True) # coef for loss scalings = np.sqrt((X**2).sum(0) / N) scaling_matrix = np.diag(1./scalings) for _ in range(10): beta = np.random.normal(size=(P,)) v = L.linear_map(beta) v2 = np.dot(X, np.dot(scaling_matrix, beta)) v3 = L.affine_map(beta) np.testing.assert_almost_equal(v, v2) np.testing.assert_almost_equal(v, v3) y = np.random.standard_normal(N) u1 = L.adjoint_map(y) u2 = np.dot(scaling_matrix, np.dot(X.T, y)) np.testing.assert_almost_equal(u1, u2)
def test_path_group_lasso(): ''' this test looks at the paths of three different parameterizations of the same problem ''' n = 100 X = np.random.standard_normal((n, 10)) U = np.random.standard_normal((n, 2)) Y = np.random.standard_normal(100) betaX = np.array([3, 4, 5, 0, 0] + [0] * 5) betaU = np.array([10, -5]) Y += (np.dot(X, betaX) + np.dot(U, betaU)) * 5 Xn = rr.normalize(np.hstack([np.ones((100, 1)), X]), inplace=True, center=True, scale=True, intercept_column=0).normalized_array() lasso = mixed_lasso.mixed_lasso_path.gaussian(Xn[:, 1:], Y, penalty_structure=[0] * 7 + [1] * 3, nstep=10) sol = lasso.main(inner_tol=1.e-12, verbose=True) beta = np.array(sol['beta'].todense()) sols = [] sols_sep = [] for l in sol['lagrange']: loss = rr.glm.gaussian(Xn, Y) penalty = rr.mixed_lasso([mixed_lasso.UNPENALIZED] + [0] * 7 + [1] * 3, lagrange=l) # matrix contains an intercept... problem = rr.simple_problem(loss, penalty) sols.append(problem.solve(tol=1.e-12).copy()) sep = rr.separable((11, ), [ rr.l2norm((7, ), np.sqrt(7) * l), rr.l2norm((3, ), np.sqrt(3) * l) ], [np.arange(1, 8), np.arange(8, 11)]) sep_problem = rr.simple_problem(loss, sep) sols_sep.append(sep_problem.solve(tol=1.e-12).copy()) sols = np.array(sols).T sols_sep = np.array(sols_sep).T nt.assert_true( np.linalg.norm(beta - sols) / (1 + np.linalg.norm(beta)) <= 1.e-4) nt.assert_true( np.linalg.norm(beta - sols_sep) / (1 + np.linalg.norm(beta)) <= 1.e-4)
def test_path_group_lasso(): """ this test looks at the paths of three different parameterizations of the same problem """ n = 100 X = np.random.standard_normal((n, 10)) U = np.random.standard_normal((n, 2)) Y = np.random.standard_normal(100) betaX = np.array([3, 4, 5, 0, 0] + [0] * 5) betaU = np.array([10, -5]) Y += (np.dot(X, betaX) + np.dot(U, betaU)) * 5 Xn = rr.normalize( np.hstack([np.ones((100, 1)), X]), inplace=True, center=True, scale=True, intercept_column=0 ).normalized_array() lasso = rr.lasso.squared_error(Xn[:, 1:], Y, penalty_structure=[0] * 7 + [1] * 3, nstep=10) sol = lasso.main(inner_tol=1.0e-12, verbose=True) beta = np.array(sol["beta"].todense()) sols = [] sols_sep = [] for l in sol["lagrange"]: loss = rr.squared_error(Xn, Y, coef=1.0 / n) penalty = rr.mixed_lasso([rr.UNPENALIZED] + [0] * 7 + [1] * 3, lagrange=l) # matrix contains an intercept... problem = rr.simple_problem(loss, penalty) sols.append(problem.solve(tol=1.0e-12).copy()) sep = rr.separable( (11,), [rr.l2norm((7,), np.sqrt(7) * l), rr.l2norm((3,), np.sqrt(3) * l)], [np.arange(1, 8), np.arange(8, 11)], ) sep_problem = rr.simple_problem(loss, sep) sols_sep.append(sep_problem.solve(tol=1.0e-12).copy()) sols = np.array(sols).T sols_sep = np.array(sols_sep).T nt.assert_true(np.linalg.norm(beta - sols) / (1 + np.linalg.norm(beta)) <= 1.0e-4) nt.assert_true(np.linalg.norm(beta - sols_sep) / (1 + np.linalg.norm(beta)) <= 1.0e-4)
def test_normalize_intercept(): for issparse, value, inplace, intercept_column, scale, center in product( [False, True], [1, 3], [False, True], [None, 2], [True, False], [True, False]): print(issparse, value, inplace, intercept_column, scale, center) if not (issparse and inplace): X = np.random.standard_normal((20, 6)) if intercept_column is not None: X[:, intercept_column] = 1 Y = X.copy() if issparse: X = scipy.sparse.csr_matrix(X) Xn = rr.normalize(X, value=value, inplace=inplace, intercept_column=intercept_column, scale=scale, center=center) if intercept_column is not None: v = np.zeros(Y.shape[1]) v[intercept_column] = 4 yield np.testing.assert_allclose, Xn.linear_map( v), 4 * np.ones(Y.shape[0]) if scale and center: Y -= Y.mean(0)[None, :] Y /= Y.std(0)[None, :] Y *= np.sqrt(value) if intercept_column is not None: Y[:, intercept_column] = 1 elif scale and not center: Y /= (np.sqrt((Y**2).sum(0))[None, :] / np.sqrt(Y.shape[0])) Y *= np.sqrt(value) if intercept_column is not None: Y[:, intercept_column] = 1 elif center and not scale: Y -= Y.mean(0)[None, :] if intercept_column is not None: Y[:, intercept_column] = 1 V = np.random.standard_normal((20, 3)) U = np.random.standard_normal((6, 4)) Xn.adjoint_map(V) yield np.testing.assert_allclose, np.dot(Y, U), Xn.linear_map( np.array(U)) yield np.testing.assert_allclose, np.dot(Y, U), Xn.affine_map( np.array(U)) yield np.testing.assert_allclose, np.dot(Y, U[:, 0]), Xn.linear_map( np.array(U[:, 0])) yield np.testing.assert_allclose, np.dot(Y, U[:, 0]), Xn.affine_map( np.array(U[:, 0])) yield np.testing.assert_allclose, np.dot(Y.T, V), Xn.adjoint_map(V) yield nt.assert_raises, ValueError, Xn.linear_map, np.zeros( (6, 4, 3)) X2 = Xn.slice_columns(list(range(3))) Y2 = Y[:, :3] U2 = np.random.standard_normal((3, 4)) V2 = np.random.standard_normal(20) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.linear_map( np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.affine_map( np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2[:, 0]), X2.linear_map( np.array(U2[:, 0])) yield np.testing.assert_allclose, np.dot(Y2, U2[:, 0]), X2.affine_map( np.array(U2[:, 0])) yield np.testing.assert_allclose, np.dot(Y2.T, V2), X2.adjoint_map(V2) X2 = Xn.slice_columns(list(range(3, 6))) Y2 = Y[:, 3:] U2 = np.random.standard_normal((3, 4)) V2 = np.random.standard_normal(20) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.linear_map( np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.affine_map( np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2[:, 0]), X2.linear_map( np.array(U2[:, 0])) yield np.testing.assert_allclose, np.dot(Y2, U2[:, 0]), X2.affine_map( np.array(U2[:, 0])) yield np.testing.assert_allclose, np.dot(Y2.T, V2), X2.adjoint_map(V2) keep = np.zeros(6, np.bool) keep[:3] = 1 X2 = Xn.slice_columns(keep) Y2 = Y[:, :3] U2 = np.random.standard_normal((3, 4)) V2 = np.random.standard_normal(20) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.linear_map( np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.affine_map( np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2[:, 0]), X2.linear_map( np.array(U2[:, 0])) yield np.testing.assert_allclose, np.dot(Y2, U2[:, 0]), X2.affine_map( np.array(U2[:, 0])) yield np.testing.assert_allclose, np.dot(Y2.T, V2), X2.adjoint_map(V2) yield nt.assert_raises, ValueError, rr.normalize, scipy.sparse.csr_matrix( Y), True, True, 1, True
def test_centering_fit_inplace(debug=False): # N - number of data points # P - number of columns in design == number of betas N, P = 40, 30 # an arbitrary positive offset for data and design offset = 2 # design - with ones as last column X = np.random.normal(size=(N, P)) + offset L = rr.normalize(X, center=True, scale=False, inplace=True) # X should have been normalized in place np.testing.assert_almost_equal(np.sum(X, 0), 0) # data Y = np.random.normal(size=(N, )) + offset # coef for loss coef = 0.5 # lagrange for penalty lagrange = .1 # Loss function (squared difference between fitted and actual data) loss = rr.quadratic_loss.affine(L, -Y, coef=coef) penalties = [ rr.constrained_positive_part(25, lagrange=lagrange), rr.nonnegative(5) ] groups = [slice(0, 25), slice(25, 30)] penalty = rr.separable((P, ), penalties, groups) initial = np.random.standard_normal(P) composite_form = rr.separable_problem.fromatom(penalty, loss) solver = rr.FISTA(composite_form) solver.debug = debug solver.fit(tol=1.0e-12, min_its=200) coefs = solver.composite.coefs # Solve the problem with X, which has been normalized in place loss2 = rr.quadratic_loss.affine(X, -Y, coef=coef) initial2 = np.random.standard_normal(P) composite_form2 = rr.separable_problem.fromatom(penalty, loss2) solver2 = rr.FISTA(composite_form2) solver2.debug = debug solver2.fit(tol=1.0e-12, min_its=200) coefs2 = solver2.composite.coefs for _ in range(10): beta = np.random.standard_normal(P) g1 = loss.smooth_objective(beta, mode='grad') g2 = loss2.smooth_objective(beta, mode='grad') np.testing.assert_almost_equal(g1, g2) b1 = penalty.proximal(sq(1, beta, g1, 0)) b2 = penalty.proximal(sq(1, beta, g2, 0)) np.testing.assert_almost_equal(b1, b2) f1 = composite_form.objective(beta) f2 = composite_form2.objective(beta) np.testing.assert_almost_equal(f1, f2) np.testing.assert_almost_equal(composite_form.objective(coefs), composite_form.objective(coefs2)) np.testing.assert_almost_equal(composite_form2.objective(coefs), composite_form2.objective(coefs2)) nt.assert_true( np.linalg.norm(coefs - coefs2) / max(np.linalg.norm(coefs), 1) < 1.0e-04)
def test_centering_fit_inplace(debug=False): # N - number of data points # P - number of columns in design == number of betas N, P = 40, 30 # an arbitrary positive offset for data and design offset = 2 # design - with ones as last column X = np.random.normal(size=(N,P)) + offset L = rr.normalize(X, center=True, scale=False, inplace=True) # X should have been normalized in place np.testing.assert_almost_equal(np.sum(X, 0), 0) # data Y = np.random.normal(size=(N,)) + offset # coef for loss coef = 0.5 # lagrange for penalty lagrange = .1 # Loss function (squared difference between fitted and actual data) loss = rr.quadratic.affine(L, -Y, coef=coef) penalties = [rr.constrained_positive_part(25, lagrange=lagrange), rr.nonnegative(5)] groups = [slice(0,25), slice(25,30)] penalty = rr.separable((P,), penalties, groups) initial = np.random.standard_normal(P) composite_form = rr.separable_problem.fromatom(penalty, loss) solver = rr.FISTA(composite_form) solver.debug = debug solver.fit(tol=1.0e-12, min_its=200) coefs = solver.composite.coefs # Solve the problem with X, which has been normalized in place loss2 = rr.quadratic.affine(X, -Y, coef=coef) initial2 = np.random.standard_normal(P) composite_form2 = rr.separable_problem.fromatom(penalty, loss2) solver2 = rr.FISTA(composite_form2) solver2.debug = debug solver2.fit(tol=1.0e-12, min_its=200) coefs2 = solver2.composite.coefs for _ in range(10): beta = np.random.standard_normal(P) g1 = loss.smooth_objective(beta, mode='grad') g2 = loss2.smooth_objective(beta, mode='grad') np.testing.assert_almost_equal(g1, g2) b1 = penalty.proximal(sq(1, beta, g1,0)) b2 = penalty.proximal(sq(1, beta, g2,0)) np.testing.assert_almost_equal(b1, b2) f1 = composite_form.objective(beta) f2 = composite_form2.objective(beta) np.testing.assert_almost_equal(f1, f2) np.testing.assert_almost_equal(composite_form.objective(coefs), composite_form.objective(coefs2)) np.testing.assert_almost_equal(composite_form2.objective(coefs), composite_form2.objective(coefs2)) nt.assert_true(np.linalg.norm(coefs - coefs2) / max(np.linalg.norm(coefs),1) < 1.0e-04)
def test_normalize_intercept(): for issparse, value, inplace, intercept_column, scale, center in product([False, True], [1,3], [False, True], [None, 2], [True, False], [True, False]): print (issparse, value, inplace, intercept_column, scale, center) if not (issparse and inplace): X = np.random.standard_normal((20,6)) if intercept_column is not None: X[:,intercept_column] = 1 Y = X.copy() if issparse: X = scipy.sparse.csr_matrix(X) Xn = rr.normalize(X, value=value, inplace=inplace, intercept_column=intercept_column, scale=scale, center=center) if intercept_column is not None: v = np.zeros(Y.shape[1]) v[intercept_column] = 4 yield np.testing.assert_allclose, Xn.linear_map(v), 4 * np.ones(Y.shape[0]) if scale and center: Y -= Y.mean(0)[None,:] Y /= Y.std(0)[None,:] Y *= np.sqrt(value) if intercept_column is not None: Y[:,intercept_column] = 1 elif scale and not center: Y /= (np.sqrt((Y**2).sum(0))[None,:] / np.sqrt(Y.shape[0])) Y *= np.sqrt(value) if intercept_column is not None: Y[:,intercept_column] = 1 elif center and not scale: Y -= Y.mean(0)[None,:] if intercept_column is not None: Y[:,intercept_column] = 1 V = np.random.standard_normal((20, 3)) U = np.random.standard_normal((6,4)) Xn.adjoint_map(V) yield np.testing.assert_allclose, np.dot(Y, U), Xn.linear_map(np.array(U)) yield np.testing.assert_allclose, np.dot(Y, U), Xn.affine_map(np.array(U)) yield np.testing.assert_allclose, np.dot(Y, U[:,0]), Xn.linear_map(np.array(U[:,0])) yield np.testing.assert_allclose, np.dot(Y, U[:,0]), Xn.affine_map(np.array(U[:,0])) yield np.testing.assert_allclose, np.dot(Y.T, V), Xn.adjoint_map(V) yield nt.assert_raises, ValueError, Xn.linear_map, np.zeros((6,4,3)) X2 = Xn.slice_columns(list(range(3))) Y2 = Y[:,:3] U2 = np.random.standard_normal((3,4)) V2 = np.random.standard_normal(20) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.linear_map(np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.affine_map(np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2[:,0]), X2.linear_map(np.array(U2[:,0])) yield np.testing.assert_allclose, np.dot(Y2, U2[:,0]), X2.affine_map(np.array(U2[:,0])) yield np.testing.assert_allclose, np.dot(Y2.T, V2), X2.adjoint_map(V2) X2 = Xn.slice_columns(list(range(3,6))) Y2 = Y[:,3:] U2 = np.random.standard_normal((3,4)) V2 = np.random.standard_normal(20) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.linear_map(np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.affine_map(np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2[:,0]), X2.linear_map(np.array(U2[:,0])) yield np.testing.assert_allclose, np.dot(Y2, U2[:,0]), X2.affine_map(np.array(U2[:,0])) yield np.testing.assert_allclose, np.dot(Y2.T, V2), X2.adjoint_map(V2) keep = np.zeros(6, np.bool) keep[:3] = 1 X2 = Xn.slice_columns(keep) Y2 = Y[:,:3] U2 = np.random.standard_normal((3,4)) V2 = np.random.standard_normal(20) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.linear_map(np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2), X2.affine_map(np.array(U2)) yield np.testing.assert_allclose, np.dot(Y2, U2[:,0]), X2.linear_map(np.array(U2[:,0])) yield np.testing.assert_allclose, np.dot(Y2, U2[:,0]), X2.affine_map(np.array(U2[:,0])) yield np.testing.assert_allclose, np.dot(Y2.T, V2), X2.adjoint_map(V2) yield nt.assert_raises, ValueError, rr.normalize, scipy.sparse.csr_matrix(Y), True, True, 1, True
def test_normalize_intercept(): for value in [1,3]: # test of intercept column = 2 X = np.random.standard_normal((10,3)) X[:,2] = 1 Y = X.copy() Xn = rr.normalize(X, intercept_column=2, value=value) Y[:,1] -= Y[:,1].mean() Y[:,0] -= Y[:,0].mean() Y[:,1] /= np.std(Y[:,1]) Y[:,0] /= np.std(Y[:,0]) Y *= np.sqrt(value) np.testing.assert_allclose(np.dot(Y, [2,4,6]), Xn.linear_map(np.array([2,4,6]))) # test of intercept column = 2, no scaling X = np.random.standard_normal((10,3)) X[:,2] = 1 Y = X.copy() Xn = rr.normalize(X, intercept_column=2, scale=False) Y[:,1] -= Y[:,1].mean() Y[:,0] -= Y[:,0].mean() np.testing.assert_allclose(np.dot(Y, [2,4,6]), Xn.linear_map(np.array([2,4,6]))) # test of intercept column = 2, no centering X = np.random.standard_normal((10,3)) X[:,2] = 1 Y = X.copy() Xn = rr.normalize(X, intercept_column=2, center=False, value=value) Y[:,1] /= (np.linalg.norm(Y[:,1]) / np.sqrt(Y.shape[0])) Y[:,0] /= (np.linalg.norm(Y[:,0]) / np.sqrt(Y.shape[0])) Y *= np.sqrt(value) np.testing.assert_allclose(np.dot(Y, [2,4,6]), Xn.linear_map(np.array([2,4,6]))) # test of no intercept column, no scaling X = np.random.standard_normal((10,3)) Y = X.copy() Xn = rr.normalize(X, intercept_column=None, scale=False) Y[:,2] -= Y[:,2].mean() Y[:,1] -= Y[:,1].mean() Y[:,0] -= Y[:,0].mean() np.testing.assert_allclose(np.dot(Y, [2,4,6]), Xn.linear_map(np.array([2,4,6]))) # test of no intercept column, no centering X = np.random.standard_normal((10,3)) Y = X.copy() Xn = rr.normalize(X, intercept_column=None, center=False, value=value) Y[:,2] /= (np.linalg.norm(Y[:,2]) / np.sqrt(Y.shape[0])) Y[:,1] /= (np.linalg.norm(Y[:,1]) / np.sqrt(Y.shape[0])) Y[:,0] /= (np.linalg.norm(Y[:,0]) / np.sqrt(Y.shape[0])) Y *= np.sqrt(value) np.testing.assert_allclose(np.dot(Y, [2,4,6]), Xn.linear_map(np.array([2,4,6]))) # test of no intercept column, no centering X = np.random.standard_normal((10,3)) Y = X.copy() Xn = rr.normalize(X, intercept_column=None, value=value) Y[:,2] -= Y[:,2].mean() Y[:,1] -= Y[:,1].mean() Y[:,0] -= Y[:,0].mean() Y[:,2] /= (np.linalg.norm(Y[:,2]) / np.sqrt(Y.shape[0])) Y[:,1] /= (np.linalg.norm(Y[:,1]) / np.sqrt(Y.shape[0])) Y[:,0] /= (np.linalg.norm(Y[:,0]) / np.sqrt(Y.shape[0])) Y *= np.sqrt(value) np.testing.assert_allclose(np.dot(Y, [2,4,6]), Xn.linear_map(np.array([2,4,6])))
def test_scaling_and_centering_intercept_fit(debug=False): # N - number of data points # P - number of columns in design == number of betas N, P = 40, 30 # an arbitrary positive offset for data and design offset = 2 # design - with ones as last column X = np.random.normal(size=(N, P)) + 0 * offset X2 = X - X.mean(0)[None, :] X2 = X2 / np.std(X2, 0, ddof=1)[None, :] X2 = np.hstack([np.ones((X2.shape[0], 1)), X2]) L = rr.normalize(X, center=True, scale=True, intercept=True) # data Y = np.random.normal(size=(N, )) + offset # lagrange for penalty lagrange = .1 # Loss function (squared difference between fitted and actual data) loss = rr.squared_error(L, Y) penalties = [ rr.constrained_positive_part(25, lagrange=lagrange), rr.nonnegative(5) ] groups = [slice(0, 25), slice(25, 30)] penalty = rr.separable((P + 1, ), penalties, groups) initial = np.random.standard_normal(P + 1) composite_form = rr.separable_problem.fromatom(penalty, loss) solver = rr.FISTA(composite_form) solver.debug = debug solver.fit(tol=1.0e-12, min_its=200) coefs = solver.composite.coefs # Solve the problem with X2 loss2 = rr.squared_error(X2, Y) initial2 = np.random.standard_normal(P + 1) composite_form2 = rr.separable_problem.fromatom(penalty, loss2) solver2 = rr.FISTA(composite_form2) solver2.debug = debug solver2.fit(tol=1.0e-12, min_its=200) coefs2 = solver2.composite.coefs for _ in range(10): beta = np.random.standard_normal(P + 1) g1 = loss.smooth_objective(beta, mode='grad') g2 = loss2.smooth_objective(beta, mode='grad') np.testing.assert_almost_equal(g1, g2) b1 = penalty.proximal(sq(1, beta, g1, 0)) b2 = penalty.proximal(sq(1, beta, g2, 0)) np.testing.assert_almost_equal(b1, b2) f1 = composite_form.objective(beta) f2 = composite_form2.objective(beta) np.testing.assert_almost_equal(f1, f2) np.testing.assert_almost_equal(composite_form.objective(coefs), composite_form.objective(coefs2)) np.testing.assert_almost_equal(composite_form2.objective(coefs), composite_form2.objective(coefs2)) nt.assert_true( np.linalg.norm(coefs - coefs2) / max(np.linalg.norm(coefs), 1) < 1.0e-04)
def test_normalize_intercept(): for value in [1, 3]: # test of intercept column = 2 X = np.random.standard_normal((10, 3)) X[:, 2] = 1 Y = X.copy() Xn = rr.normalize(X, intercept_column=2, value=value) Y[:, 1] -= Y[:, 1].mean() Y[:, 0] -= Y[:, 0].mean() Y[:, 1] /= np.std(Y[:, 1]) Y[:, 0] /= np.std(Y[:, 0]) Y *= np.sqrt(value) np.testing.assert_allclose(np.dot(Y, [2, 4, 6]), Xn.linear_map(np.array([2, 4, 6]))) # test of intercept column = 2, no scaling X = np.random.standard_normal((10, 3)) X[:, 2] = 1 Y = X.copy() Xn = rr.normalize(X, intercept_column=2, scale=False) Y[:, 1] -= Y[:, 1].mean() Y[:, 0] -= Y[:, 0].mean() np.testing.assert_allclose(np.dot(Y, [2, 4, 6]), Xn.linear_map(np.array([2, 4, 6]))) # test of intercept column = 2, no centering X = np.random.standard_normal((10, 3)) X[:, 2] = 1 Y = X.copy() Xn = rr.normalize(X, intercept_column=2, center=False, value=value) Y[:, 1] /= (np.linalg.norm(Y[:, 1]) / np.sqrt(Y.shape[0])) Y[:, 0] /= (np.linalg.norm(Y[:, 0]) / np.sqrt(Y.shape[0])) Y *= np.sqrt(value) np.testing.assert_allclose(np.dot(Y, [2, 4, 6]), Xn.linear_map(np.array([2, 4, 6]))) # test of no intercept column, no scaling X = np.random.standard_normal((10, 3)) Y = X.copy() Xn = rr.normalize(X, intercept_column=None, scale=False) Y[:, 2] -= Y[:, 2].mean() Y[:, 1] -= Y[:, 1].mean() Y[:, 0] -= Y[:, 0].mean() np.testing.assert_allclose(np.dot(Y, [2, 4, 6]), Xn.linear_map(np.array([2, 4, 6]))) # test of no intercept column, no centering X = np.random.standard_normal((10, 3)) Y = X.copy() Xn = rr.normalize(X, intercept_column=None, center=False, value=value) Y[:, 2] /= (np.linalg.norm(Y[:, 2]) / np.sqrt(Y.shape[0])) Y[:, 1] /= (np.linalg.norm(Y[:, 1]) / np.sqrt(Y.shape[0])) Y[:, 0] /= (np.linalg.norm(Y[:, 0]) / np.sqrt(Y.shape[0])) Y *= np.sqrt(value) np.testing.assert_allclose(np.dot(Y, [2, 4, 6]), Xn.linear_map(np.array([2, 4, 6]))) # test of no intercept column, no centering X = np.random.standard_normal((10, 3)) Y = X.copy() Xn = rr.normalize(X, intercept_column=None, value=value) Y[:, 2] -= Y[:, 2].mean() Y[:, 1] -= Y[:, 1].mean() Y[:, 0] -= Y[:, 0].mean() Y[:, 2] /= (np.linalg.norm(Y[:, 2]) / np.sqrt(Y.shape[0])) Y[:, 1] /= (np.linalg.norm(Y[:, 1]) / np.sqrt(Y.shape[0])) Y[:, 0] /= (np.linalg.norm(Y[:, 0]) / np.sqrt(Y.shape[0])) Y *= np.sqrt(value) np.testing.assert_allclose(np.dot(Y, [2, 4, 6]), Xn.linear_map(np.array([2, 4, 6])))