def __init__(self, map, generative_mean, coef=1., offset=None, quadratic=None): self.map = map self.q = map.p - map.nactive self.r = map.p + map.nactive self.p = map.p rr.smooth_atom.__init__(self, (2 * self.p, ), offset=offset, quadratic=quadratic, initial=self.map.feasible_point, coef=coef) self.coefs[:] = self.map.feasible_point opt_vars_0 = np.zeros(self.r, bool) opt_vars_0[self.p:] = 1 opt_vars = np.append(opt_vars_0, np.ones(self.q, bool)) opt_vars_active = np.append(opt_vars_0, np.zeros(self.q, bool)) opt_vars_inactive = np.zeros(2 * self.p, bool) opt_vars_inactive[self.r:] = 1 self._response_selector = rr.selector(~opt_vars, (2 * self.p, )) self._opt_selector_active = rr.selector(opt_vars_active, (2 * self.p, )) self._opt_selector_inactive = rr.selector(opt_vars_inactive, (2 * self.p, )) nonnegative = nonnegative_softmax_scaled(self.map.nactive) self.nonnegative_barrier = nonnegative.linear( self._opt_selector_active) cube_objective = smooth_cube_barrier(self.map.inactive_lagrange) self.cube_barrier = rr.affine_smooth(cube_objective, self._opt_selector_inactive) linear_map = np.hstack( [self.map._score_linear_term, self.map._opt_linear_term]) randomization_loss = log_likelihood(np.zeros(self.p), self.map.randomization_cov, self.p) self.randomization_loss = rr.affine_smooth( randomization_loss, rr.affine_transform(linear_map, self.map._opt_affine_term)) likelihood_loss = log_likelihood(generative_mean, self.map.score_cov, self.p) self.likelihood_loss = rr.affine_smooth(likelihood_loss, self._response_selector) self.total_loss = rr.smooth_sum([ self.randomization_loss, self.likelihood_loss, self.nonnegative_barrier, self.cube_barrier ])
def sel_prob_smooth_objective(self, param, mode='both', check_feasibility=False): param = self.apply_offset(param) data = np.squeeze(self.t * self.map.A) offset_active = self.map.offset_active + data[:self.map.nactive] offset_inactive = self.map.offset_inactive + data[self.map.nactive:] active_conj_loss = rr.affine_smooth(self.active_conjugate, rr.affine_transform(self.map.B_active, offset_active)) cube_loss = neg_log_cube_probability_fs(self.q, offset_inactive, randomization_scale = self.map.randomization_scale) total_loss = rr.smooth_sum([active_conj_loss, cube_loss, self.nonnegative_barrier]) if mode == 'func': f = total_loss.smooth_objective(param, 'func') return self.scale(f) elif mode == 'grad': g = total_loss.smooth_objective(param, 'grad') return self.scale(g) elif mode == 'both': f, g = total_loss.smooth_objective(param, 'both') return self.scale(f), self.scale(g) else: raise ValueError("mode incorrectly specified")
def randomize(self, loss, epsilon=0): """ Randomize the loss. """ randomized_loss = rr.smooth_sum([loss]) _randomZ = self.sample() randomized_loss.quadratic = rr.identity_quadratic( epsilon, 0, -_randomZ, 0) return randomized_loss
def randomize(self, loss, epsilon=0, perturb=None): """ Randomize the loss. """ randomized_loss = rr.smooth_sum([loss]) if perturb is None: perturb = self.sample() randomized_loss.quadratic = rr.identity_quadratic( epsilon, 0, -perturb, 0) return randomized_loss, perturb
def __init__(self, y, grad_map, prior_variance, coef=1., offset=None, quadratic=None, nstep=10): generative_X = grad_map.generative_X self.param_shape = generative_X.shape[1] y = np.squeeze(y) E_1 = grad_map.E_1 E_2 = grad_map.E_2 self.E = E_2 self.generative_X = grad_map.generative_X initial = np.zeros(self.E) #initial[:E_1] = np.squeeze(grad_map.feasible_point[:E_1]* grad_map.active_signs_1[None,:]) initial = np.squeeze(grad_map.feasible_point[E_1:] * grad_map.active_signs_2[None, :]) rr.smooth_atom.__init__(self, (self.param_shape, ), offset=offset, quadratic=quadratic, initial=initial, coef=coef) self.coefs[:] = initial noise_variance = grad_map.noise_variance self.set_likelihood(y, noise_variance, generative_X) self.set_prior(prior_variance) self.initial_state = initial self.total_loss = rr.smooth_sum( [self.likelihood_loss, self.log_prior_loss, grad_map])
def __init__(self, y, grad_map, prior_variance, coef=1., offset=None, quadratic=None, nstep=10): generative_X = grad_map.generative_X self.param_shape = generative_X.shape[1] y = np.squeeze(y) self.E = grad_map.E self.generative_X = grad_map.generative_X initial = np.zeros(self.E) rr.smooth_atom.__init__(self, (self.param_shape,), offset=offset, quadratic=quadratic, initial=initial, coef=coef) self.coefs[:] = initial noise_variance = grad_map.noise_variance self.set_likelihood(y, noise_variance, generative_X) self.set_prior(prior_variance) self.initial_state = initial self.total_loss_0 = rr.smooth_sum([self.likelihood_loss, self.log_prior_loss, grad_map])
def __init__( self, X, feasible_point, active, # the active set chosen by randomized lasso active_sign, # the set of signs of active coordinates chosen by lasso lagrange, # in R^p mean_parameter, # in R^n noise_variance, #noise_level in data randomizer, #specified randomization epsilon, # ridge penalty for randomized lasso coef=1., offset=None, quadratic=None, nstep=10): n, p = X.shape self._X = X E = active.sum() self.q = p - E self.active = active self.noise_variance = noise_variance self.randomization = randomizer self.inactive_conjugate = self.active_conjugate = randomizer.CGF_conjugate if self.active_conjugate is None: raise ValueError( 'randomization must know its CGF_conjugate -- currently only isotropic_gaussian and laplace are implemented and are assumed to be randomization with IID coordinates' ) initial = np.zeros(n + E, ) initial[n:] = feasible_point self.n = n rr.smooth_atom.__init__(self, (n + E, ), offset=offset, quadratic=quadratic, initial=initial, coef=coef) self.coefs[:] = initial opt_vars = np.zeros(n + E, bool) opt_vars[n:] = 1 nonnegative = nonnegative_softmax_scaled(E) self._opt_selector = rr.selector(opt_vars, (n + E, )) self.nonnegative_barrier = nonnegative.linear(self._opt_selector) self._response_selector = rr.selector(~opt_vars, (n + E, )) self.set_parameter(mean_parameter, noise_variance) X_E = X[:, active] B = X.T.dot(X_E) B_E = B[active] B_mE = B[~active] self.A_active = np.hstack([ -X[:, active].T, (B_E + epsilon * np.identity(E)) * active_sign[None, :] ]) self.A_inactive = np.hstack( [-X[:, ~active].T, (B_mE * active_sign[None, :])]) self.offset_active = active_sign * lagrange[active] self.offset_inactive = np.zeros(p - E) self.active_conj_loss = rr.affine_smooth( self.active_conjugate, rr.affine_transform(self.A_active, self.offset_active)) cube_obj = neg_log_cube_probability(self.q, lagrange[~active], randomization_scale=1.) self.cube_loss = rr.affine_smooth(cube_obj, self.A_inactive) self.total_loss = rr.smooth_sum([ self.active_conj_loss, self.cube_loss, self.likelihood_loss, self.nonnegative_barrier ])
def __init__(self, X, feasible_point, active, # the active set chosen by randomized marginal screening active_signs, # the set of signs of active coordinates chosen by ms threshold, # in R^p mean_parameter, noise_variance, randomizer, coef=1., offset=None, quadratic=None, nstep=10): n, p = X.shape self._X = X E = active.sum() self.q = p - E sigma = np.sqrt(noise_variance) self.active = active self.noise_variance = noise_variance self.randomization = randomizer self.inactive_conjugate = self.active_conjugate = randomizer.CGF_conjugate if self.active_conjugate is None: raise ValueError( 'randomization must know its CGF_conjugate -- currently only isotropic_gaussian and laplace are implemented and are assumed to be randomization with IID coordinates') initial = np.zeros(n + E, ) initial[n:] = feasible_point self.n = n rr.smooth_atom.__init__(self, (n + E,), offset=offset, quadratic=quadratic, initial=initial, coef=coef) self.coefs[:] = initial nonnegative = nonnegative_softmax_scaled(E) opt_vars = np.zeros(n + E, bool) opt_vars[n:] = 1 self._opt_selector = rr.selector(opt_vars, (n + E,)) self.nonnegative_barrier = nonnegative.linear(self._opt_selector) self._response_selector = rr.selector(~opt_vars, (n + E,)) self.set_parameter(mean_parameter, noise_variance) self.A_active = np.hstack([np.true_divide(-X[:, active].T, sigma), np.identity(E) * active_signs[None, :]]) self.A_inactive = np.hstack([np.true_divide(-X[:, ~active].T, sigma), np.zeros((p - E, E))]) self.offset_active = active_signs * threshold[active] self.offset_inactive = np.zeros(p - E) self.active_conj_loss = rr.affine_smooth(self.active_conjugate, rr.affine_transform(self.A_active, self.offset_active)) cube_obj = neg_log_cube_probability(self.q, threshold[~active], randomization_scale=1.) self.cube_loss = rr.affine_smooth(cube_obj, rr.affine_transform(self.A_inactive, self.offset_inactive)) self.total_loss = rr.smooth_sum([self.active_conj_loss, self.cube_loss, self.likelihood_loss, self.nonnegative_barrier])
def __init__( self, X, feasible_point, #in R^{|E|_1 + |E|_2} active_1, #the active set chosen by randomized marginal screening active_2, #the active set chosen by randomized lasso active_signs_1, #the set of signs of active coordinates chosen by ms active_signs_2, #the set of signs of active coordinates chosen by lasso lagrange, #in R^p threshold, #in R^p mean_parameter, # in R^n noise_variance, randomizer, epsilon, #ridge penalty for randomized lasso coef=1., offset=None, quadratic=None, nstep=10): n, p = X.shape self._X = X E_1 = active_1.sum() E_2 = active_2.sum() sigma = np.sqrt(noise_variance) self.active_1 = active_1 self.active_2 = active_2 self.noise_variance = noise_variance self.randomization = randomizer self.inactive_conjugate = self.active_conjugate = randomizer.CGF_conjugate if self.active_conjugate is None: raise ValueError( 'randomization must know its CGF_conjugate -- currently only isotropic_gaussian and laplace are implemented and are assumed to be randomization with IID coordinates' ) initial = np.zeros(n + E_1 + E_2, ) initial[n:] = feasible_point self.n = n rr.smooth_atom.__init__(self, (n + E_1 + E_2, ), offset=offset, quadratic=quadratic, initial=initial, coef=coef) self.coefs[:] = initial nonnegative = nonnegative_softmax_scaled(E_1 + E_2) opt_vars = np.zeros(n + E_1 + E_2, bool) opt_vars[n:] = 1 self._opt_selector = rr.selector(opt_vars, (n + E_1 + E_2, )) self.nonnegative_barrier = nonnegative.linear(self._opt_selector) self._response_selector = rr.selector(~opt_vars, (n + E_1 + E_2, )) self.set_parameter(mean_parameter, noise_variance) arg_ms = np.zeros(self.n + E_1 + E_2, bool) arg_ms[:self.n + E_1] = 1 arg_lasso = np.zeros(self.n + E_1, bool) arg_lasso[:self.n] = 1 arg_lasso = np.append(arg_lasso, np.ones(E_2, bool)) self.A_active_1 = np.hstack([ np.true_divide(-X[:, active_1].T, sigma), np.identity(E_1) * active_signs_1[None, :] ]) self.A_inactive_1 = np.hstack([ np.true_divide(-X[:, ~active_1].T, sigma), np.zeros((p - E_1, E_1)) ]) self.offset_active_1 = active_signs_1 * threshold[active_1] self.offset_inactive_1 = np.zeros(p - E_1) self._active_ms = rr.selector( arg_ms, (self.n + E_1 + E_2, ), rr.affine_transform(self.A_active_1, self.offset_active_1)) self._inactive_ms = rr.selector( arg_ms, (self.n + E_1 + E_2, ), rr.affine_transform(self.A_inactive_1, self.offset_inactive_1)) self.active_conj_loss_1 = rr.affine_smooth(self.active_conjugate, self._active_ms) self.q_1 = p - E_1 cube_obj_1 = neg_log_cube_probability(self.q_1, threshold[~active_1], randomization_scale=1.) self.cube_loss_1 = rr.affine_smooth(cube_obj_1, self._inactive_ms) X_step2 = X[:, active_1] X_E_2 = X_step2[:, active_2] B = X_step2.T.dot(X_E_2) B_E = B[active_2] B_mE = B[~active_2] self.A_active_2 = np.hstack([ -X_step2[:, active_2].T, (B_E + epsilon * np.identity(E_2)) * active_signs_2[None, :] ]) self.A_inactive_2 = np.hstack( [-X_step2[:, ~active_2].T, (B_mE * active_signs_2[None, :])]) self.offset_active_2 = active_signs_2 * lagrange[active_2] self.offset_inactive_2 = np.zeros(E_1 - E_2) self._active_lasso = rr.selector( arg_lasso, (self.n + E_1 + E_2, ), rr.affine_transform(self.A_active_2, self.offset_active_2)) self._inactive_lasso = rr.selector( arg_lasso, (self.n + E_1 + E_2, ), rr.affine_transform(self.A_inactive_2, self.offset_inactive_2)) self.active_conj_loss_2 = rr.affine_smooth(self.active_conjugate, self._active_lasso) self.q_2 = E_1 - E_2 cube_obj_2 = neg_log_cube_probability(self.q_2, lagrange[~active_2], randomization_scale=1.) self.cube_loss_2 = rr.affine_smooth(cube_obj_2, self._inactive_lasso) self.total_loss = rr.smooth_sum([ self.active_conj_loss_1, self.active_conj_loss_2, self.cube_loss_1, self.cube_loss_2, self.likelihood_loss, self.nonnegative_barrier ])
def __init__(self, map, generative_mean, coef=1., offset=None, quadratic=None): self.map = map self.q = map.p - map.nactive self.r = map.p + map.nactive self.p = map.p self.inactive_conjugate = self.active_conjugate = map.randomization.CGF_conjugate if self.active_conjugate is None: raise ValueError( 'randomization must know its CGF_conjugate -- currently only isotropic_gaussian and laplace are implemented and are assumed to be randomization with IID coordinates') self.inactive_lagrange = self.map.inactive_lagrange rr.smooth_atom.__init__(self, (self.r,), offset=offset, quadratic=quadratic, initial=self.map.feasible_point, coef=coef) self.coefs[:] = self.map.feasible_point nonnegative = nonnegative_softmax_scaled(self.map.nactive) opt_vars = np.zeros(self.r, bool) opt_vars[map.p:] = 1 self._opt_selector = rr.selector(opt_vars, (self.r,)) self._response_selector = rr.selector(~opt_vars, (self.r,)) self.nonnegative_barrier = nonnegative.linear(self._opt_selector) self.active_conj_loss = rr.affine_smooth(self.active_conjugate, rr.affine_transform(np.hstack([self.map.A_active, self.map.B_active]), self.map.offset_active)) cube_obj = neg_log_cube_probability(self.q, self.inactive_lagrange, randomization_scale=1.) self.cube_loss = rr.affine_smooth(cube_obj, np.hstack([self.map.A_inactive, self.map.B_inactive])) # w_1, v_1 = np.linalg.eig(self.map.score_cov) # self.score_cov_inv_half = (v_1.T.dot(np.diag(np.power(w_1, -0.5)))).dot(v_1) # likelihood_loss = rr.signal_approximator(np.squeeze(np.zeros(self.p)), coef=1.) # scaled_response_selector = rr.selector(~opt_vars, (self.r,), rr.affine_transform(self.score_cov_inv_half, # self.score_cov_inv_half. # dot(np.squeeze(generative_mean)))) #print("cov", self.map.score_cov.shape ) likelihood_loss = log_likelihood(generative_mean, self.map.score_cov, self.p) self.likelihood_loss = rr.affine_smooth(likelihood_loss, self._response_selector) self.total_loss = rr.smooth_sum([self.active_conj_loss, self.likelihood_loss, self.nonnegative_barrier, self.cube_loss])
def __init__( self, X, feasible_point, active, # the active set chosen by randomized lasso active_sign, # the set of signs of active coordinates chosen by lasso lagrange, # in R^p mean_parameter, # in R^n noise_variance, # noise_level in data randomizer, # specified randomization epsilon, # ridge penalty for randomized lasso coef=1., offset=None, quadratic=None, nstep=10): n, p = X.shape E = active.sum() self._X = X self.active = active self.noise_variance = noise_variance self.randomization = randomizer self.CGF_randomization = randomizer.CGF if self.CGF_randomization is None: raise ValueError( 'randomization must know its cgf -- currently only isotropic_gaussian and laplace are implemented and are assumed to be randomization with IID coordinates' ) self.inactive_lagrange = lagrange[~active] initial = feasible_point self.feasible_point = feasible_point rr.smooth_atom.__init__(self, (p, ), offset=offset, quadratic=quadratic, initial=initial, coef=coef) self.coefs[:] = feasible_point mean_parameter = np.squeeze(mean_parameter) self.active = active X_E = self.X_E = X[:, active] self.X_permute = np.hstack([self.X_E, self._X[:, ~active]]) B = X.T.dot(X_E) B_E = B[active] B_mE = B[~active] self.active_slice = np.zeros_like(active, np.bool) self.active_slice[:active.sum()] = True self.B_active = np.hstack([ (B_E + epsilon * np.identity(E)) * active_sign[None, :], np.zeros((E, p - E)) ]) self.B_inactive = np.hstack( [B_mE * active_sign[None, :], np.identity((p - E))]) self.B_p = np.vstack((self.B_active, self.B_inactive)) self.B_p_inv = np.linalg.inv(self.B_p.T) self.offset_active = active_sign * lagrange[active] self.inactive_subgrad = np.zeros(p - E) self.cube_bool = np.zeros(p, np.bool) self.cube_bool[E:] = 1 self.dual_arg = self.B_p_inv.dot( np.append(self.offset_active, self.inactive_subgrad)) self._opt_selector = rr.selector(~self.cube_bool, (p, )) self.set_parameter(mean_parameter, noise_variance) _barrier_star = barrier_conjugate_softmax_scaled_rr( self.cube_bool, self.inactive_lagrange) self.conjugate_barrier = rr.affine_smooth(_barrier_star, np.identity(p)) self.CGF_randomizer = rr.affine_smooth(self.CGF_randomization, -self.B_p_inv) self.constant = np.true_divide(mean_parameter.dot(mean_parameter), 2 * noise_variance) self.linear_term = rr.identity_quadratic(0, 0, self.dual_arg, -self.constant) self.total_loss = rr.smooth_sum([ self.conjugate_barrier, self.CGF_randomizer, self.likelihood_loss ]) self.total_loss.quadratic = self.linear_term
def __init__(self, X, feasible_point, active, active_sign, mean_parameter, # in R^n noise_variance, randomizer, coef=1., offset=None, quadratic=None, nstep=10): self.n, p = X.shape E = 1 self.q = p-1 self._X = X self.active = active self.noise_variance = noise_variance self.randomization = randomizer self.inactive_conjugate = self.active_conjugate = randomizer.CGF_conjugate if self.active_conjugate is None: raise ValueError( 'randomization must know its CGF_conjugate -- currently only isotropic_gaussian and laplace are implemented and are assumed to be randomization with IID coordinates') initial = np.zeros(self.n + E, ) initial[self.n:] = feasible_point rr.smooth_atom.__init__(self, (self.n + E,), offset=offset, quadratic=quadratic, initial=initial, coef=coef) self.coefs[:] = initial nonnegative = nonnegative_softmax_scaled(E) opt_vars = np.zeros(self.n + E, bool) opt_vars[self.n:] = 1 self._opt_selector = rr.selector(opt_vars, (self.n + E,)) self._response_selector = rr.selector(~opt_vars, (self.n + E,)) self.nonnegative_barrier = nonnegative.linear(self._opt_selector) sign = np.zeros((1, 1)) sign[0:, :] = active_sign self.A_active = np.hstack([-X[:, active].T, sign]) self.active_conj_loss = rr.affine_smooth(self.active_conjugate, self.A_active) self.A_in_1 = np.hstack([-X[:, ~active].T, np.zeros((p - 1, 1))]) self.A_in_2 = np.hstack([np.zeros((self.n, 1)).T, np.ones((1, 1))]) self.A_inactive = np.vstack([self.A_in_1, self.A_in_2]) cube_loss = neg_log_cube_probability_fs(self.q, p) self.cube_loss = rr.affine_smooth(cube_loss, self.A_inactive) self.set_parameter(mean_parameter, noise_variance) self.total_loss = rr.smooth_sum([self.active_conj_loss, self.cube_loss, self.likelihood_loss, self.nonnegative_barrier])