tol\",\n \"= loglike self.nfeature = self.loglike.shape[0] # ridge parameter self.ridge_term =\",\n \"= - self.logdens_linear.dot(target_score_cov.T.dot(prec_target)) ref_hat = [] for k in range(grid.shape[0]):\",\n \"class group_lasso(object): def __init__(self, loglike, groups, weights, ridge_term, randomizer, use_lasso=True,\",\n \"_construct_density(self): precs = {} S = {} r = {}\",\n \"grad_J, hess_J def _check_groups(groups): \\\"\\\"\\\"Make sure that the user-specific groups\",\n \"is None: randomizer_scale = np.sqrt(mean_diag) * 0.5 * np.std(Y) *\",\n \"solve_barrier_affine_jacobian_py(conjugate_arg, precision, feasible_point, con_linear, con_offset, C, active_dirs, useJacobian=True, step=1, nstep=2000,\",\n \"-S.dot(np.multiply(GpC_inv, GpC_inv.T).dot(S.T)) return J, grad_J, hess_J def _check_groups(groups): \\\"\\\"\\\"Make sure\",\n \"self.logdens_linear = logdens_linear return cond_mean, cond_cov, cond_precision, logdens_linear def selective_MLE(self,\",\n \"step *= 0.5 if count >= 40: raise ValueError('not finding\",\n \"0]) mean = self.S[m].dot(mean_parameter[m].reshape((1,))) + self.r[m] _cdf = family.cdf((mean[0] -\",\n \"size of g'th group if pg > 1: Z =\",\n \"minus sign target_linear = target_score_cov.T.dot(prec_target) target_offset = score_offset - target_linear.dot(observed_target)\",\n \"level=0.9): \\\"\\\"\\\" Produce p-values and confidence intervals for targets of\",\n \"to hessian p1 = con_linear.T.dot(np.diag(-1. / ((scaling + con_offset -\",\n \"return p1 + p2 current = feasible_point current_value = np.inf\",\n \"if self.useIP == False: logW = (log_ref - 0.5 *\",\n \"the non-group lasso doesn't self.groups = groups self._initial_omega = perturb\",\n \"optimization density # depends on the score, not how the\",\n \"(np.diag(self.target_cov)[m]).reshape((1, 1)) prec_target = 1. / target_cov_uni target_score_cov_uni = self.target_score_cov[m,\",\n \"offset, self.C, self.active_dirs, useJacobian, **solve_args) final_estimator = target_cov.dot(_prec).dot(observed_target) \\\\ +\",\n \"-self.prec_opt.dot(self.logdens_linear.dot(target_score_cov.T)) implied_mean = np.asscalar(eta.T.dot(cond_mean_grid)) implied_cov = np.asscalar(eta.T.dot(self.cond_cov).dot(eta)) implied_prec = 1./implied_cov\",\n \"def _construct_density(self): precs = {} S = {} r =\",\n \"for barrier function con_offset: offset part of affine constraint used\",\n \"= -(self.loglike.smooth_objective(initial_soln, 'grad') + quad.objective(initial_soln, 'grad')) return initial_soln, initial_subgrad @staticmethod\",\n \"ValueError('no target specified') observed_target = np.atleast_1d(observed_target) prec_target = inv(target_cov) prec_opt\",\n \"logW -= logW.max() self._families.append(discrete_family(self.stat_grid[m], np.exp(logW))) else: approx_fn = interp1d(self.stat_grid[m], log_ref,\",\n \"** 2 / self._W).sum() / (n - XE.shape[1]) cov_target =\",\n \"import randomization from ..base import restricted_estimator from ..algorithms.barrier_affine import solve_barrier_affine_py\",\n \"result, observed_info_mean, log_ref def selected_targets(self, dispersion=None, solve_args={'tol': 1.e-12, 'min_its': 50}):\",\n \"if self.penalty.weights[g] == 0: unpenalized.append(g) else: active_groups.append(g) active_dirs[g] = soln[group_mask]\",\n \"def selected_targets(self, dispersion=None, solve_args={'tol': 1.e-12, 'min_its': 50}): X, y =\",\n \"gaussian(X, Y, groups, weights, sigma=1., quadratic=None, ridge_term=0., perturb=None, use_lasso=True, #\",\n \"# cond_mean is \\\"something\\\" times D # Gamma is target_score_cov.T.dot(prec_target)\",\n \"S self.r = r def solve_barrier_affine_jacobian_py(conjugate_arg, precision, feasible_point, con_linear, con_offset,\",\n \"+ quantile * np.sqrt(np.diag(observed_info_mean))]).T log_ref = val + conjugate_arg.T.dot(cond_cov).dot(conjugate_arg) /\",\n \"an empty array return 0, 0, 0 else: GammaMinus =\",\n \"ridge_term is None: ridge_term = np.std(Y) * np.sqrt(mean_diag) / np.sqrt(n\",\n \"to True perturb=None): _check_groups(groups) # make sure groups looks sensible\",\n \"on score, hence the minus sign target_linear = target_score_cov.T.dot(prec_target) target_offset\",\n \"= collections.OrderedDict(sorted(active_dirs.items())) Vs = [compute_Vg(ug) for ug in sorted_active_dirs.values()] V\",\n \"= opt_linearNoU.dot(U) self.active_dirs = active_dirs self.opt_offset = opt_offset self.ordered_vars =\",\n \"+ observed_target) return np.asarray(lower), np.asarray(upper) ### Private method def _construct_density(self):\",\n \"+ self.opt_offset) self.cond_mean = cond_mean self.cond_cov = cond_cov self.cond_precision =\",\n \"1. / ((self.precs[m])[0, 0]) mean = self.S[m].dot(mean_parameter[m].reshape((1,))) + self.r[m] _cdf\",\n \"grad(gs): p1 = -conjugate_arg + precision.dot(gs) p2 = -con_linear.T.dot(1. /\",\n \"'parameter', parameter) return result def log_reference(self, observed_target, target_cov, target_score_cov, grid):\",\n \"ordered_vars.extend(np.flatnonzero(group_mask)) if self.penalty.weights[g] == 0: unpenalized.append(g) else: active_groups.append(g) active_dirs[g] =\",\n \"summary(self, alternatives=None, parameter=None, level=0.9): \\\"\\\"\\\" Produce p-values and confidence intervals\",\n \"level. \\\"\\\"\\\" if parameter is not None: pivots = self._approx_pivots(parameter,\",\n \"con_linear.dot(gs)) ** 2.))).dot(con_linear) if useJacobian: p2 = - jacobian_grad_hess(gs, C,\",\n \"user-specific groups are ok There are a number of assumptions\",\n \"on to solver level: level of confidence intervals useC: whether\",\n \"= np.sign(self.initial_soln) active = np.flatnonzero(active_signs) self.active = active def compute_Vg(ug):\",\n \"**self.solve_args) gamma_ = _A.dot(soln) + R.dot(self.init_soln) log_jacob = jacobian_grad_hess(gamma_, self.C,\",\n \"np.inf for itercount in range(nstep): cur_grad = grad(current) # make\",\n \"/ 2.) intervals = np.vstack([final_estimator - quantile * np.sqrt(np.diag(observed_info_mean)), final_estimator\",\n \"ordered_groups # exception if no groups are selected if len(self.selection_variable['active_groups'])\",\n \"def calc_GammaMinus(gamma, active_dirs): \\\"\\\"\\\"Calculate Gamma^minus (as a function of gamma\",\n \"import solve_barrier_affine_py as solver from ..distributions.discrete_family import discrete_family class group_lasso(object):\",\n \"lasso doesn't self.groups = groups self._initial_omega = perturb # gaussian\",\n \"(0, 0): # when all groups are size one, C\",\n \"== 0: raise ValueError(\\\"First group is not 0\\\") # check\",\n \"rr.identity_quadratic(self.ridge_term, 0, -self._initial_omega, 0) problem = rr.simple_problem(self.loglike, self.penalty) # if\",\n \"m in range(self.ntarget): p = self.target_score_cov.shape[1] observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni\",\n \"= 2 * np.minimum(pvalues, 1 - pvalues) alpha = 1\",\n \"self.active_dirs, useJacobian, **solve_args) final_estimator = target_cov.dot(_prec).dot(observed_target) \\\\ + target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean -\",\n \"= ndist.ppf(1 - alpha / 2.) intervals = np.vstack([final_estimator -\",\n \"in range(self.ntarget): p = self.target_score_cov.shape[1] observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni =\",\n \"-con_linear.T.dot(1. / (scaling + con_offset - con_linear.dot(gs))) if useJacobian: p3\",\n \"con_linear: linear part of affine constraint used for barrier function\",\n \"optional Sequence of strings describing the alternatives, should be values\",\n \"check array_like agroups = np.array(groups) # check dimension if len(agroups.shape)\",\n \"prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( self.prec_opt).dot(target_lin) _P =\",\n \"group labels tol = 1.e-20 _, self.randomizer_prec = self.randomizer.cov_prec #\",\n \"the conditional mean of optimization variables # vary with target\",\n \"and score of randomized query. solve_args : dict, optional Arguments\",\n \"from scipy.linalg import block_diag from scipy.stats import norm as ndist\",\n \"to_diag = [[g] * (ug.size - 1) for (g, ug)\",\n \"= np.flatnonzero(active_signs) self.active = active def compute_Vg(ug): pg = ug.size\",\n \"np from numpy import log from numpy.linalg import norm, qr,\",\n \"\\\"\\\"\\\" if parameter is not None: pivots = self._approx_pivots(parameter, alternatives=alternatives)\",\n \"the group_lasso. Also, assumes you have already run the fit\",\n \"JacobianPieces: (use self.C defined in fitting) \\\"\\\"\\\" self._setup_implied_gaussian() # Calculate\",\n \"+ C unbiased_estimator = target_cov.dot(_prec).dot(observed_target) + target_cov.dot( _P - target_lin.T.dot(prec_opt).dot(target_off))\",\n \"# should lasso solver be used where applicable - defaults\",\n \"= 1. / scaling def objective(gs): p1 = -gs.T.dot(conjugate_arg) p2\",\n \"jacobian_grad_hess(gamma, C, active_dirs): \\\"\\\"\\\" Calculate the log-Jacobian (scalar), gradient (gamma.size\",\n \"feasible_point current_value = np.inf for itercount in range(nstep): cur_grad =\",\n \"# just the gammas cond_mean = self.cond_mean cond_cov = self.cond_cov\",\n \"variables (model on _setup_implied_gaussian) cond_cov: conditional variance of optimization variables\",\n \"- 1.5 * _scale[j], observed_target[j] + 1.5 * _scale[j], num=ngrid)\",\n \"of the reference density on a grid. \\\"\\\"\\\" if np.asarray(observed_target).shape\",\n \"= gs.T.dot(precision).dot(gs) / 2. if useJacobian: p3 = - jacobian_grad_hess(gs,\",\n \"norm(soln): # is group g appreciably nonzero ordered_groups.append(g) # variables\",\n \"* np.std(Y) * np.sqrt(n / (n - 1.)) randomizer =\",\n \"_prec = prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( self.prec_opt).dot(target_lin)\",\n \"ridge_term=0., perturb=None, use_lasso=True, # should lasso solver be used when\",\n \"groups are size 1 if use_lasso and groups.size == np.unique(groups).size:\",\n \"count += 1 proposal = current - step * cur_grad\",\n \"C)) # inverse #GpC_inv = evectors.dot(np.diag(1 / evalues).dot(evectors.T)) GpC_inv =\",\n \"new perturbation if supplied if perturb is not None: self._initial_omega\",\n \"starts with 0 if not np.amin(agroups) == 0: raise ValueError(\\\"First\",\n \"uses results from that method. Parameters ---------- observed_target: from selected_targets\",\n \"* prec else: cond_precision = self.opt_linear.T.dot(prec.dot(self.opt_linear)) cond_cov = inv(cond_precision) logdens_linear\",\n \"= (self.cond_mean - target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],)) _prec = prec_target + (target_linear.T.dot(target_linear) *\",\n \"['twosided'] * self.ntarget pivot = [] for m in range(self.ntarget):\",\n \"> agroups[1:]) < 0: raise ValueError(\\\"Groups are not sorted\\\") #\",\n \"conditional variance of optimization variables (model on _setup_implied_gaussian) logdens_linear: (model\",\n \"not adapted for the group_lasso. Also, assumes you have already\",\n \"val, soln, hess = solve_barrier_affine_jacobian_py(conjugate_arg, prec_opt, init_soln, linear_part, offset, self.C,\",\n \"np.asarray(upper) ### Private method def _construct_density(self): precs = {} S\",\n \"= {} # dictionary: keys are group labels, values are\",\n \"- logdens_linear.dot(target_linear) target_off = cond_mean - target_lin.dot(observed_target) if np.asarray(self.randomizer_prec).shape in\",\n \"observed_target : ndarray Observed estimate of target. target_cov : ndarray\",\n \"self.observed_target[m]) ** 2 / var_target) logW -= logW.max() self._families.append(discrete_family(grid, np.exp(logW)))\",\n \"gammas as array _beta_unpenalized = restricted_estimator(self.loglike, # refit OLS on\",\n \"self.opt_offset) self.cond_mean = cond_mean self.cond_cov = cond_cov self.cond_precision = cond_precision\",\n \"cond_cov = self.cond_cov logdens_linear = self.logdens_linear linear_part = self.linear_part offset\",\n \"cov_target, crosscov_target_score, alternatives) class approximate_grid_inference(object): def __init__(self, query, dispersion, solve_args={'tol':\",\n \"be in [\\\"twosided\\\", \\\"less\\\", \\\"greater\\\"]') return pivot def _approx_intervals(self, level=0.9):\",\n \"J, grad_J, hess_J def _check_groups(groups): \\\"\\\"\\\"Make sure that the user-specific\",\n \"alternatives=alternatives) lower, upper = self._approx_intervals(level=level) result = pd.DataFrame({'target': self.observed_target, 'pvalue':\",\n \"self._approx_pivots(np.zeros_like(self.observed_target), alternatives=alternatives) lower, upper = self._approx_intervals(level=level) result = pd.DataFrame({'target': self.observed_target,\",\n \"interp1d(self.stat_grid[m], log_ref, kind='quadratic', bounds_error=False, fill_value='extrapolate') grid = np.linspace(self.stat_grid[m].min(), self.stat_grid[m].max(), 1000)\",\n \"block_diag from scipy.stats import norm as ndist from scipy.interpolate import\",\n \"if all groups are size 1 if use_lasso and groups.size\",\n \"= self.cond_precision score_offset = self.observed_score_state + self.opt_offset # target_lin determines\",\n \"if count >= 20: if not (np.isnan(proposed_value) or np.isnan(current_value)): break\",\n \"if relative decrease is small if np.fabs(current_value - proposed_value) <\",\n \"(see existing code)... initial_soln = problem.solve(quad, **solve_args) initial_subgrad = -(self.loglike.smooth_objective(initial_soln,\",\n \"logdens_linear = cond_cov.dot(self.opt_linear.T) * prec else: cond_precision = self.opt_linear.T.dot(prec.dot(self.opt_linear)) cond_cov\",\n \"# do not need to keep setting this if norm(soln[group_mask])\",\n \"logW -= logW.max() self._families.append(discrete_family(grid, np.exp(logW))) def _approx_pivots(self, mean_parameter, alternatives=None): if\",\n \"target_offset = score_offset - target_linear.dot(observed_target) target_lin = - logdens_linear.dot(target_linear) target_off\",\n \"+ quad.objective(initial_soln, 'grad')) return initial_soln, initial_subgrad @staticmethod def gaussian(X, Y,\",\n \"groups are selected if len(self.selection_variable['active_groups']) == 0: return np.sign(soln), soln\",\n \"self.randomizer = randomizer def fit(self, solve_args={'tol': 1.e-12, 'min_its': 50}, perturb=None):\",\n \"* np.sqrt(np.diag(inverse_info)) if useIP == False: ngrid = 1000 self.stat_grid\",\n \"con_offset, C, active_dirs, useJacobian=True, step=1, nstep=2000, min_its=500, tol=1.e-12): \\\"\\\"\\\" This\",\n \"mean of optimization variables # vary with target # logdens_linear\",\n \":] = np.linspace(observed_target[j] - 1.5 * _scale[j], observed_target[j] + 1.5\",\n \"p)) target_linear = target_score_cov_uni.T.dot(prec_target) target_offset = (self.score_offset - target_linear.dot(observed_target_uni)).reshape( (target_linear.shape[0],))\",\n \"= restricted_estimator(self.loglike, # refit OLS on E overall, solve_args=solve_args) beta_bar\",\n \"from numpy.linalg import norm, qr, inv, eig import pandas as\",\n \"= [] # active group labels sorted by label ordered_opt\",\n \"group_mask = self.groups == g soln = self.initial_soln # do\",\n \":].reshape((1, p)) target_linear = target_score_cov_uni.T.dot(prec_target) target_offset = (self.score_offset - target_linear.dot(observed_target_uni)).reshape(\",\n \"solver... (see existing code)... initial_soln = problem.solve(quad, **solve_args) initial_subgrad =\",\n \"observed_target[j] + 1.5 * _scale[j], num=ngrid) else: ngrid = 100\",\n \"= np.linspace(observed_target[j] - 1.5 * _scale[j], observed_target[j] + 1.5 *\",\n \"groups, weights, ridge_term, randomizer, use_lasso, perturb) def _setup_implied_gaussian(self): _, prec\",\n \"labels ordered_vars = [] # indices \\\"ordered\\\" by sorting group\",\n \"this if norm(soln[group_mask]) > tol * norm(soln): # is group\",\n \"linear_part = self.linear_part offset = self.offset if np.asarray(observed_target).shape in [(),\",\n \"<= current_value: break step *= 0.5 if count >= 20:\",\n \"np.issubdtype(agroups.dtype, np.integer): raise TypeError(\\\"Groups are not integers\\\") # check starts\",\n \"defaults to True perturb=None): _check_groups(groups) # make sure groups looks\",\n \"self.randomizer.sample() quad = rr.identity_quadratic(self.ridge_term, 0, -self._initial_omega, 0) problem = rr.simple_problem(self.loglike,\",\n \"1. / target_cov_uni target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) target_linear =\",\n \"= np.atleast_1d(observed_target) prec_target = inv(target_cov) prec_opt = self.cond_precision score_offset =\",\n \"= eig(GammaMinus + C) # log Jacobian #J = log(evalues).sum()\",\n \"None: alternatives = ['twosided'] * self.ntarget pivot = [] for\",\n \"grad(current) # make sure proposal is feasible count = 0\",\n \"np.asscalar(eta.T.dot(cond_mean_grid)) implied_cov = np.asscalar(eta.T.dot(self.cond_cov).dot(eta)) implied_prec = 1./implied_cov _A = self.cond_cov.dot(eta)\",\n \"of strings describing the alternatives, should be values of ['twosided',\",\n \"ug.size - 1)) for ug in active_dirs.values()]) # gradient grad_J\",\n \"final_estimator / np.sqrt(np.diag(observed_info_mean)) pvalues = ndist.cdf(Z_scores) pvalues = 2 *\",\n \"(proposed_value, current_value)) # stop if relative decrease is small if\",\n \"Gaussian # cond_mean is \\\"something\\\" times D # Gamma is\",\n \"/ 2. result = pd.DataFrame({'MLE': final_estimator, 'SE': np.sqrt(np.diag(observed_info_mean)), 'Zvalue': Z_scores,\",\n \"else: Vg = np.zeros((1, 0)) # if the group is\",\n \"query. solve_args : dict, optional Arguments passed to solver. \\\"\\\"\\\"\",\n \"b_scaling (from lasso) solve_args: passed on to solver level: level\",\n \"unpenalized.append(g) else: active_groups.append(g) active_dirs[g] = soln[group_mask] / norm(soln[group_mask]) ordered_opt.append(norm(soln[group_mask])) else:\",\n \"(in self.C) arguments conjugate_arg: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} \\\\bar{\\\\\\\\mu} precision: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} feasible_point: gamma's\",\n \"= _score_linear.dot(self.QI).T * dispersion return (observed_target, cov_target, crosscov_target_score, alternatives) class\",\n \"- target_linear.dot(observed_target_uni)).reshape( (target_linear.shape[0],)) target_lin = -self.logdens_linear.dot(target_linear) target_off = (self.cond_mean -\",\n \"to use python or C solver JacobianPieces: (use self.C defined\",\n \"take a new perturbation if supplied if perturb is not\",\n \"p = X.shape XE = self.XE Q = self.Q observed_target\",\n \"np.array rather than a dictionary weights_np = np.array([w[1] for w\",\n \"solve_args=solve_args) _score_linear = -XE.T.dot(self._W[:, None] * X).T alternatives = ['twosided']\",\n \"the minus sign target_linear = target_score_cov.T.dot(prec_target) target_offset = score_offset -\",\n \"of model including selected features Parameters ---------- query : `gaussian_query`\",\n \"1. / ((self.precs[m])[0, 0]) lower.append(l * var_target + observed_target) upper.append(u\",\n \"with 0 if not np.amin(agroups) == 0: raise ValueError(\\\"First group\",\n \"'lower_confidence': lower, 'upper_confidence': upper}) if not np.all(parameter == 0): result.insert(4,\",\n \"_, prec = self.randomizer.cov_prec if np.asarray(prec).shape in [(), (0,)]: cond_precision\",\n \"self._families.append(discrete_family(self.stat_grid[m], np.exp(logW))) else: approx_fn = interp1d(self.stat_grid[m], log_ref, kind='quadratic', bounds_error=False, fill_value='extrapolate')\",\n \"implied_cov)/ 2. + log_jacob[0]) return np.asarray(ref_hat) def _construct_families(self): self._construct_density() self._families\",\n \"(np.isnan(proposed_value) or np.isnan(current_value)): break else: raise ValueError('value is NaN: %f,\",\n \"useC: whether to use python or C solver JacobianPieces: (use\",\n \"### Private method def _construct_density(self): precs = {} S =\",\n \"ridge_term # group lasso penalty (from regreg) # use regular\",\n \"mean_diag = np.mean((X ** 2).sum(0)) if ridge_term is None: ridge_term\",\n \"= (target_lin.dot(np.atleast_1d(grid[k] - observed_target)) + self.cond_mean) #direction for decomposing o\",\n \"= self.target_score_cov.shape[1] for m in range(self.ntarget): observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni\",\n \"This function checks the user-specified group scheme and raises an\",\n \"targets of model including selected features Parameters ---------- alternatives :\",\n \"= np.asscalar(eta.T.dot(cond_mean_grid)) implied_cov = np.asscalar(eta.T.dot(self.cond_cov).dot(eta)) implied_prec = 1./implied_cov _A =\",\n \"= -con_linear.T.dot(1. / (scaling + con_offset - con_linear.dot(gs))) if useJacobian:\",\n \"a 1-d array_like of integers that are sorted in increasing\",\n \"np.isnan(current_value)): break else: raise ValueError('value is NaN: %f, %f' %\",\n \"when all groups are size one, C will be an\",\n \"1-d array_like of integers that are sorted in increasing order,\",\n \"solve_args=solve_args) # initialize variables active_groups = [] # active group\",\n \"pivots) result.insert(5, 'parameter', parameter) return result def log_reference(self, observed_target, target_cov,\",\n \"XE.shape[1]) cov_target = self.QI * dispersion crosscov_target_score = _score_linear.dot(self.QI).T *\",\n \"XE.T.dot(self._W[:, None] * XE) QI = inv(Q) C = V.T.dot(QI).dot(L).dot(V)\",\n \"target_linear = target_score_cov_uni.T.dot(prec_target) target_offset = (self.score_offset - target_linear.dot(observed_target_uni)).reshape( (target_linear.shape[0],)) target_lin\",\n \"Q, _ = qr(Z) Vg = Q[:, 1:] # drop\",\n \"`gaussian_query` A Gaussian query which has information to describe implied\",\n \"ngrid = 1000 self.stat_grid = np.zeros((ntarget, ngrid)) for j in\",\n \"(observed) value of optimization variables cond_mean: conditional mean of optimization\",\n \"usual D = N + Gamma theta.hat, # target_lin is\",\n \"variables # vary with target # logdens_linear determines how the\",\n \"selected_targets target_cov: from selected_targets target_cov_score: from selected_targets init_soln: (opt_state) initial\",\n \"-= logW.max() self._families.append(discrete_family(self.stat_grid[m], np.exp(logW))) else: approx_fn = interp1d(self.stat_grid[m], log_ref, kind='quadratic',\",\n \"1], 'unbiased': unbiased_estimator}) return result, observed_info_mean, log_ref def selected_targets(self, dispersion=None,\",\n \"1. / ((con_offset - con_linear.dot(gs)) / scaling)).sum() return p1 +\",\n \"ug in sorted_active_dirs.values()] V = block_diag(*Vs) # unpack the list\",\n \"defaults to 0. level : float Confidence level. \\\"\\\"\\\" if\",\n \"hess = inv(precision + barrier_hessian(current)) return current_value, current, hess #\",\n \"of ['twosided', 'less', 'greater'] parameter : np.array Hypothesized value for\",\n \"target_lin.T.dot(prec_opt).dot(target_off)) L = target_lin.T.dot(prec_opt) observed_info_natural = _prec + L.dot(target_lin) -\",\n \"self.loglike.shape[0] # ridge parameter self.ridge_term = ridge_term # group lasso\",\n \"part of affine constraint used for barrier function C: V^T\",\n \"solve_args={'tol': 1.e-12, 'min_its': 50}, perturb=None): # solve the randomized version\",\n \"# make sure proposal is a descent count = 0\",\n \"query.selected_targets(dispersion) self.observed_target = observed_target self.target_score_cov = target_score_cov self.target_cov = target_cov\",\n \"masks the selective_MLE inherited from query because that is not\",\n \"N + Gamma theta.hat, # target_lin is \\\"something\\\" times Gamma,\",\n \"sorted if np.any(agroups[:-1] > agroups[1:]) < 0: raise ValueError(\\\"Groups are\",\n \"- con_linear.dot(gs)) ** 2.))).dot(con_linear) if useJacobian: p2 = - jacobian_grad_hess(gs,\",\n \"\\\\\\\\bar{\\\\\\\\Sigma}^{-1} \\\\bar{\\\\\\\\mu} precision: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} feasible_point: gamma's from fitting con_linear: linear\",\n \"1 proposal = current - step * cur_grad proposed_value =\",\n \"= S self.r = r def solve_barrier_affine_jacobian_py(conjugate_arg, precision, feasible_point, con_linear,\",\n \"of affine constraint used for barrier function con_offset: offset part\",\n \"= self.QI * dispersion crosscov_target_score = _score_linear.dot(self.QI).T * dispersion return\",\n \"_scale[j], num=ngrid) else: ngrid = 100 self.stat_grid = np.zeros((ntarget, ngrid))\",\n \"0], 'upper_confidence': intervals[:, 1], 'unbiased': unbiased_estimator}) return result, observed_info_mean, log_ref\",\n \"the reference density on a grid. \\\"\\\"\\\" if np.asarray(observed_target).shape in\",\n \"** 2).sum(0)) if ridge_term is None: ridge_term = np.std(Y) *\",\n \"current_value = proposed_value break current = proposal current_value = proposed_value\",\n \"penalty if all groups are size 1 if use_lasso and\",\n \"= self.cond_cov.dot(eta) * implied_prec R = np.identity(num_opt) - _A.dot(eta.T) A\",\n \"precision.dot(gs) p2 = -con_linear.T.dot(1. / (scaling + con_offset - con_linear.dot(gs)))\",\n \"one feature in group 3). This function checks the user-specified\",\n \"p2 = 0 return p1 + p2 current = feasible_point\",\n \"Gamma, # where \\\"something\\\" comes from implied Gaussian # cond_mean\",\n \"np.array(groups) # check dimension if len(agroups.shape) != 1: raise ValueError(\\\"Groups\",\n \"np.any(agroups[:-1] > agroups[1:]) < 0: raise ValueError(\\\"Groups are not sorted\\\")\",\n \"for targets of model including selected features Parameters ---------- query\",\n \"self.randomizer.cov_prec if np.asarray(prec).shape in [(), (0,)]: cond_precision = self.opt_linear.T.dot(self.opt_linear) *\",\n \"target_linear = target_score_cov.T.dot(prec_target) target_offset = score_offset - target_linear.dot(observed_target) target_lin =\",\n \"np.sqrt(np.diag(con_linear.dot(precision).dot(con_linear.T))) if feasible_point is None: feasible_point = 1. / scaling\",\n \"0, and have no gaps (e.g., if there is a\",\n \"opt_linearNoU.dot(U) self.active_dirs = active_dirs self.opt_offset = opt_offset self.ordered_vars = ordered_vars\",\n \"useful quantities (observed_target, target_cov, target_score_cov, alternatives) = self.selected_targets(dispersion) init_soln =\",\n \"solver(np.asarray([conjugate_arg]), np.reshape(implied_prec, (1,1)), eta.T.dot(self.init_soln), A.reshape((A.shape[0],1)), b, **self.solve_args) gamma_ = _A.dot(soln)\",\n \"= (np.diag(self.target_cov)[m]).reshape((1, 1)) prec_target = 1. / target_cov_uni target_score_cov_uni =\",\n \"= target_score_cov self.target_cov = target_cov self.init_soln = query.observed_opt_state self.randomizer_prec =\",\n \"scheme and raises an exception if it finds any problems.\",\n \"g appreciably nonzero ordered_groups.append(g) # variables in active group ordered_vars.extend(np.flatnonzero(group_mask))\",\n \"eta = -self.prec_opt.dot(self.logdens_linear.dot(target_score_cov.T)) implied_mean = np.asscalar(eta.T.dot(cond_mean_grid)) implied_cov = np.asscalar(eta.T.dot(self.cond_cov).dot(eta)) implied_prec\",\n \"Private method def _construct_density(self): precs = {} S = {}\",\n \"= log(1. + 1. / ((con_offset - con_linear.dot(gs)) / scaling)).sum()\",\n \"[compute_Vg(ug) for ug in sorted_active_dirs.values()] V = block_diag(*Vs) # unpack\",\n \"quantities (observed_target, target_cov, target_score_cov, alternatives) = self.selected_targets(dispersion) init_soln = self.observed_opt_state\",\n \"return p1 + p2 + p3 + p4 def barrier_hessian(gs):\",\n \"(model on _setup_implied_gaussian) cond_cov: conditional variance of optimization variables (model\",\n \"= ordered_groups # exception if no groups are selected if\",\n \"[(), (0,)]: cond_precision = self.opt_linear.T.dot(self.opt_linear) * prec cond_cov = inv(cond_precision)\",\n \"= 0 p4 = 1. / (con_offset - con_linear.dot(gs)) return\",\n \"if np.any(agroups[:-1] > agroups[1:]) < 0: raise ValueError(\\\"Groups are not\",\n \"for no skipped groups if not np.all(np.diff(np.unique(agroups)) == 1): raise\",\n \"target_cov: from selected_targets target_cov_score: from selected_targets init_soln: (opt_state) initial (observed)\",\n \"log(1. + 1. / ((con_offset - con_linear.dot(gs)) / scaling)).sum() return\",\n \"specified') observed_target = np.atleast_1d(observed_target) prec_target = inv(target_cov) prec_opt = self.cond_precision\",\n \"use Pearson's X^2 dispersion = ((y - self.loglike.saturated_loss.mean_function( XE.dot(observed_target))) **\",\n \"(self.cond_mean - target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],)) _prec = prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec)\",\n \"the log-Jacobian (scalar), gradient (gamma.size vector) and hessian (gamma.size square\",\n \"provide weights an an np.array rather than a dictionary weights_np\",\n \"is a 1-d array_like of integers that are sorted in\",\n \"X, y = self.loglike.data W = self._W = self.loglike.saturated_loss.hessian(X.dot(beta_bar)) #\",\n \"groups is potentially tedious for the user and in future\",\n \"for g in sorted_active_dirs] L = block_diag(*Ls) # unpack the\",\n \"perturb=None, solve_args={'tol': 1.e-15, 'min_its': 100}): # take a new perturbation\",\n \"0]) lower.append(l * var_target + observed_target) upper.append(u * var_target +\",\n \"log likelihood : quadratic loss self.loglike = loglike self.nfeature =\",\n \"be values of ['twosided', 'less', 'greater'] parameter : np.array Hypothesized\",\n \"need to provide weights an an np.array rather than a\",\n \"0.5 if count >= 40: raise ValueError('not finding a feasible\",\n \"variables in active group ordered_vars.extend(np.flatnonzero(group_mask)) if self.penalty.weights[g] == 0: unpenalized.append(g)\",\n \"labels, values are unit-norm coefficients unpenalized = [] # selected\",\n \"_ = solver(np.asarray([conjugate_arg]), np.reshape(implied_prec, (1,1)), eta.T.dot(self.init_soln), A.reshape((A.shape[0],1)), b, **self.solve_args) gamma_\",\n \"con_linear.dot(gs)) return p1 + p2 + p3 + p4 def\",\n \"target_cov.dot(_prec).dot(observed_target) \\\\ + target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean - soln))) + C unbiased_estimator =\",\n \"fitting con_linear: linear part of affine constraint used for barrier\",\n \"# active group labels active_dirs = {} # dictionary: keys\",\n \"check starts with 0 if not np.amin(agroups) == 0: raise\",\n \"otherwise continue as before self.observed_opt_state = np.hstack(ordered_opt) # gammas as\",\n \"(gamma.size vector) and hessian (gamma.size square matrix) \\\"\\\"\\\" if C.shape\",\n \"[] # selected groups with no penalty overall = np.ones(self.nfeature,\",\n \"raise ValueError('value is NaN: %f, %f' % (proposed_value, current_value)) #\",\n \"active features ordered_groups = [] # active group labels sorted\",\n \"- con_linear.dot(proposal) > 0): break step *= 0.5 if count\",\n \"target_score_cov.T.dot(prec_target) num_opt = self.prec_opt.shape[0] num_con = self.linear_part.shape[0] cond_mean_grid = (target_lin.dot(np.atleast_1d(grid[k]\",\n \"if the group is size one, the orthogonal complement is\",\n \"are a number of assumptions that group_lasso makes about how\",\n \"specified') prec_target = np.linalg.inv(target_cov) target_lin = - self.logdens_linear.dot(target_score_cov.T.dot(prec_target)) ref_hat =\",\n \"intervals useC: whether to use python or C solver JacobianPieces:\",\n \"/ (scaling + con_offset - con_linear.dot(gs))) if useJacobian: p3 =\",\n \"ug in active_dirs.values()]) # gradient grad_J = S.dot(GpC_inv.diagonal()) # hessian\",\n \"in [(), (0,)]: raise ValueError('no target specified') observed_target = np.atleast_1d(observed_target)\",\n \"'less': pivot.append(_cdf) else: raise ValueError('alternative should be in [\\\"twosided\\\", \\\"less\\\",\",\n \"target_cov : ndarray Estimated covaraince of target. target_score_cov : ndarray\",\n \"group labels, values are unit-norm coefficients unpenalized = [] #\",\n \"sorted(np.unique(self.groups)): # g is group label group_mask = self.groups ==\",\n \"query.selective_MLE(dispersion=dispersion)[:2] self.linear_part = query.linear_part self.offset = query.offset self.logdens_linear = query.logdens_linear\",\n \"if np.asarray(prec).shape in [(), (0,)]: cond_precision = self.opt_linear.T.dot(self.opt_linear) * prec\",\n \"method since this uses results from that method. Parameters ----------\",\n \"cur_grad if np.all(con_offset - con_linear.dot(proposal) > 0): break step *=\",\n \"lasso) solve_args: passed on to solver level: level of confidence\",\n \"(0,)]: cond_precision = self.opt_linear.T.dot(self.opt_linear) * prec cond_cov = inv(cond_precision) logdens_linear\",\n \"1. / ((con_offset - con_linear.dot(gs)) ** 2.))).dot(con_linear) if useJacobian: p2\",\n \"* np.fabs(current_value) and itercount >= min_its: current = proposal current_value\",\n \"4, there must also be at least one feature in\",\n \"log_reference(self, observed_target, target_cov, target_score_cov, grid): \\\"\\\"\\\" Approximate the log of\",\n \"which has information to describe implied Gaussian. observed_target : ndarray\",\n \"self.C, self.active_dirs) ref_hat.append(-val - ((conjugate_arg ** 2) * implied_cov)/ 2.\",\n \"sorted\\\") # check integers if not np.issubdtype(agroups.dtype, np.integer): raise TypeError(\\\"Groups\",\n \"# inverse #GpC_inv = evectors.dot(np.diag(1 / evalues).dot(evectors.T)) GpC_inv = np.linalg.inv(GammaMinus\",\n \"\\\"\\\"\\\" Approximate the log of the reference density on a\",\n \"+ p2 current = feasible_point current_value = np.inf for itercount\",\n \"barrier_hessian(current)) return current_value, current, hess # Jacobian calculations def calc_GammaMinus(gamma,\",\n \"= False self.selection_variable = {'directions': active_dirs, 'active_groups': active_groups} # kind\",\n \"target_lin) else: _P = target_linear.T.dot(self.randomizer_prec).dot(target_offset) _prec = prec_target + (target_linear.T.dot(self.randomizer_prec).dot(target_linear))\",\n \"== g soln = self.initial_soln # do not need to\",\n \"penalty and run usual lasso solver... (see existing code)... initial_soln\",\n \"randomization.isotropic_gaussian((p,), randomizer_scale) return group_lasso(loglike, groups, weights, ridge_term, randomizer, use_lasso, perturb)\",\n \"- defaults to True randomizer_scale=None): loglike = rr.glm.gaussian(X, Y, coef=1.\",\n \"\\\"\\\"\\\" self._setup_implied_gaussian() # Calculate useful quantities (observed_target, target_cov, target_score_cov, alternatives)\",\n \"= np.sqrt(mean_diag) * 0.5 * np.std(Y) * np.sqrt(n / (n\",\n \"ordered_vars = [] # indices \\\"ordered\\\" by sorting group labels\",\n \"[] for k in range(grid.shape[0]): # in the usual D\",\n \"integers\\\") # check starts with 0 if not np.amin(agroups) ==\",\n \"= self.selected_targets(dispersion) init_soln = self.observed_opt_state # just the gammas cond_mean\",\n \"1's for LS opt_linearNoU = np.dot(X.T, X[:, ordered_vars] * W[:,\",\n \"beta_bar[overall] = _beta_unpenalized # refit OLS beta with zeros self._beta_full\",\n \"for gp in to_diag for i in gp]) def jacobian_grad_hess(gamma,\",\n \"restricted_estimator(self.loglike, # refit OLS on E overall, solve_args=solve_args) beta_bar =\",\n \"conjugate_arg = prec_opt.dot(cond_mean) val, soln, hess = solve_barrier_affine_jacobian_py(conjugate_arg, prec_opt, init_soln,\",\n \"barrier and jacobian to hessian p1 = con_linear.T.dot(np.diag(-1. / ((scaling\",\n \"dict, optional Arguments passed to solver. \\\"\\\"\\\" self.solve_args = solve_args\",\n \"group_lasso(object): def __init__(self, loglike, groups, weights, ridge_term, randomizer, use_lasso=True, #\",\n \"dictionary: keys are group labels, values are unit-norm coefficients unpenalized\",\n \"np.zeros(self.nfeature) beta_bar[overall] = _beta_unpenalized # refit OLS beta with zeros\",\n \"be at least one feature in group 3). This function\",\n \"np.unique(groups).size: # need to provide weights an an np.array rather\",\n \"_cdf)) elif alternatives[m] == 'greater': pivot.append(1 - _cdf) elif alternatives[m]\",\n \"cond_precision = self.opt_linear.T.dot(self.opt_linear) * prec cond_cov = inv(cond_precision) logdens_linear =\",\n \"Pearson's X^2 dispersion = ((y - self.loglike.saturated_loss.mean_function( XE.dot(observed_target))) ** 2\",\n \"for i in gp]) def jacobian_grad_hess(gamma, C, active_dirs): \\\"\\\"\\\" Calculate\",\n \"inv(target_cov) prec_opt = self.cond_precision score_offset = self.observed_score_state + self.opt_offset #\",\n \"min_its=500, tol=1.e-12): \\\"\\\"\\\" This needs to be updated to actually\",\n \"you have already run the fit method since this uses\",\n \"weights=weights, lagrange=1.) # store groups as a class variable since\",\n \"the argument of the optimization density # depends on the\",\n \"relative decrease is small if np.fabs(current_value - proposed_value) < tol\",\n \"quadratic=quadratic) n, p = X.shape mean_diag = np.mean((X ** 2).sum(0))\",\n \"= rr.simple_problem(self.loglike, self.penalty) # if all groups are size 1,\",\n \"self.active_dirs) ref_hat.append(-val - ((conjugate_arg ** 2) * implied_cov)/ 2. +\",\n \"soln # otherwise continue as before self.observed_opt_state = np.hstack(ordered_opt) #\",\n \"# should lasso solver be used when applicable - defaults\",\n \"True perturb=None): _check_groups(groups) # make sure groups looks sensible #\",\n \"are size 1 if use_lasso and groups.size == np.unique(groups).size: #\",\n \"(target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( prec_opt).dot( target_lin) else: _P =\",\n \"Gaussian query which has information to describe implied Gaussian. observed_target\",\n \"ridge_term, randomizer, use_lasso=True, # should lasso solver be used where\",\n \"np.array Hypothesized value for parameter -- defaults to 0. level\",\n \"return pivot def _approx_intervals(self, level=0.9): if not hasattr(self, \\\"_families\\\"): self._construct_families()\",\n \"\\\"something\\\" times Gamma, # where \\\"something\\\" comes from implied Gaussian\",\n \"= V.T.dot(QI).dot(L).dot(V) self.XE = XE self.Q = Q self.QI =\",\n \"0.5 * np.std(Y) * np.sqrt(n / (n - 1.)) randomizer\",\n \"self.opt_linear = opt_linearNoU.dot(U) self.active_dirs = active_dirs self.opt_offset = opt_offset self.ordered_vars\",\n \"ref_hat.append(-val - ((conjugate_arg ** 2) * implied_cov)/ 2. + log_jacob[0])\",\n \"---------- observed_target: from selected_targets target_cov: from selected_targets target_cov_score: from selected_targets\",\n \"100 self.stat_grid = np.zeros((ntarget, ngrid)) for j in range(ntarget): self.stat_grid[j,\",\n \"self.target_score_cov[m, :].reshape((1, p)) var_target = 1. / ((self.precs[m])[0, 0]) log_ref\",\n \"def grad(gs): p1 = -conjugate_arg + precision.dot(gs) p2 = -con_linear.T.dot(1.\",\n \"R.dot(self.init_soln) log_jacob = jacobian_grad_hess(gamma_, self.C, self.active_dirs) ref_hat.append(-val - ((conjugate_arg **\",\n \"= solve_barrier_affine_jacobian_py(conjugate_arg, prec_opt, init_soln, linear_part, offset, self.C, self.active_dirs, useJacobian, **solve_args)\",\n \"1 proposal = current - step * cur_grad if np.all(con_offset\",\n \"#direction for decomposing o eta = -self.prec_opt.dot(self.logdens_linear.dot(target_score_cov.T)) implied_mean = np.asscalar(eta.T.dot(cond_mean_grid))\",\n \"ug in sorted_active_dirs.values()]).T self.opt_linear = opt_linearNoU.dot(U) self.active_dirs = active_dirs self.opt_offset\",\n \"_approx_pivots(self, mean_parameter, alternatives=None): if not hasattr(self, \\\"_families\\\"): self._construct_families() if alternatives\",\n \"proposal current_value = proposed_value break current = proposal current_value =\",\n \"1) for (g, ug) in zip(gamma, active_dirs.values())] return block_diag(*[i for\",\n \"of g'th group if pg > 1: Z = np.column_stack((ug,\",\n \"= self.penalty.weights[g] * np.eye(pg) return Lg sorted_active_dirs = collections.OrderedDict(sorted(active_dirs.items())) Vs\",\n \"self.logdens_linear.dot(target_score_cov.T.dot(prec_target)) ref_hat = [] for k in range(grid.shape[0]): # in\",\n \"C = target_cov.dot(_P - target_lin.T.dot(prec_opt).dot(target_off)) conjugate_arg = prec_opt.dot(cond_mean) val, soln,\",\n \"self.ntarget = ntarget = target_cov.shape[0] _scale = 4 * np.sqrt(np.diag(inverse_info))\",\n \"C.shape[0]) S = block_diag(*[np.ones((1, ug.size - 1)) for ug in\",\n \">= min_its: current = proposal current_value = proposed_value break current\",\n \"if no groups are selected if len(self.selection_variable['active_groups']) == 0: return\",\n \"i, var in enumerate(ordered_vars): opt_linearNoU[var, i] += self.ridge_term opt_offset =\",\n \"self.linear_part = -np.eye(self.observed_opt_state.shape[0]) self.offset = np.zeros(self.observed_opt_state.shape[0]) return active_signs, soln def\",\n \"vector) and hessian (gamma.size square matrix) \\\"\\\"\\\" if C.shape ==\",\n \"# active group labels sorted by label ordered_opt = []\",\n \"np.linalg.inv(_prec).dot(prec_target) S[m] = _S r[m] = _r precs[m] = _prec\",\n \"approximate_grid_inference(object): def __init__(self, query, dispersion, solve_args={'tol': 1.e-12}, useIP=True): \\\"\\\"\\\" Produce\",\n \"(scaling + con_offset - con_linear.dot(gs))) if useJacobian: p3 = -\",\n \"p1 = con_linear.T.dot(np.diag(-1. / ((scaling + con_offset - con_linear.dot(gs)) **\",\n \"target_cov.shape[0] _scale = 4 * np.sqrt(np.diag(inverse_info)) if useIP == False:\",\n \"this masks the selective_MLE inherited from query because that is\",\n \"self.initial_soln # do not need to keep setting this if\",\n \"C, active_dirs)[1] else: p3 = 0 p4 = 1. /\",\n \"log_ref, kind='quadratic', bounds_error=False, fill_value='extrapolate') grid = np.linspace(self.stat_grid[m].min(), self.stat_grid[m].max(), 1000) logW\",\n \"= np.vstack([final_estimator - quantile * np.sqrt(np.diag(observed_info_mean)), final_estimator + quantile *\",\n \"a descent count = 0 while True: count += 1\",\n \"self._families[m] var_target = 1. / ((self.precs[m])[0, 0]) mean = self.S[m].dot(mean_parameter[m].reshape((1,)))\",\n \"= self.loglike.data n, p = X.shape XE = self.XE Q\",\n \"ok There are a number of assumptions that group_lasso makes\",\n \"scipy.stats import norm as ndist from scipy.interpolate import interp1d import\",\n \"active_dirs[g].size Lg = self.penalty.weights[g] * np.eye(pg) return Lg sorted_active_dirs =\",\n \"var_target + observed_target) return np.asarray(lower), np.asarray(upper) ### Private method def\",\n \"= target_linear.T.dot(self.randomizer_prec).dot(target_offset) _prec = prec_target + (target_linear.T.dot(self.randomizer_prec).dot(target_linear)) - target_lin.T.dot( prec_opt).dot(target_lin)\",\n \"cond_cov: conditional variance of optimization variables (model on _setup_implied_gaussian) logdens_linear:\",\n \"con_offset: offset part of affine constraint used for barrier function\",\n \"matrix (gamma.size by C.shape[0]) S = block_diag(*[np.ones((1, ug.size - 1))\",\n \"= -np.eye(self.observed_opt_state.shape[0]) self.offset = np.zeros(self.observed_opt_state.shape[0]) return active_signs, soln def _solve_randomized_problem(self,\",\n \"barrier_hessian(gs): # contribution of barrier and jacobian to hessian p1\",\n \"eigendecomposition #evalues, evectors = eig(GammaMinus + C) # log Jacobian\",\n \"information (in self.C) arguments conjugate_arg: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} \\\\bar{\\\\\\\\mu} precision: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} feasible_point:\",\n \"C solver JacobianPieces: (use self.C defined in fitting) \\\"\\\"\\\" self._setup_implied_gaussian()\",\n \"= query.offset self.logdens_linear = query.logdens_linear self.cond_mean = query.cond_mean self.prec_opt =\",\n \"active_groups} # kind of redundant with keys of active_dirs self._ordered_groups\",\n \"(grid - self.observed_target[m]) ** 2 / var_target) logW -= logW.max()\",\n \"the score, not how the mean depends on score, hence\",\n \"np.eye(pg, pg - 1))) Q, _ = qr(Z) Vg =\",\n \"pvalues = 2 * np.minimum(pvalues, 1 - pvalues) alpha =\",\n \"+ self.opt_offset # target_lin determines how the conditional mean of\",\n \"scipy.interpolate import interp1d import collections import numpy as np from\",\n \"scipy.linalg import block_diag from scipy.stats import norm as ndist from\",\n \"final_estimator + quantile * np.sqrt(np.diag(observed_info_mean))]).T log_ref = val + conjugate_arg.T.dot(cond_cov).dot(conjugate_arg)\",\n \"p)) var_target = 1. / ((self.precs[m])[0, 0]) log_ref = self.log_reference(observed_target_uni,\",\n \"in range(self.ntarget): family = self._families[m] var_target = 1. / ((self.precs[m])[0,\",\n \"ridge_term = np.std(Y) * np.sqrt(mean_diag) / np.sqrt(n - 1) if\",\n \"= 100 self.stat_grid = np.zeros((ntarget, ngrid)) for j in range(ntarget):\",\n \"= {'directions': active_dirs, 'active_groups': active_groups} # kind of redundant with\",\n \"theta.hat, # target_lin is \\\"something\\\" times Gamma, # where \\\"something\\\"\",\n \"do not need to keep setting this if norm(soln[group_mask]) >\",\n \"= evectors.dot(np.diag(1 / evalues).dot(evectors.T)) GpC_inv = np.linalg.inv(GammaMinus + C) #\",\n \"Sorting feature groups is potentially tedious for the user and\",\n \"'pvalue': pvalues, 'lower_confidence': lower, 'upper_confidence': upper}) if not np.all(parameter ==\",\n \"and raises an exception if it finds any problems. Sorting\",\n \"= {} p = self.target_score_cov.shape[1] for m in range(self.ntarget): observed_target_uni\",\n \"has information to describe implied Gaussian. observed_target : ndarray Observed\",\n \"target_linear.T.dot(self.randomizer_prec).dot(target_offset) _prec = prec_target + (target_linear.T.dot(self.randomizer_prec).dot(target_linear)) - target_lin.T.dot( prec_opt).dot(target_lin) C\",\n \"conditional mean of optimization variables # vary with target #\",\n \"logW.max() self._families.append(discrete_family(grid, np.exp(logW))) def _approx_pivots(self, mean_parameter, alternatives=None): if not hasattr(self,\",\n \"lasso penalty if all groups are size 1 if use_lasso\",\n \"self._initial_omega = perturb # gaussian randomization self.randomizer = randomizer def\",\n \"0.5 * (self.stat_grid[m] - self.observed_target[m]) ** 2 / var_target) logW\",\n \"check integers if not np.issubdtype(agroups.dtype, np.integer): raise TypeError(\\\"Groups are not\",\n \"break else: raise ValueError('value is NaN: %f, %f' % (proposed_value,\",\n \"var in enumerate(ordered_vars): opt_linearNoU[var, i] += self.ridge_term opt_offset = self.initial_subgrad\",\n \"= self.cond_mean cond_cov = self.cond_cov logdens_linear = self.logdens_linear linear_part =\",\n \"initial_subgrad = -(self.loglike.smooth_objective(initial_soln, 'grad') + quad.objective(initial_soln, 'grad')) return initial_soln, initial_subgrad\",\n \"X[:, ordered_vars] # changed to ordered_vars Q = XE.T.dot(self._W[:, None]\",\n \"((con_offset - con_linear.dot(gs)) / scaling)).sum() return p1 + p2 +\",\n \"level=0.9): if not hasattr(self, \\\"_families\\\"): self._construct_families() lower, upper = [],\",\n \"(log_ref - 0.5 * (self.stat_grid[m] - self.observed_target[m]) ** 2 /\",\n \"by sorting group labels tol = 1.e-20 _, self.randomizer_prec =\",\n \"V active_dirs: \\\"\\\"\\\" scaling = np.sqrt(np.diag(con_linear.dot(precision).dot(con_linear.T))) if feasible_point is None:\",\n \"D # Gamma is target_score_cov.T.dot(prec_target) num_opt = self.prec_opt.shape[0] num_con =\",\n \"if np.fabs(current_value - proposed_value) < tol * np.fabs(current_value) and itercount\",\n \"if not np.issubdtype(agroups.dtype, np.integer): raise TypeError(\\\"Groups are not integers\\\") #\",\n \"else: self.penalty = rr.group_lasso(groups, weights=weights, lagrange=1.) # store groups as\",\n \"self.S[m].dot(mean_parameter[m].reshape((1,))) + self.r[m] _cdf = family.cdf((mean[0] - self.observed_target[m]) / var_target,\",\n \"def log_reference(self, observed_target, target_cov, target_score_cov, grid): \\\"\\\"\\\" Approximate the log\",\n \"= self.observed_score_state + self.opt_offset # target_lin determines how the conditional\",\n \"'pivot', pivots) result.insert(5, 'parameter', parameter) return result def log_reference(self, observed_target,\",\n \"+ log_jacob[0]) return np.asarray(ref_hat) def _construct_families(self): self._construct_density() self._families = []\",\n \"query.logdens_linear self.cond_mean = query.cond_mean self.prec_opt = np.linalg.inv(query.cond_cov) self.cond_cov = query.cond_cov\",\n \"feasible_point, con_linear, con_offset, C, active_dirs, useJacobian=True, step=1, nstep=2000, min_its=500, tol=1.e-12):\",\n \"proposed_value <= current_value: break step *= 0.5 if count >=\",\n \"sorted_active_dirs.values()]).T self.opt_linear = opt_linearNoU.dot(U) self.active_dirs = active_dirs self.opt_offset = opt_offset\",\n \"ordered_opt = [] # gamma's ordered by group labels ordered_vars\",\n \"= target_cov self.init_soln = query.observed_opt_state self.randomizer_prec = query.randomizer_prec self.score_offset =\",\n \"values of ['twosided', 'less', 'greater'] parameter : np.array Hypothesized value\",\n \"initial_subgrad @staticmethod def gaussian(X, Y, groups, weights, sigma=1., quadratic=None, ridge_term=0.,\",\n \"from selected_targets target_cov_score: from selected_targets init_soln: (opt_state) initial (observed) value\",\n \"import numpy as np from numpy import log from numpy.linalg\",\n \"alternatives[m] == 'greater': pivot.append(1 - _cdf) elif alternatives[m] == 'less':\",\n \"p = X.shape mean_diag = np.mean((X ** 2).sum(0)) if ridge_term\",\n \"def compute_Lg(g): pg = active_dirs[g].size Lg = self.penalty.weights[g] * np.eye(pg)\",\n \"`groups` is a 1-d array_like of integers that are sorted\",\n \"X, y = self.loglike.data n, p = X.shape XE =\",\n \"= 0 p4 = log(1. + 1. / ((con_offset -\",\n \"= self._families[m] var_target = 1. / ((self.precs[m])[0, 0]) mean =\",\n \"fit method since this uses results from that method. Parameters\",\n \"= ndist.cdf(Z_scores) pvalues = 2 * np.minimum(pvalues, 1 - pvalues)\",\n \"target_lin = - logdens_linear.dot(target_linear) target_off = cond_mean - target_lin.dot(observed_target) if\",\n \"+ precision.dot(gs) p2 = -con_linear.T.dot(1. / (scaling + con_offset -\",\n \"(self.score_offset - target_linear.dot(observed_target_uni)).reshape( (target_linear.shape[0],)) target_lin = -self.logdens_linear.dot(target_linear) target_off = (self.cond_mean\",\n \"quadratic loss self.loglike = loglike self.nfeature = self.loglike.shape[0] # ridge\",\n \"np.zeros((1, 0)) # if the group is size one, the\",\n \"itercount in range(nstep): cur_grad = grad(current) # make sure proposal\",\n \"= np.dot(X.T, X[:, ordered_vars] * W[:, np.newaxis]) for i, var\",\n \"Q[:, 1:] # drop the first column else: Vg =\",\n \"[[g] * (ug.size - 1) for (g, ug) in zip(gamma,\",\n \"hessian (gamma.size square matrix) \\\"\\\"\\\" if C.shape == (0, 0):\",\n \"group labels active_dirs = {} # dictionary: keys are group\",\n \": float Confidence level. \\\"\\\"\\\" if parameter is not None:\",\n \"supplied if perturb is not None: self._initial_omega = perturb if\",\n \"= query.selective_MLE(dispersion=dispersion)[:2] self.linear_part = query.linear_part self.offset = query.offset self.logdens_linear =\",\n \"scaling)).sum() return p1 + p2 + p3 + p4 def\",\n \"range(self.ntarget): p = self.target_score_cov.shape[1] observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1,\",\n \"the alternatives, should be values of ['twosided', 'less', 'greater'] parameter\",\n \"selected if len(self.selection_variable['active_groups']) == 0: return np.sign(soln), soln # otherwise\",\n \"pvalues = self._approx_pivots(np.zeros_like(self.observed_target), alternatives=alternatives) lower, upper = self._approx_intervals(level=level) result =\",\n \"active_groups = [] # active group labels active_dirs = {}\",\n \"# changed to ordered_vars Q = XE.T.dot(self._W[:, None] * XE)\",\n \"all 1's for LS opt_linearNoU = np.dot(X.T, X[:, ordered_vars] *\",\n \"check dimension if len(agroups.shape) != 1: raise ValueError(\\\"Groups are not\",\n \"= 1.e-20 _, self.randomizer_prec = self.randomizer.cov_prec # now we are\",\n \"OLS on E overall, solve_args=solve_args) beta_bar = np.zeros(self.nfeature) beta_bar[overall] =\",\n \"finds any problems. Sorting feature groups is potentially tedious for\",\n \"OLS beta with zeros self._beta_full = beta_bar X, y =\",\n \"are unit-norm coefficients unpenalized = [] # selected groups with\",\n \"dispersion return (observed_target, cov_target, crosscov_target_score, alternatives) class approximate_grid_inference(object): def __init__(self,\",\n \"are not integers\\\") # check starts with 0 if not\",\n \"crosscov_target_score, alternatives) class approximate_grid_inference(object): def __init__(self, query, dispersion, solve_args={'tol': 1.e-12},\",\n \"is NaN: %f, %f' % (proposed_value, current_value)) # stop if\",\n \"#J = log(evalues).sum() J = np.log(np.linalg.det(GammaMinus + C)) # inverse\",\n \"current - step * cur_grad proposed_value = objective(proposal) if proposed_value\",\n \"defaults to True randomizer_scale=None): loglike = rr.glm.gaussian(X, Y, coef=1. /\",\n \"# need to provide weights an an np.array rather than\",\n \"_check_groups(groups): \\\"\\\"\\\"Make sure that the user-specific groups are ok There\",\n \"self.ordered_vars, solve_args=solve_args) _score_linear = -XE.T.dot(self._W[:, None] * X).T alternatives =\",\n \"np.sign(self.initial_soln) active = np.flatnonzero(active_signs) self.active = active def compute_Vg(ug): pg\",\n \"np.minimum(pvalues, 1 - pvalues) alpha = 1 - level quantile\",\n \"X[:, ordered_vars] * W[:, np.newaxis]) for i, var in enumerate(ordered_vars):\",\n \"1.e-12}, useIP=True): \\\"\\\"\\\" Produce p-values and confidence intervals for targets\",\n \"-self.logdens_linear.dot(target_linear) target_off = (self.cond_mean - target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],)) _prec = prec_target +\",\n \"= [] for m in range(self.ntarget): family = self._families[m] var_target\",\n \"not a 1D array_like\\\") # check sorted if np.any(agroups[:-1] >\",\n \"/ evalues).dot(evectors.T)) GpC_inv = np.linalg.inv(GammaMinus + C) # summing matrix\",\n \"= - logdens_linear.dot(target_linear) target_off = cond_mean - target_lin.dot(observed_target) if np.asarray(self.randomizer_prec).shape\",\n \"-= logW.max() self._families.append(discrete_family(grid, np.exp(logW))) def _approx_pivots(self, mean_parameter, alternatives=None): if not\",\n \"checks the user-specified group scheme and raises an exception if\",\n \"are specified. Specifically, we assume that `groups` is a 1-d\",\n \"square matrix) \\\"\\\"\\\" if C.shape == (0, 0): # when\",\n \"cond_mean_grid = (target_lin.dot(np.atleast_1d(grid[k] - observed_target)) + self.cond_mean) #direction for decomposing\",\n \"= cond_mean - target_lin.dot(observed_target) if np.asarray(self.randomizer_prec).shape in [(), (0,)]: _P\",\n \"+ target_cov.dot( _P - target_lin.T.dot(prec_opt).dot(target_off)) L = target_lin.T.dot(prec_opt) observed_info_natural =\",\n \"density on a grid. \\\"\\\"\\\" if np.asarray(observed_target).shape in [(), (0,)]:\",\n \"determines how the conditional mean of optimization variables # vary\",\n \"p4 = log(1. + 1. / ((con_offset - con_linear.dot(gs)) /\",\n \"+ C) # summing matrix (gamma.size by C.shape[0]) S =\",\n \"/ np.sqrt(np.diag(observed_info_mean)) pvalues = ndist.cdf(Z_scores) pvalues = 2 * np.minimum(pvalues,\",\n \"_P = target_linear.T.dot(self.randomizer_prec).dot(target_offset) _prec = prec_target + (target_linear.T.dot(self.randomizer_prec).dot(target_linear)) - target_lin.T.dot(\",\n \"0): result.insert(4, 'pivot', pivots) result.insert(5, 'parameter', parameter) return result def\",\n \"log_ref = val + conjugate_arg.T.dot(cond_cov).dot(conjugate_arg) / 2. result = pd.DataFrame({'MLE':\",\n \"LS opt_linearNoU = np.dot(X.T, X[:, ordered_vars] * W[:, np.newaxis]) for\",\n \"initial (observed) value of optimization variables cond_mean: conditional mean of\",\n \"Q = XE.T.dot(self._W[:, None] * XE) QI = inv(Q) C\",\n \"be used where applicable - defaults to True perturb=None): _check_groups(groups)\",\n \"np.sign(soln), soln # otherwise continue as before self.observed_opt_state = np.hstack(ordered_opt)\",\n \"enumerate(ordered_vars): opt_linearNoU[var, i] += self.ridge_term opt_offset = self.initial_subgrad self.observed_score_state =\",\n \"groups are size one, C will be an empty array\",\n \"= self._families[m] observed_target = self.observed_target[m] l, u = family.equal_tailed_interval(observed_target, alpha=1\",\n \"and run usual lasso solver... (see existing code)... initial_soln =\",\n \"np.all(parameter == 0): result.insert(4, 'pivot', pivots) result.insert(5, 'parameter', parameter) return\",\n \"= cond_cov self.cond_precision = cond_precision self.logdens_linear = logdens_linear return cond_mean,\",\n \"in active group ordered_vars.extend(np.flatnonzero(group_mask)) if self.penalty.weights[g] == 0: unpenalized.append(g) else:\",\n \"100}): # take a new perturbation if supplied if perturb\",\n \"self.randomizer_prec _prec = prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot(\",\n \"# mask of active features ordered_groups = [] # active\",\n \"= np.zeros(self.observed_opt_state.shape[0]) return active_signs, soln def _solve_randomized_problem(self, perturb=None, solve_args={'tol': 1.e-15,\",\n \"Vg = np.zeros((1, 0)) # if the group is size\",\n \"self._initial_omega = perturb if self._initial_omega is None: self._initial_omega = self.randomizer.sample()\",\n \"active group labels active_dirs = {} # dictionary: keys are\",\n \"if useJacobian: p2 = - jacobian_grad_hess(gs, C, active_dirs)[2] else: p2\",\n \"makes about how groups are specified. Specifically, we assume that\",\n \"self.offset = np.zeros(self.observed_opt_state.shape[0]) return active_signs, soln def _solve_randomized_problem(self, perturb=None, solve_args={'tol':\",\n \"None: pivots = self._approx_pivots(parameter, alternatives=alternatives) else: pivots = None pvalues\",\n \"= 0 while True: count += 1 proposal = current\",\n \"GpC_inv.T).dot(S.T)) return J, grad_J, hess_J def _check_groups(groups): \\\"\\\"\\\"Make sure that\",\n \"passed on to solver level: level of confidence intervals useC:\",\n \"ngrid = 100 self.stat_grid = np.zeros((ntarget, ngrid)) for j in\",\n \": quadratic loss self.loglike = loglike self.nfeature = self.loglike.shape[0] #\",\n \"group lasso (self.initial_soln, self.initial_subgrad) = self._solve_randomized_problem(perturb=perturb, solve_args=solve_args) # initialize variables\",\n \"self.C, self.active_dirs, useJacobian, **solve_args) final_estimator = target_cov.dot(_prec).dot(observed_target) \\\\ + target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean\",\n \"_solve_randomized_problem(self, perturb=None, solve_args={'tol': 1.e-15, 'min_its': 100}): # take a new\",\n \"* cur_grad proposed_value = objective(proposal) if proposed_value <= current_value: break\",\n \"X^2 dispersion = ((y - self.loglike.saturated_loss.mean_function( XE.dot(observed_target))) ** 2 /\",\n \"_beta_unpenalized # refit OLS beta with zeros self._beta_full = beta_bar\",\n \"= block_diag(*Vs) # unpack the list Ls = [compute_Lg(g) for\",\n \"* W[:, np.newaxis]) for i, var in enumerate(ordered_vars): opt_linearNoU[var, i]\",\n \"pivots = self._approx_pivots(parameter, alternatives=alternatives) else: pivots = None pvalues =\",\n \"= self.loglike.saturated_loss.hessian(X.dot(beta_bar)) # all 1's for LS opt_linearNoU = np.dot(X.T,\",\n \"def _setup_implied_gaussian(self): _, prec = self.randomizer.cov_prec if np.asarray(prec).shape in [(),\",\n \"1)) prec_target = 1. / target_cov_uni target_score_cov_uni = self.target_score_cov[m, :].reshape((1,\",\n \"# refit OLS beta with zeros self._beta_full = beta_bar X,\",\n \"because that is not adapted for the group_lasso. Also, assumes\",\n \"target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],)) _prec = prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot(\",\n \"use the Jacobian information (in self.C) arguments conjugate_arg: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} \\\\bar{\\\\\\\\mu}\",\n \"doesn't self.groups = groups self._initial_omega = perturb # gaussian randomization\",\n \"# make sure groups looks sensible # log likelihood :\",\n \"function con_offset: offset part of affine constraint used for barrier\",\n \"\\\\ + target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean - soln))) + C unbiased_estimator = target_cov.dot(_prec).dot(observed_target)\",\n \"solve_args={'tol': 1.e-12}, useIP=True): \\\"\\\"\\\" Produce p-values and confidence intervals for\",\n \"[] # gamma's ordered by group labels ordered_vars = []\",\n \"in group 3). This function checks the user-specified group scheme\",\n \"a new perturbation if supplied if perturb is not None:\",\n \"* norm(soln): # is group g appreciably nonzero ordered_groups.append(g) #\",\n \"observed_info_natural = _prec + L.dot(target_lin) - L.dot(hess.dot(L.T)) observed_info_mean = target_cov.dot(observed_info_natural.dot(target_cov))\",\n \"(target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( self.prec_opt).dot(target_lin) _P = target_linear.T.dot(target_offset) *\",\n \"is not 0\\\") # check for no skipped groups if\",\n \"features ordered_groups = [] # active group labels sorted by\",\n \"+ 1. / ((con_offset - con_linear.dot(gs)) ** 2.))).dot(con_linear) if useJacobian:\",\n \"active_dirs) # eigendecomposition #evalues, evectors = eig(GammaMinus + C) #\",\n \"l, u = family.equal_tailed_interval(observed_target, alpha=1 - level) var_target = 1.\",\n \"\\\"\\\"\\\"Make sure that the user-specific groups are ok There are\",\n \"[] # indices \\\"ordered\\\" by sorting group labels tol =\",\n \"= 1. / ((self.precs[m])[0, 0]) log_ref = self.log_reference(observed_target_uni, target_cov_uni, target_score_cov_uni,\",\n \"= query.active_dirs (observed_target, target_cov, target_score_cov, alternatives) = query.selected_targets(dispersion) self.observed_target =\",\n \"= query.cond_cov self.C = query.C self.active_dirs = query.active_dirs (observed_target, target_cov,\",\n \"X).T alternatives = ['twosided'] * len(self.active) if dispersion is None:\",\n \"= self.opt_linear.T.dot(self.opt_linear) * prec cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T)\",\n \"raise ValueError('not finding a feasible point') # make sure proposal\",\n \"one, the orthogonal complement is empty return Vg def compute_Lg(g):\",\n \"return initial_soln, initial_subgrad @staticmethod def gaussian(X, Y, groups, weights, sigma=1.,\",\n \"quantile * np.sqrt(np.diag(observed_info_mean))]).T log_ref = val + conjugate_arg.T.dot(cond_cov).dot(conjugate_arg) / 2.\",\n \"parameter self.ridge_term = ridge_term # group lasso penalty (from regreg)\",\n \"/ _prec).dot(target_lin.T.dot(self.prec_opt).dot(target_off) - _P) _S = np.linalg.inv(_prec).dot(prec_target) S[m] = _S\",\n \"2 / var_target) logW -= logW.max() self._families.append(discrete_family(self.stat_grid[m], np.exp(logW))) else: approx_fn\",\n \"regreg) # use regular lasso penalty if all groups are\",\n \"return p1 + p2 + p3 + p4 def grad(gs):\",\n \"= -conjugate_arg + precision.dot(gs) p2 = -con_linear.T.dot(1. / (scaling +\",\n \"solve_barrier_affine_py as solver from ..distributions.discrete_family import discrete_family class group_lasso(object): def\",\n \"in active_dirs.values()]) # gradient grad_J = S.dot(GpC_inv.diagonal()) # hessian hess_J\",\n \"useJacobian: p3 = - jacobian_grad_hess(gs, C, active_dirs)[0] else: p3 =\",\n \"them. \\\"\\\"\\\" # check array_like agroups = np.array(groups) # check\",\n \"= randomization.isotropic_gaussian((p,), randomizer_scale) return group_lasso(loglike, groups, weights, ridge_term, randomizer, use_lasso,\",\n \"a class variable since the non-group lasso doesn't self.groups =\",\n \"Gaussian. observed_target : ndarray Observed estimate of target. target_cov :\",\n \"np.fabs(current_value - proposed_value) < tol * np.fabs(current_value) and itercount >=\",\n \"def _check_groups(groups): \\\"\\\"\\\"Make sure that the user-specific groups are ok\",\n \"variance of optimization variables (model on _setup_implied_gaussian) logdens_linear: (model on\",\n \"cond_mean = self.cond_mean cond_cov = self.cond_cov logdens_linear = self.logdens_linear linear_part\",\n \"0.5 if count >= 20: if not (np.isnan(proposed_value) or np.isnan(current_value)):\",\n \"0) problem = rr.simple_problem(self.loglike, self.penalty) # if all groups are\",\n \"def selective_MLE(self, solve_args={'tol': 1.e-12}, level=0.9, useJacobian=True, dispersion=None): \\\"\\\"\\\"Do selective_MLE for\",\n \"existing code)... initial_soln = problem.solve(quad, **solve_args) initial_subgrad = -(self.loglike.smooth_objective(initial_soln, 'grad')\",\n \"pivot.append(_cdf) else: raise ValueError('alternative should be in [\\\"twosided\\\", \\\"less\\\", \\\"greater\\\"]')\",\n \"the user-specific groups are ok There are a number of\",\n \"return result def log_reference(self, observed_target, target_cov, target_score_cov, grid): \\\"\\\"\\\" Approximate\",\n \"= self.target_score_cov.shape[1] observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) target_score_cov_uni\",\n \"{} S = {} r = {} p = self.target_score_cov.shape[1]\",\n \"array _beta_unpenalized = restricted_estimator(self.loglike, # refit OLS on E overall,\",\n \"of gamma vector, active directions) \\\"\\\"\\\" to_diag = [[g] *\",\n \"result, inverse_info = query.selective_MLE(dispersion=dispersion)[:2] self.linear_part = query.linear_part self.offset = query.offset\",\n \"S = block_diag(*[np.ones((1, ug.size - 1)) for ug in active_dirs.values()])\",\n \"restricted_estimator(self.loglike, self.ordered_vars, solve_args=solve_args) _score_linear = -XE.T.dot(self._W[:, None] * X).T alternatives\",\n \"solve_args : dict, optional Arguments passed to solver. \\\"\\\"\\\" self.solve_args\",\n \"grid): \\\"\\\"\\\" Approximate the log of the reference density on\",\n \"lagrange=1.) # store groups as a class variable since the\",\n \"label ordered_opt = [] # gamma's ordered by group labels\",\n \"or np.isnan(current_value)): break else: raise ValueError('value is NaN: %f, %f'\",\n \"def _approx_pivots(self, mean_parameter, alternatives=None): if not hasattr(self, \\\"_families\\\"): self._construct_families() if\",\n \"precs = {} S = {} r = {} p\",\n \"'upper_confidence': upper}) if not np.all(parameter == 0): result.insert(4, 'pivot', pivots)\",\n \"of the optimization density # depends on the score, not\",\n \"else: p3 = 0 p4 = log(1. + 1. /\",\n \"active_dirs): \\\"\\\"\\\"Calculate Gamma^minus (as a function of gamma vector, active\",\n \"do this for them. \\\"\\\"\\\" # check array_like agroups =\",\n \"_A.dot(soln) + R.dot(self.init_soln) log_jacob = jacobian_grad_hess(gamma_, self.C, self.active_dirs) ref_hat.append(-val -\",\n \"the first column else: Vg = np.zeros((1, 0)) # if\",\n \"else: p3 = 0 p4 = 1. / (con_offset -\",\n \"indices \\\"ordered\\\" by sorting group labels tol = 1.e-20 _,\",\n \"b, **self.solve_args) gamma_ = _A.dot(soln) + R.dot(self.init_soln) log_jacob = jacobian_grad_hess(gamma_,\",\n \"logdens_linear = self.logdens_linear linear_part = self.linear_part offset = self.offset if\",\n \"V = block_diag(*Vs) # unpack the list Ls = [compute_Lg(g)\",\n \"applicable - defaults to True perturb=None): _check_groups(groups) # make sure\",\n \"are group labels, values are unit-norm coefficients unpenalized = []\",\n \"= -gs.T.dot(conjugate_arg) p2 = gs.T.dot(precision).dot(gs) / 2. if useJacobian: p3\",\n \"3). This function checks the user-specified group scheme and raises\",\n \"= self.randomizer.sample() quad = rr.identity_quadratic(self.ridge_term, 0, -self._initial_omega, 0) problem =\",\n \"bounds_error=False, fill_value='extrapolate') grid = np.linspace(self.stat_grid[m].min(), self.stat_grid[m].max(), 1000) logW = (approx_fn(grid)\",\n \"Vg = Q[:, 1:] # drop the first column else:\",\n \"= -self.prec_opt.dot(self.logdens_linear.dot(target_score_cov.T)) implied_mean = np.asscalar(eta.T.dot(cond_mean_grid)) implied_cov = np.asscalar(eta.T.dot(self.cond_cov).dot(eta)) implied_prec =\",\n \"C, active_dirs): \\\"\\\"\\\" Calculate the log-Jacobian (scalar), gradient (gamma.size vector)\",\n \"\\\"less\\\", \\\"greater\\\"]') return pivot def _approx_intervals(self, level=0.9): if not hasattr(self,\",\n \"kind of redundant with keys of active_dirs self._ordered_groups = ordered_groups\",\n \"* np.eye(pg) return Lg sorted_active_dirs = collections.OrderedDict(sorted(active_dirs.items())) Vs = [compute_Vg(ug)\",\n \"= jacobian_grad_hess(gamma_, self.C, self.active_dirs) ref_hat.append(-val - ((conjugate_arg ** 2) *\",\n \"gaussian randomization self.randomizer = randomizer def fit(self, solve_args={'tol': 1.e-12, 'min_its':\",\n \"coef=1. / sigma ** 2, quadratic=quadratic) n, p = X.shape\",\n \"None: # use Pearson's X^2 dispersion = ((y - self.loglike.saturated_loss.mean_function(\",\n \"be updated to actually use the Jacobian information (in self.C)\",\n \"= self.prec_opt.shape[0] num_con = self.linear_part.shape[0] cond_mean_grid = (target_lin.dot(np.atleast_1d(grid[k] - observed_target))\",\n \"_scale[j], observed_target[j] + 1.5 * _scale[j], num=ngrid) self.opt_linear = query.opt_linear\",\n \"overall[group_mask] = False self.selection_variable = {'directions': active_dirs, 'active_groups': active_groups} #\",\n \"prec_opt.dot(cond_mean) val, soln, hess = solve_barrier_affine_jacobian_py(conjugate_arg, prec_opt, init_soln, linear_part, offset,\",\n \"self.ridge_term opt_offset = self.initial_subgrad self.observed_score_state = -opt_linearNoU.dot(_beta_unpenalized) self.observed_score_state[~overall] += self.loglike.smooth_objective(beta_bar,\",\n \": `gaussian_query` A Gaussian query which has information to describe\",\n \"import interp1d import collections import numpy as np from numpy\",\n \"0, -self._initial_omega, 0) problem = rr.simple_problem(self.loglike, self.penalty) # if all\",\n \"setting this if norm(soln[group_mask]) > tol * norm(soln): # is\",\n \"in sorted(np.unique(self.groups)): # g is group label group_mask = self.groups\",\n \"self._families.append(discrete_family(grid, np.exp(logW))) def _approx_pivots(self, mean_parameter, alternatives=None): if not hasattr(self, \\\"_families\\\"):\",\n \"False self.selection_variable = {'directions': active_dirs, 'active_groups': active_groups} # kind of\",\n \"-- defaults to 0. level : float Confidence level. \\\"\\\"\\\"\",\n \"- self.loglike.saturated_loss.mean_function( XE.dot(observed_target))) ** 2 / self._W).sum() / (n -\",\n \"Sequence of strings describing the alternatives, should be values of\",\n \"- target_lin.dot(observed_target) if np.asarray(self.randomizer_prec).shape in [(), (0,)]: _P = target_linear.T.dot(target_offset)\",\n \"self._W).sum() / (n - XE.shape[1]) cov_target = self.QI * dispersion\",\n \"self.target_score_cov.shape[1] observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) target_score_cov_uni =\",\n \"active_dirs: \\\"\\\"\\\" scaling = np.sqrt(np.diag(con_linear.dot(precision).dot(con_linear.T))) if feasible_point is None: feasible_point\",\n \"keys of active_dirs self._ordered_groups = ordered_groups # exception if no\",\n \"_setup_implied_gaussian) logdens_linear: (model on _setup_implied_gaussian) linear_part: like A_scaling (from lasso)\",\n \"target. target_cov : ndarray Estimated covaraince of target. target_score_cov :\",\n \"1.5 * _scale[j], num=ngrid) else: ngrid = 100 self.stat_grid =\",\n \"Hypothesized value for parameter -- defaults to 0. level :\",\n \"= (np.diag(self.target_cov)[m]).reshape((1, 1)) target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) var_target =\",\n \"A_scaling (from lasso) offset: like b_scaling (from lasso) solve_args: passed\",\n \"agroups = np.array(groups) # check dimension if len(agroups.shape) != 1:\",\n \"== 0): result.insert(4, 'pivot', pivots) result.insert(5, 'parameter', parameter) return result\",\n \"= r def solve_barrier_affine_jacobian_py(conjugate_arg, precision, feasible_point, con_linear, con_offset, C, active_dirs,\",\n \"= np.linalg.inv(query.cond_cov) self.cond_cov = query.cond_cov self.C = query.C self.active_dirs =\",\n \"ValueError('alternative should be in [\\\"twosided\\\", \\\"less\\\", \\\"greater\\\"]') return pivot def\",\n \"observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) target_score_cov_uni = self.target_score_cov[m,\",\n \"target_cov, target_score_cov, alternatives) = self.selected_targets(dispersion) init_soln = self.observed_opt_state # just\",\n \"cond_cov, cond_precision, logdens_linear def selective_MLE(self, solve_args={'tol': 1.e-12}, level=0.9, useJacobian=True, dispersion=None):\",\n \"pg = active_dirs[g].size Lg = self.penalty.weights[g] * np.eye(pg) return Lg\",\n \"else: pivots = None pvalues = self._approx_pivots(np.zeros_like(self.observed_target), alternatives=alternatives) lower, upper\",\n \"_P = target_linear.T.dot(target_offset) * self.randomizer_prec _prec = prec_target + (target_linear.T.dot(target_linear)\",\n \"self.stat_grid[m].max(), 1000) logW = (approx_fn(grid) - 0.5 * (grid -\",\n \"= [[g] * (ug.size - 1) for (g, ug) in\",\n \"self.target_score_cov = target_score_cov self.target_cov = target_cov self.init_soln = query.observed_opt_state self.randomizer_prec\",\n \"self.stat_grid[j, :] = np.linspace(observed_target[j] - 1.5 * _scale[j], observed_target[j] +\",\n \"for g in sorted(np.unique(self.groups)): # g is group label group_mask\",\n \"= self.offset-self.linear_part.dot(R).dot(self.init_soln) conjugate_arg = implied_mean * implied_prec val, soln, _\",\n \"target_cov_uni, target_score_cov_uni, self.stat_grid[m]) if self.useIP == False: logW = (log_ref\",\n \"def fit(self, solve_args={'tol': 1.e-12, 'min_its': 50}, perturb=None): # solve the\",\n \"perturb if self._initial_omega is None: self._initial_omega = self.randomizer.sample() quad =\",\n \"def solve_barrier_affine_jacobian_py(conjugate_arg, precision, feasible_point, con_linear, con_offset, C, active_dirs, useJacobian=True, step=1,\",\n \"rr from .randomization import randomization from ..base import restricted_estimator from\",\n \"+ p2 + p3 + p4 def grad(gs): p1 =\",\n \"- jacobian_grad_hess(gs, C, active_dirs)[0] else: p3 = 0 p4 =\",\n \"loss self.loglike = loglike self.nfeature = self.loglike.shape[0] # ridge parameter\",\n \"current, hess # Jacobian calculations def calc_GammaMinus(gamma, active_dirs): \\\"\\\"\\\"Calculate Gamma^minus\",\n \"- target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],)) _prec = prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) -\",\n \"make sure proposal is a descent count = 0 while\",\n \"2 * np.minimum(pvalues, 1 - pvalues) alpha = 1 -\",\n \"['twosided'] * len(self.active) if dispersion is None: # use Pearson's\",\n \"Arguments passed to solver. \\\"\\\"\\\" self.solve_args = solve_args result, inverse_info\",\n \"raise ValueError('no target specified') prec_target = np.linalg.inv(target_cov) target_lin = -\",\n \"= inv(target_cov) prec_opt = self.cond_precision score_offset = self.observed_score_state + self.opt_offset\",\n \"* self.randomizer_prec _prec = prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) -\",\n \"group if pg > 1: Z = np.column_stack((ug, np.eye(pg, pg\",\n \"i in gp]) def jacobian_grad_hess(gamma, C, active_dirs): \\\"\\\"\\\" Calculate the\",\n \"sensible # log likelihood : quadratic loss self.loglike = loglike\",\n \"for group_lasso Note: this masks the selective_MLE inherited from query\",\n \"= 1 - level quantile = ndist.ppf(1 - alpha /\",\n \"prec_opt).dot( target_lin) else: _P = target_linear.T.dot(self.randomizer_prec).dot(target_offset) _prec = prec_target +\",\n \"from families follows `selectinf.learning.core` family = self._families[m] observed_target = self.observed_target[m]\",\n \"lower.append(l * var_target + observed_target) upper.append(u * var_target + observed_target)\",\n \"1))) Q, _ = qr(Z) Vg = Q[:, 1:] #\",\n \"group g appreciably nonzero ordered_groups.append(g) # variables in active group\",\n \"self.prec_opt).dot(target_lin) _P = target_linear.T.dot(target_offset) * self.randomizer_prec _r = (1. /\",\n \"logdens_linear def selective_MLE(self, solve_args={'tol': 1.e-12}, level=0.9, useJacobian=True, dispersion=None): \\\"\\\"\\\"Do selective_MLE\",\n \"offset = self.offset if np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no\",\n \"target_cov_uni target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) target_linear = target_score_cov_uni.T.dot(prec_target) target_offset\",\n \"current_value: break step *= 0.5 if count >= 20: if\",\n \"# Jacobian calculations def calc_GammaMinus(gamma, active_dirs): \\\"\\\"\\\"Calculate Gamma^minus (as a\",\n \"active_dirs.values()]) # gradient grad_J = S.dot(GpC_inv.diagonal()) # hessian hess_J =\",\n \"self.penalty) # if all groups are size 1, set up\",\n \"- alpha / 2.) intervals = np.vstack([final_estimator - quantile *\",\n \"how the conditional mean of optimization variables # vary with\",\n \"-conjugate_arg + precision.dot(gs) p2 = -con_linear.T.dot(1. / (scaling + con_offset\",\n \"for i, var in enumerate(ordered_vars): opt_linearNoU[var, i] += self.ridge_term opt_offset\",\n \"a number of assumptions that group_lasso makes about how groups\",\n \"= con_linear.T.dot(np.diag(-1. / ((scaling + con_offset - con_linear.dot(gs)) ** 2.)\",\n \"* _scale[j], observed_target[j] + 1.5 * _scale[j], num=ngrid) else: ngrid\",\n \"1, set up lasso penalty and run usual lasso solver...\",\n \"affine constraint used for barrier function con_offset: offset part of\",\n \"in range(nstep): cur_grad = grad(current) # make sure proposal is\",\n \"(self.stat_grid[m] - self.observed_target[m]) ** 2 / var_target) logW -= logW.max()\",\n \"len(agroups.shape) != 1: raise ValueError(\\\"Groups are not a 1D array_like\\\")\",\n \"matrix) \\\"\\\"\\\" if C.shape == (0, 0): # when all\",\n \"observed_target) return np.asarray(lower), np.asarray(upper) ### Private method def _construct_density(self): precs\",\n \"groups for g in sorted(np.unique(self.groups)): # g is group label\",\n \"self.cond_cov.dot(eta) * implied_prec R = np.identity(num_opt) - _A.dot(eta.T) A =\",\n \"have no gaps (e.g., if there is a group 2\",\n \"import block_diag from scipy.stats import norm as ndist from scipy.interpolate\",\n \"len(self.selection_variable['active_groups']) == 0: return np.sign(soln), soln # otherwise continue as\",\n \"ndist.cdf(Z_scores) pvalues = 2 * np.minimum(pvalues, 1 - pvalues) alpha\",\n \"\\\"something\\\" times D # Gamma is target_score_cov.T.dot(prec_target) num_opt = self.prec_opt.shape[0]\",\n \"proposal is a descent count = 0 while True: count\",\n \"1.e-15, 'min_its': 100}): # take a new perturbation if supplied\",\n \"/ var_target, x=self.observed_target[m]) print(\\\"variable completed \\\", m) if alternatives[m] ==\",\n \"as a class variable since the non-group lasso doesn't self.groups\",\n \"self.observed_opt_state # just the gammas cond_mean = self.cond_mean cond_cov =\",\n \"active_dirs, useJacobian=True, step=1, nstep=2000, min_its=500, tol=1.e-12): \\\"\\\"\\\" This needs to\",\n \"query because that is not adapted for the group_lasso. Also,\",\n \"randomization from ..base import restricted_estimator from ..algorithms.barrier_affine import solve_barrier_affine_py as\",\n \"soln, _ = solver(np.asarray([conjugate_arg]), np.reshape(implied_prec, (1,1)), eta.T.dot(self.init_soln), A.reshape((A.shape[0],1)), b, **self.solve_args)\",\n \"= np.log(np.linalg.det(GammaMinus + C)) # inverse #GpC_inv = evectors.dot(np.diag(1 /\",\n \"ValueError(\\\"Groups are not a 1D array_like\\\") # check sorted if\",\n \"loglike self.nfeature = self.loglike.shape[0] # ridge parameter self.ridge_term = ridge_term\",\n \"num=ngrid) else: ngrid = 100 self.stat_grid = np.zeros((ntarget, ngrid)) for\",\n \"= [] for m in range(self.ntarget): p = self.target_score_cov.shape[1] observed_target_uni\",\n \"U = block_diag(*[ug for ug in sorted_active_dirs.values()]).T self.opt_linear = opt_linearNoU.dot(U)\",\n \"i] += self.ridge_term opt_offset = self.initial_subgrad self.observed_score_state = -opt_linearNoU.dot(_beta_unpenalized) self.observed_score_state[~overall]\",\n \"= target_score_cov.T.dot(prec_target) target_offset = score_offset - target_linear.dot(observed_target) target_lin = -\",\n \"= self.randomizer.cov_prec if np.asarray(prec).shape in [(), (0,)]: cond_precision = self.opt_linear.T.dot(self.opt_linear)\",\n \"is None: self._initial_omega = self.randomizer.sample() quad = rr.identity_quadratic(self.ridge_term, 0, -self._initial_omega,\",\n \"target_cov.dot(_prec).dot(observed_target) + target_cov.dot( _P - target_lin.T.dot(prec_opt).dot(target_off)) L = target_lin.T.dot(prec_opt) observed_info_natural\",\n \"range(nstep): cur_grad = grad(current) # make sure proposal is feasible\",\n \"0: unpenalized.append(g) else: active_groups.append(g) active_dirs[g] = soln[group_mask] / norm(soln[group_mask]) ordered_opt.append(norm(soln[group_mask]))\",\n \"selected features Parameters ---------- alternatives : [str], optional Sequence of\",\n \"to keep setting this if norm(soln[group_mask]) > tol * norm(soln):\",\n \"= inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T).dot(prec) cond_mean = -logdens_linear.dot(self.observed_score_state + self.opt_offset)\",\n \"in range(ntarget): self.stat_grid[j, :] = np.linspace(observed_target[j] - 1.5 * _scale[j],\",\n \"where applicable - defaults to True perturb=None): _check_groups(groups) # make\",\n \"use_lasso=True, # should lasso solver be used where applicable -\",\n \"refit OLS on E overall, solve_args=solve_args) beta_bar = np.zeros(self.nfeature) beta_bar[overall]\",\n \"target_score_cov_uni.T.dot(prec_target) target_offset = (self.score_offset - target_linear.dot(observed_target_uni)).reshape( (target_linear.shape[0],)) target_lin = -self.logdens_linear.dot(target_linear)\",\n \"group 2 and a group 4, there must also be\",\n \"{} r = {} p = self.target_score_cov.shape[1] for m in\",\n \"= self.cond_cov logdens_linear = self.logdens_linear linear_part = self.linear_part offset =\",\n \"self._approx_pivots(parameter, alternatives=alternatives) else: pivots = None pvalues = self._approx_pivots(np.zeros_like(self.observed_target), alternatives=alternatives)\",\n \"actually use the Jacobian information (in self.C) arguments conjugate_arg: \\\\\\\\bar{\\\\\\\\Sigma}^{-1}\",\n \"log from numpy.linalg import norm, qr, inv, eig import pandas\",\n \"size 1, set up lasso penalty and run usual lasso\",\n \"gradient grad_J = S.dot(GpC_inv.diagonal()) # hessian hess_J = -S.dot(np.multiply(GpC_inv, GpC_inv.T).dot(S.T))\",\n \"= np.zeros(self.nfeature) beta_bar[overall] = _beta_unpenalized # refit OLS beta with\",\n \"hasattr(self, \\\"_families\\\"): self._construct_families() if alternatives is None: alternatives = ['twosided']\",\n \"pivot.append(1 - _cdf) elif alternatives[m] == 'less': pivot.append(_cdf) else: raise\",\n \"with keys of active_dirs self._ordered_groups = ordered_groups # exception if\",\n \"active group ordered_vars.extend(np.flatnonzero(group_mask)) if self.penalty.weights[g] == 0: unpenalized.append(g) else: active_groups.append(g)\",\n \"is size one, the orthogonal complement is empty return Vg\",\n \"in [(), (0,)]: _P = target_linear.T.dot(target_offset) * self.randomizer_prec _prec =\",\n \"= - jacobian_grad_hess(gs, C, active_dirs)[0] else: p3 = 0 p4\",\n \"- _cdf) elif alternatives[m] == 'less': pivot.append(_cdf) else: raise ValueError('alternative\",\n \"= self.XE Q = self.Q observed_target = restricted_estimator(self.loglike, self.ordered_vars, solve_args=solve_args)\",\n \"= self.initial_soln # do not need to keep setting this\",\n \"observed_info_mean = target_cov.dot(observed_info_natural.dot(target_cov)) Z_scores = final_estimator / np.sqrt(np.diag(observed_info_mean)) pvalues =\",\n \"offset part of affine constraint used for barrier function C:\",\n \"prec_target = inv(target_cov) prec_opt = self.cond_precision score_offset = self.observed_score_state +\",\n \"- proposed_value) < tol * np.fabs(current_value) and itercount >= min_its:\",\n \"current_value = proposed_value if itercount % 4 == 0: step\",\n \"self._solve_randomized_problem(perturb=perturb, solve_args=solve_args) # initialize variables active_groups = [] # active\",\n \"current = feasible_point current_value = np.inf for itercount in range(nstep):\",\n \"selected features Parameters ---------- query : `gaussian_query` A Gaussian query\",\n \"also be at least one feature in group 3). This\",\n \"sorted in increasing order, start at 0, and have no\",\n \"code)... initial_soln = problem.solve(quad, **solve_args) initial_subgrad = -(self.loglike.smooth_objective(initial_soln, 'grad') +\",\n \"_prec = prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( prec_opt).dot(\",\n \"== 0: unpenalized.append(g) else: active_groups.append(g) active_dirs[g] = soln[group_mask] / norm(soln[group_mask])\",\n \"XE.dot(observed_target))) ** 2 / self._W).sum() / (n - XE.shape[1]) cov_target\",\n \"if ridge_term is None: ridge_term = np.std(Y) * np.sqrt(mean_diag) /\",\n \"np.std(Y) * np.sqrt(mean_diag) / np.sqrt(n - 1) if randomizer_scale is\",\n \"num_opt = self.prec_opt.shape[0] num_con = self.linear_part.shape[0] cond_mean_grid = (target_lin.dot(np.atleast_1d(grid[k] -\",\n \"w in sorted(weights.items())]) self.penalty = rr.weighted_l1norm(weights=weights_np, lagrange=1.) else: self.penalty =\",\n \"self.groups = groups self._initial_omega = perturb # gaussian randomization self.randomizer\",\n \"self._construct_density() self._families = [] for m in range(self.ntarget): p =\",\n \"= prec_target + (target_linear.T.dot(self.randomizer_prec).dot(target_linear)) - target_lin.T.dot( prec_opt).dot(target_lin) C = target_cov.dot(_P\",\n \"in sorted_active_dirs.values()]).T self.opt_linear = opt_linearNoU.dot(U) self.active_dirs = active_dirs self.opt_offset =\",\n \"compute_Lg(g): pg = active_dirs[g].size Lg = self.penalty.weights[g] * np.eye(pg) return\",\n \"active groups for g in sorted(np.unique(self.groups)): # g is group\",\n \"a dictionary weights_np = np.array([w[1] for w in sorted(weights.items())]) self.penalty\",\n \"p2 current = feasible_point current_value = np.inf for itercount in\",\n \"float Confidence level. \\\"\\\"\\\" if parameter is not None: pivots\",\n \"- level quantile = ndist.ppf(1 - alpha / 2.) intervals\",\n \"linear_part, offset, self.C, self.active_dirs, useJacobian, **solve_args) final_estimator = target_cov.dot(_prec).dot(observed_target) \\\\\",\n \"import discrete_family class group_lasso(object): def __init__(self, loglike, groups, weights, ridge_term,\",\n \"weights_np = np.array([w[1] for w in sorted(weights.items())]) self.penalty = rr.weighted_l1norm(weights=weights_np,\",\n \"affine constraint used for barrier function C: V^T Q^{-1} \\\\\\\\Lambda\",\n \"/ scaling)).sum() return p1 + p2 + p3 + p4\",\n \"import pandas as pd import regreg.api as rr from .randomization\",\n \"Lg sorted_active_dirs = collections.OrderedDict(sorted(active_dirs.items())) Vs = [compute_Vg(ug) for ug in\",\n \"opt_offset = self.initial_subgrad self.observed_score_state = -opt_linearNoU.dot(_beta_unpenalized) self.observed_score_state[~overall] += self.loglike.smooth_objective(beta_bar, 'grad')[~overall]\",\n \"con_linear.dot(gs))) if useJacobian: p3 = - jacobian_grad_hess(gs, C, active_dirs)[1] else:\",\n \"_P - target_lin.T.dot(prec_opt).dot(target_off)) L = target_lin.T.dot(prec_opt) observed_info_natural = _prec +\",\n \"if there is a group 2 and a group 4,\",\n \"optimization variables cond_mean: conditional mean of optimization variables (model on\",\n \"# kind of redundant with keys of active_dirs self._ordered_groups =\",\n \"# check dimension if len(agroups.shape) != 1: raise ValueError(\\\"Groups are\",\n \"should be in [\\\"twosided\\\", \\\"less\\\", \\\"greater\\\"]') return pivot def _approx_intervals(self,\",\n \"alternatives) = query.selected_targets(dispersion) self.observed_target = observed_target self.target_score_cov = target_score_cov self.target_cov\",\n \"prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( prec_opt).dot( target_lin) else:\",\n \"linear part of affine constraint used for barrier function con_offset:\",\n \"self.score_offset = query.observed_score_state + query.opt_offset self.ntarget = ntarget = target_cov.shape[0]\",\n \"= None pvalues = self._approx_pivots(np.zeros_like(self.observed_target), alternatives=alternatives) lower, upper = self._approx_intervals(level=level)\",\n \"# target_lin determines how the conditional mean of optimization variables\",\n \"are collecting the directions and norms of the active groups\",\n \"norm(soln[group_mask]) ordered_opt.append(norm(soln[group_mask])) else: overall[group_mask] = False self.selection_variable = {'directions': active_dirs,\",\n \"that `groups` is a 1-d array_like of integers that are\",\n \"= _S r[m] = _r precs[m] = _prec self.precs =\",\n \"the mean depends on score, hence the minus sign target_linear\",\n \"prec = self.randomizer.cov_prec if np.asarray(prec).shape in [(), (0,)]: cond_precision =\",\n \"init_soln = self.observed_opt_state # just the gammas cond_mean = self.cond_mean\",\n \"Q^{-1} \\\\\\\\Lambda V active_dirs: \\\"\\\"\\\" scaling = np.sqrt(np.diag(con_linear.dot(precision).dot(con_linear.T))) if feasible_point\",\n \"0 p4 = 1. / (con_offset - con_linear.dot(gs)) return p1\",\n \"initialize variables active_groups = [] # active group labels active_dirs\",\n \"vector, active directions) \\\"\\\"\\\" to_diag = [[g] * (ug.size -\",\n \"self.offset-self.linear_part.dot(R).dot(self.init_soln) conjugate_arg = implied_mean * implied_prec val, soln, _ =\",\n \"* (ug.size - 1) for (g, ug) in zip(gamma, active_dirs.values())]\",\n \"self.opt_linear.T.dot(self.opt_linear) * prec cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T) *\",\n \"hess_J def _check_groups(groups): \\\"\\\"\\\"Make sure that the user-specific groups are\",\n \"(observed_target, target_cov, target_score_cov, alternatives) = query.selected_targets(dispersion) self.observed_target = observed_target self.target_score_cov\",\n \"g in sorted(np.unique(self.groups)): # g is group label group_mask =\",\n \"= val + conjugate_arg.T.dot(cond_cov).dot(conjugate_arg) / 2. result = pd.DataFrame({'MLE': final_estimator,\",\n \"objective(proposal) if proposed_value <= current_value: break step *= 0.5 if\",\n \"self.randomizer_prec = query.randomizer_prec self.score_offset = query.observed_score_state + query.opt_offset self.ntarget =\",\n \"(approx_fn(grid) - 0.5 * (grid - self.observed_target[m]) ** 2 /\",\n \"self.cond_mean = query.cond_mean self.prec_opt = np.linalg.inv(query.cond_cov) self.cond_cov = query.cond_cov self.C\",\n \"x=self.observed_target[m]) print(\\\"variable completed \\\", m) if alternatives[m] == 'twosided': pivot.append(2\",\n \"np.linalg.inv(GammaMinus + C) # summing matrix (gamma.size by C.shape[0]) S\",\n \"QI self.C = C U = block_diag(*[ug for ug in\",\n \"array_like\\\") # check sorted if np.any(agroups[:-1] > agroups[1:]) < 0:\",\n \"ordered_groups.append(g) # variables in active group ordered_vars.extend(np.flatnonzero(group_mask)) if self.penalty.weights[g] ==\",\n \"np.sqrt(np.diag(observed_info_mean)) pvalues = ndist.cdf(Z_scores) pvalues = 2 * np.minimum(pvalues, 1\",\n \"np.asarray(ref_hat) def _construct_families(self): self._construct_density() self._families = [] for m in\",\n \"None: self._initial_omega = perturb if self._initial_omega is None: self._initial_omega =\",\n \"mean depends on score, hence the minus sign target_linear =\",\n \"for w in sorted(weights.items())]) self.penalty = rr.weighted_l1norm(weights=weights_np, lagrange=1.) else: self.penalty\",\n \"at 0, and have no gaps (e.g., if there is\",\n \"if not (np.isnan(proposed_value) or np.isnan(current_value)): break else: raise ValueError('value is\",\n \"val, soln, _ = solver(np.asarray([conjugate_arg]), np.reshape(implied_prec, (1,1)), eta.T.dot(self.init_soln), A.reshape((A.shape[0],1)), b,\",\n \"# where \\\"something\\\" comes from implied Gaussian # cond_mean is\",\n \"# if the group is size one, the orthogonal complement\",\n \"1 - _cdf)) elif alternatives[m] == 'greater': pivot.append(1 - _cdf)\",\n \"\\\"\\\"\\\" if C.shape == (0, 0): # when all groups\",\n \"= prec_opt.dot(cond_mean) val, soln, hess = solve_barrier_affine_jacobian_py(conjugate_arg, prec_opt, init_soln, linear_part,\",\n \"+ L.dot(target_lin) - L.dot(hess.dot(L.T)) observed_info_mean = target_cov.dot(observed_info_natural.dot(target_cov)) Z_scores = final_estimator\",\n \"self.randomizer.cov_prec # now we are collecting the directions and norms\",\n \"- 0.5 * (grid - self.observed_target[m]) ** 2 / var_target)\",\n \"for ug in sorted_active_dirs.values()]).T self.opt_linear = opt_linearNoU.dot(U) self.active_dirs = active_dirs\",\n \"= np.mean((X ** 2).sum(0)) if ridge_term is None: ridge_term =\",\n \"randomizer_scale = np.sqrt(mean_diag) * 0.5 * np.std(Y) * np.sqrt(n /\",\n \"nonzero ordered_groups.append(g) # variables in active group ordered_vars.extend(np.flatnonzero(group_mask)) if self.penalty.weights[g]\",\n \"np.asarray(prec).shape in [(), (0,)]: cond_precision = self.opt_linear.T.dot(self.opt_linear) * prec cond_cov\",\n \"penalty overall = np.ones(self.nfeature, np.bool) # mask of active features\",\n \"Estimated covariance of target and score of randomized query. solve_args\",\n \"self._families = [] for m in range(self.ntarget): p = self.target_score_cov.shape[1]\",\n \"how groups are specified. Specifically, we assume that `groups` is\",\n \"0, 0 else: GammaMinus = calc_GammaMinus(gamma, active_dirs) # eigendecomposition #evalues,\",\n \"= cond_precision self.logdens_linear = logdens_linear return cond_mean, cond_cov, cond_precision, logdens_linear\",\n \"GpC_inv = np.linalg.inv(GammaMinus + C) # summing matrix (gamma.size by\",\n \"%f' % (proposed_value, current_value)) # stop if relative decrease is\",\n \"else: p2 = 0 return p1 + p2 current =\",\n \"exception if no groups are selected if len(self.selection_variable['active_groups']) == 0:\",\n \"Y, groups, weights, sigma=1., quadratic=None, ridge_term=0., perturb=None, use_lasso=True, # should\",\n \"* implied_cov)/ 2. + log_jacob[0]) return np.asarray(ref_hat) def _construct_families(self): self._construct_density()\",\n \"== 'greater': pivot.append(1 - _cdf) elif alternatives[m] == 'less': pivot.append(_cdf)\",\n \"unpack the list XE = X[:, ordered_vars] # changed to\",\n \"is a descent count = 0 while True: count +=\",\n \"of target. target_score_cov : ndarray Estimated covariance of target and\",\n \"groups if not np.all(np.diff(np.unique(agroups)) == 1): raise ValueError(\\\"Some group is\",\n \"W[:, np.newaxis]) for i, var in enumerate(ordered_vars): opt_linearNoU[var, i] +=\",\n \"assumes you have already run the fit method since this\",\n \"parameter is not None: pivots = self._approx_pivots(parameter, alternatives=alternatives) else: pivots\",\n \"target specified') observed_target = np.atleast_1d(observed_target) prec_target = inv(target_cov) prec_opt =\",\n \"def compute_Vg(ug): pg = ug.size # figure out size of\",\n \"-opt_linearNoU.dot(_beta_unpenalized) self.observed_score_state[~overall] += self.loglike.smooth_objective(beta_bar, 'grad')[~overall] active_signs = np.sign(self.initial_soln) active =\",\n \"/ ((self.precs[m])[0, 0]) lower.append(l * var_target + observed_target) upper.append(u *\",\n \"upper}) if not np.all(parameter == 0): result.insert(4, 'pivot', pivots) result.insert(5,\",\n \"= np.array(groups) # check dimension if len(agroups.shape) != 1: raise\",\n \"opt_offset self.ordered_vars = ordered_vars self.linear_part = -np.eye(self.observed_opt_state.shape[0]) self.offset = np.zeros(self.observed_opt_state.shape[0])\",\n \"- self.observed_target[m]) ** 2 / var_target) logW -= logW.max() self._families.append(discrete_family(self.stat_grid[m],\",\n \"= groups self._initial_omega = perturb # gaussian randomization self.randomizer =\",\n \"= ordered_vars self.linear_part = -np.eye(self.observed_opt_state.shape[0]) self.offset = np.zeros(self.observed_opt_state.shape[0]) return active_signs,\",\n \"gp]) def jacobian_grad_hess(gamma, C, active_dirs): \\\"\\\"\\\" Calculate the log-Jacobian (scalar),\",\n \"from ..distributions.discrete_family import discrete_family class group_lasso(object): def __init__(self, loglike, groups,\",\n \"conjugate_arg = implied_mean * implied_prec val, soln, _ = solver(np.asarray([conjugate_arg]),\",\n \"= np.std(Y) * np.sqrt(mean_diag) / np.sqrt(n - 1) if randomizer_scale\",\n \"sign target_linear = target_score_cov.T.dot(prec_target) target_offset = score_offset - target_linear.dot(observed_target) target_lin\",\n \"\\\"_families\\\"): self._construct_families() lower, upper = [], [] for m in\",\n \"perturb=None, use_lasso=True, # should lasso solver be used when applicable\",\n \"stop if relative decrease is small if np.fabs(current_value - proposed_value)\",\n \"solver be used where applicable - defaults to True perturb=None):\",\n \"*= 0.5 if count >= 40: raise ValueError('not finding a\",\n \"r[m] = _r precs[m] = _prec self.precs = precs self.S\",\n \"beta_bar X, y = self.loglike.data W = self._W = self.loglike.saturated_loss.hessian(X.dot(beta_bar))\",\n \"= np.zeros((1, 0)) # if the group is size one,\",\n \"X.shape XE = self.XE Q = self.Q observed_target = restricted_estimator(self.loglike,\",\n \"(observed_target, cov_target, crosscov_target_score, alternatives) class approximate_grid_inference(object): def __init__(self, query, dispersion,\",\n \"= np.sqrt(np.diag(con_linear.dot(precision).dot(con_linear.T))) if feasible_point is None: feasible_point = 1. /\",\n \"self.C = C U = block_diag(*[ug for ug in sorted_active_dirs.values()]).T\",\n \"_score_linear = -XE.T.dot(self._W[:, None] * X).T alternatives = ['twosided'] *\",\n \"((conjugate_arg ** 2) * implied_cov)/ 2. + log_jacob[0]) return np.asarray(ref_hat)\",\n \"optimization variables (model on _setup_implied_gaussian) cond_cov: conditional variance of optimization\",\n \"(gamma.size by C.shape[0]) S = block_diag(*[np.ones((1, ug.size - 1)) for\",\n \"* self.randomizer_prec _r = (1. / _prec).dot(target_lin.T.dot(self.prec_opt).dot(target_off) - _P) _S\",\n \"active_dirs): \\\"\\\"\\\" Calculate the log-Jacobian (scalar), gradient (gamma.size vector) and\",\n \"== 0: step *= 2 hess = inv(precision + barrier_hessian(current))\",\n \"log_jacob = jacobian_grad_hess(gamma_, self.C, self.active_dirs) ref_hat.append(-val - ((conjugate_arg ** 2)\",\n \"((con_offset - con_linear.dot(gs)) ** 2.))).dot(con_linear) if useJacobian: p2 = -\",\n \"inv, eig import pandas as pd import regreg.api as rr\",\n \"log(evalues).sum() J = np.log(np.linalg.det(GammaMinus + C)) # inverse #GpC_inv =\",\n \"soln def _solve_randomized_problem(self, perturb=None, solve_args={'tol': 1.e-15, 'min_its': 100}): # take\",\n \"features Parameters ---------- query : `gaussian_query` A Gaussian query which\",\n \"__init__(self, query, dispersion, solve_args={'tol': 1.e-12}, useIP=True): \\\"\\\"\\\" Produce p-values and\",\n \"in fitting) \\\"\\\"\\\" self._setup_implied_gaussian() # Calculate useful quantities (observed_target, target_cov,\",\n \"None: feasible_point = 1. / scaling def objective(gs): p1 =\",\n \"self.opt_linear = query.opt_linear self.useIP = useIP def summary(self, alternatives=None, parameter=None,\",\n \"target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) target_linear = target_score_cov_uni.T.dot(prec_target) target_offset =\",\n \"\\\"\\\"\\\" This needs to be updated to actually use the\",\n \"might do this for them. \\\"\\\"\\\" # check array_like agroups\",\n \"= [] for k in range(grid.shape[0]): # in the usual\",\n \"np.dot(X.T, X[:, ordered_vars] * W[:, np.newaxis]) for i, var in\",\n \"pd.DataFrame({'target': self.observed_target, 'pvalue': pvalues, 'lower_confidence': lower, 'upper_confidence': upper}) if not\",\n \"n, p = X.shape XE = self.XE Q = self.Q\",\n \"= observed_target self.target_score_cov = target_score_cov self.target_cov = target_cov self.init_soln =\",\n \"1.e-12, 'min_its': 50}): X, y = self.loglike.data n, p =\",\n \"# if all groups are size 1, set up lasso\",\n \"query.cond_mean self.prec_opt = np.linalg.inv(query.cond_cov) self.cond_cov = query.cond_cov self.C = query.C\",\n \"alternatives, should be values of ['twosided', 'less', 'greater'] parameter :\",\n \"are ok There are a number of assumptions that group_lasso\",\n \"np.sqrt(mean_diag) / np.sqrt(n - 1) if randomizer_scale is None: randomizer_scale\",\n \"inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T) * prec else: cond_precision = self.opt_linear.T.dot(prec.dot(self.opt_linear))\",\n \"# gradient grad_J = S.dot(GpC_inv.diagonal()) # hessian hess_J = -S.dot(np.multiply(GpC_inv,\",\n \"= inv(Q) C = V.T.dot(QI).dot(L).dot(V) self.XE = XE self.Q =\",\n \"the log of the reference density on a grid. \\\"\\\"\\\"\",\n \"== 'twosided': pivot.append(2 * min(_cdf, 1 - _cdf)) elif alternatives[m]\",\n \"= block_diag(*[ug for ug in sorted_active_dirs.values()]).T self.opt_linear = opt_linearNoU.dot(U) self.active_dirs\",\n \"2) * implied_cov)/ 2. + log_jacob[0]) return np.asarray(ref_hat) def _construct_families(self):\",\n \"> 0): break step *= 0.5 if count >= 40:\",\n \"cov_target = self.QI * dispersion crosscov_target_score = _score_linear.dot(self.QI).T * dispersion\",\n \"_setup_implied_gaussian) linear_part: like A_scaling (from lasso) offset: like b_scaling (from\",\n \"target_cov.dot(observed_info_natural.dot(target_cov)) Z_scores = final_estimator / np.sqrt(np.diag(observed_info_mean)) pvalues = ndist.cdf(Z_scores) pvalues\",\n \"if useIP == False: ngrid = 1000 self.stat_grid = np.zeros((ntarget,\",\n \"1./implied_cov _A = self.cond_cov.dot(eta) * implied_prec R = np.identity(num_opt) -\",\n \"import collections import numpy as np from numpy import log\",\n \"((self.precs[m])[0, 0]) mean = self.S[m].dot(mean_parameter[m].reshape((1,))) + self.r[m] _cdf = family.cdf((mean[0]\",\n \"= implied_mean * implied_prec val, soln, _ = solver(np.asarray([conjugate_arg]), np.reshape(implied_prec,\",\n \"[compute_Lg(g) for g in sorted_active_dirs] L = block_diag(*Ls) # unpack\",\n \"_A = self.cond_cov.dot(eta) * implied_prec R = np.identity(num_opt) - _A.dot(eta.T)\",\n \"family.equal_tailed_interval(observed_target, alpha=1 - level) var_target = 1. / ((self.precs[m])[0, 0])\",\n \"on _setup_implied_gaussian) logdens_linear: (model on _setup_implied_gaussian) linear_part: like A_scaling (from\",\n \"mask of active features ordered_groups = [] # active group\",\n \"np.sqrt(np.diag(observed_info_mean))]).T log_ref = val + conjugate_arg.T.dot(cond_cov).dot(conjugate_arg) / 2. result =\",\n \"0: step *= 2 hess = inv(precision + barrier_hessian(current)) return\",\n \"logW = (log_ref - 0.5 * (self.stat_grid[m] - self.observed_target[m]) **\",\n \"self.S = S self.r = r def solve_barrier_affine_jacobian_py(conjugate_arg, precision, feasible_point,\",\n \"self._construct_families() if alternatives is None: alternatives = ['twosided'] * self.ntarget\",\n \"hasattr(self, \\\"_families\\\"): self._construct_families() lower, upper = [], [] for m\",\n \"is None: alternatives = ['twosided'] * self.ntarget pivot = []\",\n \"group 3). This function checks the user-specified group scheme and\",\n \"is group g appreciably nonzero ordered_groups.append(g) # variables in active\",\n \"for ug in active_dirs.values()]) # gradient grad_J = S.dot(GpC_inv.diagonal()) #\",\n \"groups, weights, sigma=1., quadratic=None, ridge_term=0., perturb=None, use_lasso=True, # should lasso\",\n \"size one, the orthogonal complement is empty return Vg def\",\n \"1.e-12}, level=0.9, useJacobian=True, dispersion=None): \\\"\\\"\\\"Do selective_MLE for group_lasso Note: this\",\n \"itercount % 4 == 0: step *= 2 hess =\",\n \"p = self.target_score_cov.shape[1] for m in range(self.ntarget): observed_target_uni = (self.observed_target[m]).reshape((1,))\",\n \"_check_groups(groups) # make sure groups looks sensible # log likelihood\",\n \"soln = self.initial_soln # do not need to keep setting\",\n \"Gamma is target_score_cov.T.dot(prec_target) num_opt = self.prec_opt.shape[0] num_con = self.linear_part.shape[0] cond_mean_grid\",\n \"gaps (e.g., if there is a group 2 and a\",\n \"raise ValueError(\\\"Groups are not a 1D array_like\\\") # check sorted\",\n \"the active groups for g in sorted(np.unique(self.groups)): # g is\",\n \"# use Pearson's X^2 dispersion = ((y - self.loglike.saturated_loss.mean_function( XE.dot(observed_target)))\",\n \"loglike, groups, weights, ridge_term, randomizer, use_lasso=True, # should lasso solver\",\n \"(0,)]: _P = target_linear.T.dot(target_offset) * self.randomizer_prec _prec = prec_target +\",\n \"depends on score, hence the minus sign target_linear = target_score_cov.T.dot(prec_target)\",\n \"1000 self.stat_grid = np.zeros((ntarget, ngrid)) for j in range(ntarget): self.stat_grid[j,\",\n \"on _setup_implied_gaussian) linear_part: like A_scaling (from lasso) offset: like b_scaling\",\n \"directions and norms of the active groups for g in\",\n \"cond_mean: conditional mean of optimization variables (model on _setup_implied_gaussian) cond_cov:\",\n \"ordered_vars] # changed to ordered_vars Q = XE.T.dot(self._W[:, None] *\",\n \"return result, observed_info_mean, log_ref def selected_targets(self, dispersion=None, solve_args={'tol': 1.e-12, 'min_its':\",\n \"numpy import log from numpy.linalg import norm, qr, inv, eig\",\n \"active = np.flatnonzero(active_signs) self.active = active def compute_Vg(ug): pg =\",\n \"j in range(ntarget): self.stat_grid[j, :] = np.linspace(observed_target[j] - 1.5 *\",\n \"= target_lin.T.dot(prec_opt) observed_info_natural = _prec + L.dot(target_lin) - L.dot(hess.dot(L.T)) observed_info_mean\",\n \"jacobian_grad_hess(gs, C, active_dirs)[0] else: p3 = 0 p4 = log(1.\",\n \"(target_linear.shape[0],)) target_lin = -self.logdens_linear.dot(target_linear) target_off = (self.cond_mean - target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],)) _prec\",\n \"# store groups as a class variable since the non-group\",\n \"randomization self.randomizer = randomizer def fit(self, solve_args={'tol': 1.e-12, 'min_its': 50},\",\n \"= proposed_value if itercount % 4 == 0: step *=\",\n \"as np from numpy import log from numpy.linalg import norm,\",\n \"con_linear, con_offset, C, active_dirs, useJacobian=True, step=1, nstep=2000, min_its=500, tol=1.e-12): \\\"\\\"\\\"\",\n \"must also be at least one feature in group 3).\",\n \"= {} r = {} p = self.target_score_cov.shape[1] for m\",\n \"= 1./implied_cov _A = self.cond_cov.dot(eta) * implied_prec R = np.identity(num_opt)\",\n \"= solve_args result, inverse_info = query.selective_MLE(dispersion=dispersion)[:2] self.linear_part = query.linear_part self.offset\",\n \"min(_cdf, 1 - _cdf)) elif alternatives[m] == 'greater': pivot.append(1 -\",\n \"# otherwise continue as before self.observed_opt_state = np.hstack(ordered_opt) # gammas\",\n \"0.5 * (grid - self.observed_target[m]) ** 2 / var_target) logW\",\n \"return group_lasso(loglike, groups, weights, ridge_term, randomizer, use_lasso, perturb) def _setup_implied_gaussian(self):\",\n \"group 4, there must also be at least one feature\",\n \"C, active_dirs)[2] else: p2 = 0 return p1 + p2\",\n \"up lasso penalty and run usual lasso solver... (see existing\",\n \"lasso (self.initial_soln, self.initial_subgrad) = self._solve_randomized_problem(perturb=perturb, solve_args=solve_args) # initialize variables active_groups\",\n \"confidence intervals useC: whether to use python or C solver\",\n \"= np.linalg.inv(GammaMinus + C) # summing matrix (gamma.size by C.shape[0])\",\n \"vary with target # logdens_linear determines how the argument of\",\n \"fitting) \\\"\\\"\\\" self._setup_implied_gaussian() # Calculate useful quantities (observed_target, target_cov, target_score_cov,\",\n \"Parameters ---------- alternatives : [str], optional Sequence of strings describing\",\n \"is group label group_mask = self.groups == g soln =\",\n \"Lg = self.penalty.weights[g] * np.eye(pg) return Lg sorted_active_dirs = collections.OrderedDict(sorted(active_dirs.items()))\",\n \"R = np.identity(num_opt) - _A.dot(eta.T) A = self.linear_part.dot(_A).reshape((-1,)) b =\",\n \"lasso penalty and run usual lasso solver... (see existing code)...\",\n \"+ query.opt_offset self.ntarget = ntarget = target_cov.shape[0] _scale = 4\",\n \"target_cov.dot( _P - target_lin.T.dot(prec_opt).dot(target_off)) L = target_lin.T.dot(prec_opt) observed_info_natural = _prec\",\n \"lasso) offset: like b_scaling (from lasso) solve_args: passed on to\",\n \"self.C) arguments conjugate_arg: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} \\\\bar{\\\\\\\\mu} precision: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} feasible_point: gamma's from\",\n \"feasible count = 0 while True: count += 1 proposal\",\n \"count = 0 while True: count += 1 proposal =\",\n \"else: raise ValueError('value is NaN: %f, %f' % (proposed_value, current_value))\",\n \"= self.target_score_cov[m, :].reshape((1, p)) target_linear = target_score_cov_uni.T.dot(prec_target) target_offset = (self.score_offset\",\n \"perturb=None): # solve the randomized version of group lasso (self.initial_soln,\",\n \"whether to use python or C solver JacobianPieces: (use self.C\",\n \"unpenalized = [] # selected groups with no penalty overall\",\n \"0 while True: count += 1 proposal = current -\",\n \"method def _construct_density(self): precs = {} S = {} r\",\n \"active_dirs = {} # dictionary: keys are group labels, values\",\n \"beta with zeros self._beta_full = beta_bar X, y = self.loglike.data\",\n \"1.5 * _scale[j], num=ngrid) self.opt_linear = query.opt_linear self.useIP = useIP\",\n \"gs.T.dot(precision).dot(gs) / 2. if useJacobian: p3 = - jacobian_grad_hess(gs, C,\",\n \"W = self._W = self.loglike.saturated_loss.hessian(X.dot(beta_bar)) # all 1's for LS\",\n \"((self.precs[m])[0, 0]) log_ref = self.log_reference(observed_target_uni, target_cov_uni, target_score_cov_uni, self.stat_grid[m]) if self.useIP\",\n \"if perturb is not None: self._initial_omega = perturb if self._initial_omega\",\n \"p3 + p4 def grad(gs): p1 = -conjugate_arg + precision.dot(gs)\",\n \"in increasing order, start at 0, and have no gaps\",\n \"= np.linalg.inv(_prec).dot(prec_target) S[m] = _S r[m] = _r precs[m] =\",\n \"useJacobian: p3 = - jacobian_grad_hess(gs, C, active_dirs)[1] else: p3 =\",\n \"- 1)) for ug in active_dirs.values()]) # gradient grad_J =\",\n \"V.T.dot(QI).dot(L).dot(V) self.XE = XE self.Q = Q self.QI = QI\",\n \"+ C) # log Jacobian #J = log(evalues).sum() J =\",\n \"rr.group_lasso(groups, weights=weights, lagrange=1.) # store groups as a class variable\",\n \"lasso solver be used when applicable - defaults to True\",\n \"---------- query : `gaussian_query` A Gaussian query which has information\",\n \"p1 + p2 + p3 + p4 def grad(gs): p1\",\n \"..distributions.discrete_family import discrete_family class group_lasso(object): def __init__(self, loglike, groups, weights,\",\n \"'min_its': 100}): # take a new perturbation if supplied if\",\n \"exception if it finds any problems. Sorting feature groups is\",\n \"= 1000 self.stat_grid = np.zeros((ntarget, ngrid)) for j in range(ntarget):\",\n \"* cur_grad if np.all(con_offset - con_linear.dot(proposal) > 0): break step\",\n \"selective_MLE for group_lasso Note: this masks the selective_MLE inherited from\",\n \"if np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no target specified') prec_target\",\n \"query : `gaussian_query` A Gaussian query which has information to\",\n \"pd.DataFrame({'MLE': final_estimator, 'SE': np.sqrt(np.diag(observed_info_mean)), 'Zvalue': Z_scores, 'pvalue': pvalues, 'lower_confidence': intervals[:,\",\n \"- defaults to True perturb=None): _check_groups(groups) # make sure groups\",\n \"alternatives : [str], optional Sequence of strings describing the alternatives,\",\n \"tol * norm(soln): # is group g appreciably nonzero ordered_groups.append(g)\",\n \"rr.simple_problem(self.loglike, self.penalty) # if all groups are size 1, set\",\n \"# Calculate useful quantities (observed_target, target_cov, target_score_cov, alternatives) = self.selected_targets(dispersion)\",\n \"* dispersion crosscov_target_score = _score_linear.dot(self.QI).T * dispersion return (observed_target, cov_target,\",\n \"target_lin.T.dot( prec_opt).dot(target_lin) C = target_cov.dot(_P - target_lin.T.dot(prec_opt).dot(target_off)) conjugate_arg = prec_opt.dot(cond_mean)\",\n \"alternatives[m] == 'twosided': pivot.append(2 * min(_cdf, 1 - _cdf)) elif\",\n \"and norms of the active groups for g in sorted(np.unique(self.groups)):\",\n \"the group is size one, the orthogonal complement is empty\",\n \"_P = target_linear.T.dot(target_offset) * self.randomizer_prec _r = (1. / _prec).dot(target_lin.T.dot(self.prec_opt).dot(target_off)\",\n \"target_off = (self.cond_mean - target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],)) _prec = prec_target + (target_linear.T.dot(target_linear)\",\n \"np.hstack(ordered_opt) # gammas as array _beta_unpenalized = restricted_estimator(self.loglike, # refit\",\n \"self.observed_opt_state = np.hstack(ordered_opt) # gammas as array _beta_unpenalized = restricted_estimator(self.loglike,\",\n \"useJacobian, **solve_args) final_estimator = target_cov.dot(_prec).dot(observed_target) \\\\ + target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean - soln)))\",\n \"np.sqrt(n / (n - 1.)) randomizer = randomization.isotropic_gaussian((p,), randomizer_scale) return\",\n \"when applicable - defaults to True randomizer_scale=None): loglike = rr.glm.gaussian(X,\",\n \"'greater': pivot.append(1 - _cdf) elif alternatives[m] == 'less': pivot.append(_cdf) else:\",\n \"_scale = 4 * np.sqrt(np.diag(inverse_info)) if useIP == False: ngrid\",\n \"a 1D array_like\\\") # check sorted if np.any(agroups[:-1] > agroups[1:])\",\n \"= (1. / _prec).dot(target_lin.T.dot(self.prec_opt).dot(target_off) - _P) _S = np.linalg.inv(_prec).dot(prec_target) S[m]\",\n \"+ (target_linear.T.dot(self.randomizer_prec).dot(target_linear)) - target_lin.T.dot( prec_opt).dot(target_lin) C = target_cov.dot(_P - target_lin.T.dot(prec_opt).dot(target_off))\",\n \"in gp]) def jacobian_grad_hess(gamma, C, active_dirs): \\\"\\\"\\\" Calculate the log-Jacobian\",\n \"/ var_target) logW -= logW.max() self._families.append(discrete_family(grid, np.exp(logW))) def _approx_pivots(self, mean_parameter,\",\n \"from ..algorithms.barrier_affine import solve_barrier_affine_py as solver from ..distributions.discrete_family import discrete_family\",\n \"= query.randomizer_prec self.score_offset = query.observed_score_state + query.opt_offset self.ntarget = ntarget\",\n \"1: Z = np.column_stack((ug, np.eye(pg, pg - 1))) Q, _\",\n \"level) var_target = 1. / ((self.precs[m])[0, 0]) lower.append(l * var_target\",\n \"= rr.glm.gaussian(X, Y, coef=1. / sigma ** 2, quadratic=quadratic) n,\",\n \"= self.opt_linear.T.dot(prec.dot(self.opt_linear)) cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T).dot(prec) cond_mean =\",\n \"jacobian_grad_hess(gs, C, active_dirs)[1] else: p3 = 0 p4 = 1.\",\n \"= query.linear_part self.offset = query.offset self.logdens_linear = query.logdens_linear self.cond_mean =\",\n \"level: level of confidence intervals useC: whether to use python\",\n \"itercount >= min_its: current = proposal current_value = proposed_value break\",\n \"+= 1 proposal = current - step * cur_grad if\",\n \"self.observed_target = observed_target self.target_score_cov = target_score_cov self.target_cov = target_cov self.init_soln\",\n \"ValueError(\\\"Groups are not sorted\\\") # check integers if not np.issubdtype(agroups.dtype,\",\n \"self.linear_part = query.linear_part self.offset = query.offset self.logdens_linear = query.logdens_linear self.cond_mean\",\n \"self.QI = QI self.C = C U = block_diag(*[ug for\",\n \"# when all groups are size one, C will be\",\n \"of optimization variables (model on _setup_implied_gaussian) cond_cov: conditional variance of\",\n \"None: self._initial_omega = self.randomizer.sample() quad = rr.identity_quadratic(self.ridge_term, 0, -self._initial_omega, 0)\",\n \"var_target, x=self.observed_target[m]) print(\\\"variable completed \\\", m) if alternatives[m] == 'twosided':\",\n \"defined in fitting) \\\"\\\"\\\" self._setup_implied_gaussian() # Calculate useful quantities (observed_target,\",\n \"inverse #GpC_inv = evectors.dot(np.diag(1 / evalues).dot(evectors.T)) GpC_inv = np.linalg.inv(GammaMinus +\",\n \"cond_cov.dot(self.opt_linear.T) * prec else: cond_precision = self.opt_linear.T.dot(prec.dot(self.opt_linear)) cond_cov = inv(cond_precision)\",\n \"ridge parameter self.ridge_term = ridge_term # group lasso penalty (from\",\n \"block_diag(*Vs) # unpack the list Ls = [compute_Lg(g) for g\",\n \"proposed_value break current = proposal current_value = proposed_value if itercount\",\n \"query.active_dirs (observed_target, target_cov, target_score_cov, alternatives) = query.selected_targets(dispersion) self.observed_target = observed_target\",\n \"constraint used for barrier function C: V^T Q^{-1} \\\\\\\\Lambda V\",\n \"on _setup_implied_gaussian) cond_cov: conditional variance of optimization variables (model on\",\n \"and jacobian to hessian p1 = con_linear.T.dot(np.diag(-1. / ((scaling +\",\n \"range(self.ntarget): # construction of intervals from families follows `selectinf.learning.core` family\",\n \"= - jacobian_grad_hess(gs, C, active_dirs)[1] else: p3 = 0 p4\",\n \"from implied Gaussian # cond_mean is \\\"something\\\" times D #\",\n \"nstep=2000, min_its=500, tol=1.e-12): \\\"\\\"\\\" This needs to be updated to\",\n \"where \\\"something\\\" comes from implied Gaussian # cond_mean is \\\"something\\\"\",\n \"numpy.linalg import norm, qr, inv, eig import pandas as pd\",\n \"# all 1's for LS opt_linearNoU = np.dot(X.T, X[:, ordered_vars]\",\n \"logdens_linear return cond_mean, cond_cov, cond_precision, logdens_linear def selective_MLE(self, solve_args={'tol': 1.e-12},\",\n \"alternatives=None): if not hasattr(self, \\\"_families\\\"): self._construct_families() if alternatives is None:\",\n \"any problems. Sorting feature groups is potentially tedious for the\",\n \"1 - level quantile = ndist.ppf(1 - alpha / 2.)\",\n \"weights an an np.array rather than a dictionary weights_np =\",\n \"coefficients unpenalized = [] # selected groups with no penalty\",\n \"Also, assumes you have already run the fit method since\",\n \"part of affine constraint used for barrier function con_offset: offset\",\n \"discrete_family class group_lasso(object): def __init__(self, loglike, groups, weights, ridge_term, randomizer,\",\n \"# exception if no groups are selected if len(self.selection_variable['active_groups']) ==\",\n \"increasing order, start at 0, and have no gaps (e.g.,\",\n \"selective_MLE(self, solve_args={'tol': 1.e-12}, level=0.9, useJacobian=True, dispersion=None): \\\"\\\"\\\"Do selective_MLE for group_lasso\",\n \"< tol * np.fabs(current_value) and itercount >= min_its: current =\",\n \"= self.observed_opt_state # just the gammas cond_mean = self.cond_mean cond_cov\",\n \"= inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T) * prec else: cond_precision =\",\n \"- 1) if randomizer_scale is None: randomizer_scale = np.sqrt(mean_diag) *\",\n \"(n - XE.shape[1]) cov_target = self.QI * dispersion crosscov_target_score =\",\n \"inverse_info = query.selective_MLE(dispersion=dispersion)[:2] self.linear_part = query.linear_part self.offset = query.offset self.logdens_linear\",\n \"jacobian_grad_hess(gs, C, active_dirs)[2] else: p2 = 0 return p1 +\",\n \"_ = qr(Z) Vg = Q[:, 1:] # drop the\",\n \"Q self.QI = QI self.C = C U = block_diag(*[ug\",\n \"Q = self.Q observed_target = restricted_estimator(self.loglike, self.ordered_vars, solve_args=solve_args) _score_linear =\",\n \"prec_target + (target_linear.T.dot(self.randomizer_prec).dot(target_linear)) - target_lin.T.dot( prec_opt).dot(target_lin) C = target_cov.dot(_P -\",\n \"self.observed_target[m]) ** 2 / var_target) logW -= logW.max() self._families.append(discrete_family(self.stat_grid[m], np.exp(logW)))\",\n \"self.logdens_linear linear_part = self.linear_part offset = self.offset if np.asarray(observed_target).shape in\",\n \"[str], optional Sequence of strings describing the alternatives, should be\",\n \"0]) log_ref = self.log_reference(observed_target_uni, target_cov_uni, target_score_cov_uni, self.stat_grid[m]) if self.useIP ==\",\n \"from fitting con_linear: linear part of affine constraint used for\",\n \"0\\\") # check for no skipped groups if not np.all(np.diff(np.unique(agroups))\",\n \"are not sorted\\\") # check integers if not np.issubdtype(agroups.dtype, np.integer):\",\n \"should lasso solver be used when applicable - defaults to\",\n \"50}): X, y = self.loglike.data n, p = X.shape XE\",\n \"raise TypeError(\\\"Groups are not integers\\\") # check starts with 0\",\n \"labels sorted by label ordered_opt = [] # gamma's ordered\",\n \"if len(agroups.shape) != 1: raise ValueError(\\\"Groups are not a 1D\",\n \"cond_precision, logdens_linear def selective_MLE(self, solve_args={'tol': 1.e-12}, level=0.9, useJacobian=True, dispersion=None): \\\"\\\"\\\"Do\",\n \"the usual D = N + Gamma theta.hat, # target_lin\",\n \"no penalty overall = np.ones(self.nfeature, np.bool) # mask of active\",\n \"* X).T alternatives = ['twosided'] * len(self.active) if dispersion is\",\n \"weights, ridge_term, randomizer, use_lasso=True, # should lasso solver be used\",\n \"alpha = 1 - level quantile = ndist.ppf(1 - alpha\",\n \"self.penalty = rr.group_lasso(groups, weights=weights, lagrange=1.) # store groups as a\",\n \"of affine constraint used for barrier function C: V^T Q^{-1}\",\n \"self.cond_mean) #direction for decomposing o eta = -self.prec_opt.dot(self.logdens_linear.dot(target_score_cov.T)) implied_mean =\",\n \"cond_mean - target_lin.dot(observed_target) if np.asarray(self.randomizer_prec).shape in [(), (0,)]: _P =\",\n \"* np.sqrt(mean_diag) / np.sqrt(n - 1) if randomizer_scale is None:\",\n \"looks sensible # log likelihood : quadratic loss self.loglike =\",\n \"optimization variables (model on _setup_implied_gaussian) logdens_linear: (model on _setup_implied_gaussian) linear_part:\",\n \"_scale[j], num=ngrid) self.opt_linear = query.opt_linear self.useIP = useIP def summary(self,\",\n \"* (self.stat_grid[m] - self.observed_target[m]) ** 2 / var_target) logW -=\",\n \"# solve the randomized version of group lasso (self.initial_soln, self.initial_subgrad)\",\n \"return cond_mean, cond_cov, cond_precision, logdens_linear def selective_MLE(self, solve_args={'tol': 1.e-12}, level=0.9,\",\n \"is not None: pivots = self._approx_pivots(parameter, alternatives=alternatives) else: pivots =\",\n \"None pvalues = self._approx_pivots(np.zeros_like(self.observed_target), alternatives=alternatives) lower, upper = self._approx_intervals(level=level) result\",\n \"self._W = self.loglike.saturated_loss.hessian(X.dot(beta_bar)) # all 1's for LS opt_linearNoU =\",\n \"self.Q observed_target = restricted_estimator(self.loglike, self.ordered_vars, solve_args=solve_args) _score_linear = -XE.T.dot(self._W[:, None]\",\n \"- con_linear.dot(gs)) / scaling)).sum() return p1 + p2 + p3\",\n \"prec_opt).dot(target_lin) C = target_cov.dot(_P - target_lin.T.dot(prec_opt).dot(target_off)) conjugate_arg = prec_opt.dot(cond_mean) val,\",\n \"np.integer): raise TypeError(\\\"Groups are not integers\\\") # check starts with\",\n \"m) if alternatives[m] == 'twosided': pivot.append(2 * min(_cdf, 1 -\",\n \"`selectinf.learning.core` family = self._families[m] observed_target = self.observed_target[m] l, u =\",\n \"self.active_dirs = query.active_dirs (observed_target, target_cov, target_score_cov, alternatives) = query.selected_targets(dispersion) self.observed_target\",\n \"[] # active group labels active_dirs = {} # dictionary:\",\n \"['twosided', 'less', 'greater'] parameter : np.array Hypothesized value for parameter\",\n \"method. Parameters ---------- observed_target: from selected_targets target_cov: from selected_targets target_cov_score:\",\n \"**solve_args) final_estimator = target_cov.dot(_prec).dot(observed_target) \\\\ + target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean - soln))) +\",\n \"prec_target = np.linalg.inv(target_cov) target_lin = - self.logdens_linear.dot(target_score_cov.T.dot(prec_target)) ref_hat = []\",\n \"self.stat_grid[m]) if self.useIP == False: logW = (log_ref - 0.5\",\n \"(1. / _prec).dot(target_lin.T.dot(self.prec_opt).dot(target_off) - _P) _S = np.linalg.inv(_prec).dot(prec_target) S[m] =\",\n \"for them. \\\"\\\"\\\" # check array_like agroups = np.array(groups) #\",\n \"- 1.)) randomizer = randomization.isotropic_gaussian((p,), randomizer_scale) return group_lasso(loglike, groups, weights,\",\n \"== False: ngrid = 1000 self.stat_grid = np.zeros((ntarget, ngrid)) for\",\n \"for targets of model including selected features Parameters ---------- alternatives\",\n \"target_lin determines how the conditional mean of optimization variables #\",\n \"'greater'] parameter : np.array Hypothesized value for parameter -- defaults\",\n \"(opt_state) initial (observed) value of optimization variables cond_mean: conditional mean\",\n \"ordered_opt.append(norm(soln[group_mask])) else: overall[group_mask] = False self.selection_variable = {'directions': active_dirs, 'active_groups':\",\n \"/ ((self.precs[m])[0, 0]) log_ref = self.log_reference(observed_target_uni, target_cov_uni, target_score_cov_uni, self.stat_grid[m]) if\",\n \"= query.selected_targets(dispersion) self.observed_target = observed_target self.target_score_cov = target_score_cov self.target_cov =\",\n \"not 0\\\") # check for no skipped groups if not\",\n \"inv(Q) C = V.T.dot(QI).dot(L).dot(V) self.XE = XE self.Q = Q\",\n \"perturb=None): _check_groups(groups) # make sure groups looks sensible # log\",\n \"Observed estimate of target. target_cov : ndarray Estimated covaraince of\",\n \"p1 = -conjugate_arg + precision.dot(gs) p2 = -con_linear.T.dot(1. / (scaling\",\n \"restricted_estimator from ..algorithms.barrier_affine import solve_barrier_affine_py as solver from ..distributions.discrete_family import\",\n \"sorting group labels tol = 1.e-20 _, self.randomizer_prec = self.randomizer.cov_prec\",\n \"con_offset - con_linear.dot(gs)) ** 2.) + 1. / ((con_offset -\",\n \"* _scale[j], num=ngrid) else: ngrid = 100 self.stat_grid = np.zeros((ntarget,\",\n \"np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no target specified') observed_target =\",\n \"m in range(self.ntarget): family = self._families[m] var_target = 1. /\",\n \"{} # dictionary: keys are group labels, values are unit-norm\",\n \"(0,)]: raise ValueError('no target specified') observed_target = np.atleast_1d(observed_target) prec_target =\",\n \"'min_its': 50}): X, y = self.loglike.data n, p = X.shape\",\n \"+ 1.5 * _scale[j], num=ngrid) else: ngrid = 100 self.stat_grid\",\n \"_setup_implied_gaussian) cond_cov: conditional variance of optimization variables (model on _setup_implied_gaussian)\",\n \"jacobian_grad_hess(gamma_, self.C, self.active_dirs) ref_hat.append(-val - ((conjugate_arg ** 2) * implied_cov)/\",\n \"_construct_families(self): self._construct_density() self._families = [] for m in range(self.ntarget): p\",\n \"self.useIP == False: logW = (log_ref - 0.5 * (self.stat_grid[m]\",\n \"_beta_unpenalized = restricted_estimator(self.loglike, # refit OLS on E overall, solve_args=solve_args)\",\n \"randomizer = randomization.isotropic_gaussian((p,), randomizer_scale) return group_lasso(loglike, groups, weights, ridge_term, randomizer,\",\n \"of randomized query. solve_args : dict, optional Arguments passed to\",\n \"_, self.randomizer_prec = self.randomizer.cov_prec # now we are collecting the\",\n \"= self.target_score_cov[m, :].reshape((1, p)) var_target = 1. / ((self.precs[m])[0, 0])\",\n \"= (log_ref - 0.5 * (self.stat_grid[m] - self.observed_target[m]) ** 2\",\n \"active def compute_Vg(ug): pg = ug.size # figure out size\",\n \"!= 1: raise ValueError(\\\"Groups are not a 1D array_like\\\") #\",\n \"- target_lin.T.dot(prec_opt).dot(target_off)) conjugate_arg = prec_opt.dot(cond_mean) val, soln, hess = solve_barrier_affine_jacobian_py(conjugate_arg,\",\n \"active group labels sorted by label ordered_opt = [] #\",\n \"qr(Z) Vg = Q[:, 1:] # drop the first column\",\n \"complement is empty return Vg def compute_Lg(g): pg = active_dirs[g].size\",\n \"in the usual D = N + Gamma theta.hat, #\",\n \"# group lasso penalty (from regreg) # use regular lasso\",\n \"1:] # drop the first column else: Vg = np.zeros((1,\",\n \"= _r precs[m] = _prec self.precs = precs self.S =\",\n \"np.column_stack((ug, np.eye(pg, pg - 1))) Q, _ = qr(Z) Vg\",\n \"not sorted\\\") # check integers if not np.issubdtype(agroups.dtype, np.integer): raise\",\n \"-logdens_linear.dot(self.observed_score_state + self.opt_offset) self.cond_mean = cond_mean self.cond_cov = cond_cov self.cond_precision\",\n \"\\\"_families\\\"): self._construct_families() if alternatives is None: alternatives = ['twosided'] *\",\n \"0. level : float Confidence level. \\\"\\\"\\\" if parameter is\",\n \"np.amin(agroups) == 0: raise ValueError(\\\"First group is not 0\\\") #\",\n \"y = self.loglike.data n, p = X.shape XE = self.XE\",\n \"- quantile * np.sqrt(np.diag(observed_info_mean)), final_estimator + quantile * np.sqrt(np.diag(observed_info_mean))]).T log_ref\",\n \"soln[group_mask] / norm(soln[group_mask]) ordered_opt.append(norm(soln[group_mask])) else: overall[group_mask] = False self.selection_variable =\",\n \"None: randomizer_scale = np.sqrt(mean_diag) * 0.5 * np.std(Y) * np.sqrt(n\",\n \"= cond_cov.dot(self.opt_linear.T).dot(prec) cond_mean = -logdens_linear.dot(self.observed_score_state + self.opt_offset) self.cond_mean = cond_mean\",\n \"result.insert(5, 'parameter', parameter) return result def log_reference(self, observed_target, target_cov, target_score_cov,\",\n \"= calc_GammaMinus(gamma, active_dirs) # eigendecomposition #evalues, evectors = eig(GammaMinus +\",\n \"- L.dot(hess.dot(L.T)) observed_info_mean = target_cov.dot(observed_info_natural.dot(target_cov)) Z_scores = final_estimator / np.sqrt(np.diag(observed_info_mean))\",\n \"is None: feasible_point = 1. / scaling def objective(gs): p1\",\n \"= query.opt_linear self.useIP = useIP def summary(self, alternatives=None, parameter=None, level=0.9):\",\n \"labels active_dirs = {} # dictionary: keys are group labels,\",\n \"loglike = rr.glm.gaussian(X, Y, coef=1. / sigma ** 2, quadratic=quadratic)\",\n \"function C: V^T Q^{-1} \\\\\\\\Lambda V active_dirs: \\\"\\\"\\\" scaling =\",\n \"conjugate_arg.T.dot(cond_cov).dot(conjugate_arg) / 2. result = pd.DataFrame({'MLE': final_estimator, 'SE': np.sqrt(np.diag(observed_info_mean)), 'Zvalue':\",\n \"= C U = block_diag(*[ug for ug in sorted_active_dirs.values()]).T self.opt_linear\",\n \"p2 = gs.T.dot(precision).dot(gs) / 2. if useJacobian: p3 = -\",\n \"var_target + observed_target) upper.append(u * var_target + observed_target) return np.asarray(lower),\",\n \"query.C self.active_dirs = query.active_dirs (observed_target, target_cov, target_score_cov, alternatives) = query.selected_targets(dispersion)\",\n \"of barrier and jacobian to hessian p1 = con_linear.T.dot(np.diag(-1. /\",\n \"* self.ntarget pivot = [] for m in range(self.ntarget): family\",\n \"- target_lin.T.dot( prec_opt).dot(target_lin) C = target_cov.dot(_P - target_lin.T.dot(prec_opt).dot(target_off)) conjugate_arg =\",\n \"p1 + p2 current = feasible_point current_value = np.inf for\",\n \"* len(self.active) if dispersion is None: # use Pearson's X^2\",\n \"= - jacobian_grad_hess(gs, C, active_dirs)[2] else: p2 = 0 return\",\n \"1D array_like\\\") # check sorted if np.any(agroups[:-1] > agroups[1:]) <\",\n \"= rr.group_lasso(groups, weights=weights, lagrange=1.) # store groups as a class\",\n \"target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) var_target = 1. / ((self.precs[m])[0,\",\n \"return current_value, current, hess # Jacobian calculations def calc_GammaMinus(gamma, active_dirs):\",\n \"level quantile = ndist.ppf(1 - alpha / 2.) intervals =\",\n \"- _A.dot(eta.T) A = self.linear_part.dot(_A).reshape((-1,)) b = self.offset-self.linear_part.dot(R).dot(self.init_soln) conjugate_arg =\",\n \"is potentially tedious for the user and in future we\",\n \"- pvalues) alpha = 1 - level quantile = ndist.ppf(1\",\n \"pvalues, 'lower_confidence': intervals[:, 0], 'upper_confidence': intervals[:, 1], 'unbiased': unbiased_estimator}) return\",\n \"by C.shape[0]) S = block_diag(*[np.ones((1, ug.size - 1)) for ug\",\n \"array_like of integers that are sorted in increasing order, start\",\n \"= self.logdens_linear linear_part = self.linear_part offset = self.offset if np.asarray(observed_target).shape\",\n \"= -logdens_linear.dot(self.observed_score_state + self.opt_offset) self.cond_mean = cond_mean self.cond_cov = cond_cov\",\n \"# log likelihood : quadratic loss self.loglike = loglike self.nfeature\",\n \"with target # logdens_linear determines how the argument of the\",\n \"like b_scaling (from lasso) solve_args: passed on to solver level:\",\n \"user-specified group scheme and raises an exception if it finds\",\n \"how the mean depends on score, hence the minus sign\",\n \"Confidence level. \\\"\\\"\\\" if parameter is not None: pivots =\",\n \"we might do this for them. \\\"\\\"\\\" # check array_like\",\n \"= 1. / ((self.precs[m])[0, 0]) mean = self.S[m].dot(mean_parameter[m].reshape((1,))) + self.r[m]\",\n \"step=1, nstep=2000, min_its=500, tol=1.e-12): \\\"\\\"\\\" This needs to be updated\",\n \"score, not how the mean depends on score, hence the\",\n \"to 0. level : float Confidence level. \\\"\\\"\\\" if parameter\",\n \"construction of intervals from families follows `selectinf.learning.core` family = self._families[m]\",\n \"target_linear.dot(observed_target) target_lin = - logdens_linear.dot(target_linear) target_off = cond_mean - target_lin.dot(observed_target)\",\n \"passed to solver. \\\"\\\"\\\" self.solve_args = solve_args result, inverse_info =\",\n \"p3 + p4 def barrier_hessian(gs): # contribution of barrier and\",\n \"y = self.loglike.data W = self._W = self.loglike.saturated_loss.hessian(X.dot(beta_bar)) # all\",\n \"eig import pandas as pd import regreg.api as rr from\",\n \"def __init__(self, loglike, groups, weights, ridge_term, randomizer, use_lasso=True, # should\",\n \"'grad')) return initial_soln, initial_subgrad @staticmethod def gaussian(X, Y, groups, weights,\",\n \"def gaussian(X, Y, groups, weights, sigma=1., quadratic=None, ridge_term=0., perturb=None, use_lasso=True,\",\n \"4 * np.sqrt(np.diag(inverse_info)) if useIP == False: ngrid = 1000\",\n \"self.observed_target[m] l, u = family.equal_tailed_interval(observed_target, alpha=1 - level) var_target =\",\n \"mean of optimization variables (model on _setup_implied_gaussian) cond_cov: conditional variance\",\n \"gamma's from fitting con_linear: linear part of affine constraint used\",\n \"= proposal current_value = proposed_value break current = proposal current_value\",\n \"np.sqrt(np.diag(observed_info_mean)), final_estimator + quantile * np.sqrt(np.diag(observed_info_mean))]).T log_ref = val +\",\n \"randomized query. solve_args : dict, optional Arguments passed to solver.\",\n \"rr.glm.gaussian(X, Y, coef=1. / sigma ** 2, quadratic=quadratic) n, p\",\n \"None] * X).T alternatives = ['twosided'] * len(self.active) if dispersion\",\n \"not (np.isnan(proposed_value) or np.isnan(current_value)): break else: raise ValueError('value is NaN:\",\n \"run the fit method since this uses results from that\",\n \"0: raise ValueError(\\\"First group is not 0\\\") # check for\",\n \"parameter=None, level=0.9): \\\"\\\"\\\" Produce p-values and confidence intervals for targets\",\n \"alternatives = ['twosided'] * self.ntarget pivot = [] for m\",\n \"current_value = np.inf for itercount in range(nstep): cur_grad = grad(current)\",\n \"sigma=1., quadratic=None, ridge_term=0., perturb=None, use_lasso=True, # should lasso solver be\",\n \"+ R.dot(self.init_soln) log_jacob = jacobian_grad_hess(gamma_, self.C, self.active_dirs) ref_hat.append(-val - ((conjugate_arg\",\n \"the list Ls = [compute_Lg(g) for g in sorted_active_dirs] L\",\n \"constraint used for barrier function con_offset: offset part of affine\",\n \"self.initial_subgrad) = self._solve_randomized_problem(perturb=perturb, solve_args=solve_args) # initialize variables active_groups = []\",\n \"user and in future we might do this for them.\",\n \"(target_linear.T.dot(self.randomizer_prec).dot(target_linear)) - target_lin.T.dot( prec_opt).dot(target_lin) C = target_cov.dot(_P - target_lin.T.dot(prec_opt).dot(target_off)) conjugate_arg\",\n \"skipped groups if not np.all(np.diff(np.unique(agroups)) == 1): raise ValueError(\\\"Some group\",\n \"alternatives=alternatives) else: pivots = None pvalues = self._approx_pivots(np.zeros_like(self.observed_target), alternatives=alternatives) lower,\",\n \"in sorted(weights.items())]) self.penalty = rr.weighted_l1norm(weights=weights_np, lagrange=1.) else: self.penalty = rr.group_lasso(groups,\",\n \"0 return p1 + p2 current = feasible_point current_value =\",\n \"target_score_cov : ndarray Estimated covariance of target and score of\",\n \"num=ngrid) self.opt_linear = query.opt_linear self.useIP = useIP def summary(self, alternatives=None,\",\n \"else: raise ValueError('alternative should be in [\\\"twosided\\\", \\\"less\\\", \\\"greater\\\"]') return\",\n \"on the score, not how the mean depends on score,\",\n \"u = family.equal_tailed_interval(observed_target, alpha=1 - level) var_target = 1. /\",\n \"* np.sqrt(n / (n - 1.)) randomizer = randomization.isotropic_gaussian((p,), randomizer_scale)\",\n \"keep setting this if norm(soln[group_mask]) > tol * norm(soln): #\",\n \"np.mean((X ** 2).sum(0)) if ridge_term is None: ridge_term = np.std(Y)\",\n \"= self.initial_subgrad self.observed_score_state = -opt_linearNoU.dot(_beta_unpenalized) self.observed_score_state[~overall] += self.loglike.smooth_objective(beta_bar, 'grad')[~overall] active_signs\",\n \"if self._initial_omega is None: self._initial_omega = self.randomizer.sample() quad = rr.identity_quadratic(self.ridge_term,\",\n \"evectors.dot(np.diag(1 / evalues).dot(evectors.T)) GpC_inv = np.linalg.inv(GammaMinus + C) # summing\",\n \"'twosided': pivot.append(2 * min(_cdf, 1 - _cdf)) elif alternatives[m] ==\",\n \"Gamma^minus (as a function of gamma vector, active directions) \\\"\\\"\\\"\",\n \"query.linear_part self.offset = query.offset self.logdens_linear = query.logdens_linear self.cond_mean = query.cond_mean\",\n \"proposal is feasible count = 0 while True: count +=\",\n \"2.))).dot(con_linear) if useJacobian: p2 = - jacobian_grad_hess(gs, C, active_dirs)[2] else:\",\n \"..algorithms.barrier_affine import solve_barrier_affine_py as solver from ..distributions.discrete_family import discrete_family class\",\n \"ordered by group labels ordered_vars = [] # indices \\\"ordered\\\"\",\n \"query.observed_score_state + query.opt_offset self.ntarget = ntarget = target_cov.shape[0] _scale =\",\n \"np.std(Y) * np.sqrt(n / (n - 1.)) randomizer = randomization.isotropic_gaussian((p,),\",\n \"value of optimization variables cond_mean: conditional mean of optimization variables\",\n \"- _cdf)) elif alternatives[m] == 'greater': pivot.append(1 - _cdf) elif\",\n \"p3 = 0 p4 = log(1. + 1. / ((con_offset\",\n \"randomized version of group lasso (self.initial_soln, self.initial_subgrad) = self._solve_randomized_problem(perturb=perturb, solve_args=solve_args)\",\n \"((scaling + con_offset - con_linear.dot(gs)) ** 2.) + 1. /\",\n \"= [] # selected groups with no penalty overall =\",\n \"0: return np.sign(soln), soln # otherwise continue as before self.observed_opt_state\",\n \"variable since the non-group lasso doesn't self.groups = groups self._initial_omega\",\n \"score_offset = self.observed_score_state + self.opt_offset # target_lin determines how the\",\n \"used for barrier function C: V^T Q^{-1} \\\\\\\\Lambda V active_dirs:\",\n \"= active def compute_Vg(ug): pg = ug.size # figure out\",\n \"S[m] = _S r[m] = _r precs[m] = _prec self.precs\",\n \"unpack the list Ls = [compute_Lg(g) for g in sorted_active_dirs]\",\n \"p3 = - jacobian_grad_hess(gs, C, active_dirs)[1] else: p3 = 0\",\n \"that the user-specific groups are ok There are a number\",\n \"* implied_prec R = np.identity(num_opt) - _A.dot(eta.T) A = self.linear_part.dot(_A).reshape((-1,))\",\n \"# contribution of barrier and jacobian to hessian p1 =\",\n \"_cdf) elif alternatives[m] == 'less': pivot.append(_cdf) else: raise ValueError('alternative should\",\n \"penalty (from regreg) # use regular lasso penalty if all\",\n \"+ 1.5 * _scale[j], num=ngrid) self.opt_linear = query.opt_linear self.useIP =\",\n \"self.target_score_cov.shape[1] for m in range(self.ntarget): observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni =\",\n \"0): # when all groups are size one, C will\",\n \"group_lasso Note: this masks the selective_MLE inherited from query because\",\n \"there is a group 2 and a group 4, there\",\n \"self._approx_intervals(level=level) result = pd.DataFrame({'target': self.observed_target, 'pvalue': pvalues, 'lower_confidence': lower, 'upper_confidence':\",\n \"updated to actually use the Jacobian information (in self.C) arguments\",\n \"-np.eye(self.observed_opt_state.shape[0]) self.offset = np.zeros(self.observed_opt_state.shape[0]) return active_signs, soln def _solve_randomized_problem(self, perturb=None,\",\n \"raise ValueError(\\\"Groups are not sorted\\\") # check integers if not\",\n \"ndarray Estimated covariance of target and score of randomized query.\",\n \"scaling = np.sqrt(np.diag(con_linear.dot(precision).dot(con_linear.T))) if feasible_point is None: feasible_point = 1.\",\n \"= active_dirs self.opt_offset = opt_offset self.ordered_vars = ordered_vars self.linear_part =\",\n \"self.observed_score_state + self.opt_offset # target_lin determines how the conditional mean\",\n \"'grad')[~overall] active_signs = np.sign(self.initial_soln) active = np.flatnonzero(active_signs) self.active = active\",\n \"unbiased_estimator}) return result, observed_info_mean, log_ref def selected_targets(self, dispersion=None, solve_args={'tol': 1.e-12,\",\n \"calc_GammaMinus(gamma, active_dirs) # eigendecomposition #evalues, evectors = eig(GammaMinus + C)\",\n \"= pd.DataFrame({'MLE': final_estimator, 'SE': np.sqrt(np.diag(observed_info_mean)), 'Zvalue': Z_scores, 'pvalue': pvalues, 'lower_confidence':\",\n \"overall = np.ones(self.nfeature, np.bool) # mask of active features ordered_groups\",\n \"in enumerate(ordered_vars): opt_linearNoU[var, i] += self.ridge_term opt_offset = self.initial_subgrad self.observed_score_state\",\n \"'unbiased': unbiased_estimator}) return result, observed_info_mean, log_ref def selected_targets(self, dispersion=None, solve_args={'tol':\",\n \"np.linalg.inv(query.cond_cov) self.cond_cov = query.cond_cov self.C = query.C self.active_dirs = query.active_dirs\",\n \"init_soln: (opt_state) initial (observed) value of optimization variables cond_mean: conditional\",\n \"S = {} r = {} p = self.target_score_cov.shape[1] for\",\n \"True: count += 1 proposal = current - step *\",\n \"use python or C solver JacobianPieces: (use self.C defined in\",\n \"p2 = - jacobian_grad_hess(gs, C, active_dirs)[2] else: p2 = 0\",\n \"\\\"something\\\" comes from implied Gaussian # cond_mean is \\\"something\\\" times\",\n \"in range(self.ntarget): observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) prec_target\",\n \"= X.shape mean_diag = np.mean((X ** 2).sum(0)) if ridge_term is\",\n \"= ((y - self.loglike.saturated_loss.mean_function( XE.dot(observed_target))) ** 2 / self._W).sum() /\",\n \"no skipped groups if not np.all(np.diff(np.unique(agroups)) == 1): raise ValueError(\\\"Some\",\n \"this for them. \\\"\\\"\\\" # check array_like agroups = np.array(groups)\",\n \"p2 + p3 + p4 def barrier_hessian(gs): # contribution of\",\n \"for ug in sorted_active_dirs.values()] V = block_diag(*Vs) # unpack the\",\n \"intervals[:, 0], 'upper_confidence': intervals[:, 1], 'unbiased': unbiased_estimator}) return result, observed_info_mean,\",\n \"Parameters ---------- query : `gaussian_query` A Gaussian query which has\",\n \"b = self.offset-self.linear_part.dot(R).dot(self.init_soln) conjugate_arg = implied_mean * implied_prec val, soln,\",\n \"= [compute_Lg(g) for g in sorted_active_dirs] L = block_diag(*Ls) #\",\n \"= np.inf for itercount in range(nstep): cur_grad = grad(current) #\",\n \"gp in to_diag for i in gp]) def jacobian_grad_hess(gamma, C,\",\n \"evectors = eig(GammaMinus + C) # log Jacobian #J =\",\n \"+ (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( self.prec_opt).dot(target_lin) _P = target_linear.T.dot(target_offset)\",\n \"sorted by label ordered_opt = [] # gamma's ordered by\",\n \"used when applicable - defaults to True randomizer_scale=None): loglike =\",\n \"active_signs, soln def _solve_randomized_problem(self, perturb=None, solve_args={'tol': 1.e-15, 'min_its': 100}): #\",\n \"[(), (0,)]: raise ValueError('no target specified') prec_target = np.linalg.inv(target_cov) target_lin\",\n \"store groups as a class variable since the non-group lasso\",\n \"= ridge_term # group lasso penalty (from regreg) # use\",\n \"p4 def grad(gs): p1 = -conjugate_arg + precision.dot(gs) p2 =\",\n \"hessian hess_J = -S.dot(np.multiply(GpC_inv, GpC_inv.T).dot(S.T)) return J, grad_J, hess_J def\",\n \"A.reshape((A.shape[0],1)), b, **self.solve_args) gamma_ = _A.dot(soln) + R.dot(self.init_soln) log_jacob =\",\n \"return np.sign(soln), soln # otherwise continue as before self.observed_opt_state =\",\n \"(np.diag(self.target_cov)[m]).reshape((1, 1)) target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) var_target = 1.\",\n \"= target_linear.T.dot(target_offset) * self.randomizer_prec _r = (1. / _prec).dot(target_lin.T.dot(self.prec_opt).dot(target_off) -\",\n \"0 if not np.amin(agroups) == 0: raise ValueError(\\\"First group is\",\n \"** 2) * implied_cov)/ 2. + log_jacob[0]) return np.asarray(ref_hat) def\",\n \"g'th group if pg > 1: Z = np.column_stack((ug, np.eye(pg,\",\n \"ValueError('not finding a feasible point') # make sure proposal is\",\n \"(self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p))\",\n \": [str], optional Sequence of strings describing the alternatives, should\",\n \"follows `selectinf.learning.core` family = self._families[m] observed_target = self.observed_target[m] l, u\",\n \"(e.g., if there is a group 2 and a group\",\n \"- self.observed_target[m]) ** 2 / var_target) logW -= logW.max() self._families.append(discrete_family(grid,\",\n \"# stop if relative decrease is small if np.fabs(current_value -\",\n \"= prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( prec_opt).dot( target_lin)\",\n \"g is group label group_mask = self.groups == g soln\",\n \"ordered_vars self.linear_part = -np.eye(self.observed_opt_state.shape[0]) self.offset = np.zeros(self.observed_opt_state.shape[0]) return active_signs, soln\",\n \"used where applicable - defaults to True perturb=None): _check_groups(groups) #\",\n \"self.active_dirs = active_dirs self.opt_offset = opt_offset self.ordered_vars = ordered_vars self.linear_part\",\n \"gradient (gamma.size vector) and hessian (gamma.size square matrix) \\\"\\\"\\\" if\",\n \"class approximate_grid_inference(object): def __init__(self, query, dispersion, solve_args={'tol': 1.e-12}, useIP=True): \\\"\\\"\\\"\",\n \"p-values and confidence intervals for targets of model including selected\",\n \"= current - step * cur_grad proposed_value = objective(proposal) if\",\n \"point') # make sure proposal is a descent count =\",\n \"intervals[:, 1], 'unbiased': unbiased_estimator}) return result, observed_info_mean, log_ref def selected_targets(self,\",\n \"like A_scaling (from lasso) offset: like b_scaling (from lasso) solve_args:\",\n \"groups are specified. Specifically, we assume that `groups` is a\",\n \"finding a feasible point') # make sure proposal is a\",\n \"_P) _S = np.linalg.inv(_prec).dot(prec_target) S[m] = _S r[m] = _r\",\n \"pivot def _approx_intervals(self, level=0.9): if not hasattr(self, \\\"_families\\\"): self._construct_families() lower,\",\n \"# vary with target # logdens_linear determines how the argument\",\n \"log_jacob[0]) return np.asarray(ref_hat) def _construct_families(self): self._construct_density() self._families = [] for\",\n \"40: raise ValueError('not finding a feasible point') # make sure\",\n \"= restricted_estimator(self.loglike, self.ordered_vars, solve_args=solve_args) _score_linear = -XE.T.dot(self._W[:, None] * X).T\",\n \"sorted_active_dirs = collections.OrderedDict(sorted(active_dirs.items())) Vs = [compute_Vg(ug) for ug in sorted_active_dirs.values()]\",\n \"return np.asarray(lower), np.asarray(upper) ### Private method def _construct_density(self): precs =\",\n \"= self.linear_part offset = self.offset if np.asarray(observed_target).shape in [(), (0,)]:\",\n \"return active_signs, soln def _solve_randomized_problem(self, perturb=None, solve_args={'tol': 1.e-15, 'min_its': 100}):\",\n \"feature groups is potentially tedious for the user and in\",\n \"solve_barrier_affine_jacobian_py(conjugate_arg, prec_opt, init_soln, linear_part, offset, self.C, self.active_dirs, useJacobian, **solve_args) final_estimator\",\n \"== False: logW = (log_ref - 0.5 * (self.stat_grid[m] -\",\n \"A Gaussian query which has information to describe implied Gaussian.\",\n \"self.offset = query.offset self.logdens_linear = query.logdens_linear self.cond_mean = query.cond_mean self.prec_opt\",\n \"target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) prec_target = 1. / target_cov_uni target_score_cov_uni\",\n \"0 p4 = log(1. + 1. / ((con_offset - con_linear.dot(gs))\",\n \"on a grid. \\\"\\\"\\\" if np.asarray(observed_target).shape in [(), (0,)]: raise\",\n \"[\\\"twosided\\\", \\\"less\\\", \\\"greater\\\"]') return pivot def _approx_intervals(self, level=0.9): if not\",\n \"families follows `selectinf.learning.core` family = self._families[m] observed_target = self.observed_target[m] l,\",\n \"p2 = -con_linear.T.dot(1. / (scaling + con_offset - con_linear.dot(gs))) if\",\n \"comes from implied Gaussian # cond_mean is \\\"something\\\" times D\",\n \"= ntarget = target_cov.shape[0] _scale = 4 * np.sqrt(np.diag(inverse_info)) if\",\n \"if all groups are size 1, set up lasso penalty\",\n \"50}, perturb=None): # solve the randomized version of group lasso\",\n \"= np.column_stack((ug, np.eye(pg, pg - 1))) Q, _ = qr(Z)\",\n \"group_lasso. Also, assumes you have already run the fit method\",\n \"def summary(self, alternatives=None, parameter=None, level=0.9): \\\"\\\"\\\" Produce p-values and confidence\",\n \"2 hess = inv(precision + barrier_hessian(current)) return current_value, current, hess\",\n \"S.dot(GpC_inv.diagonal()) # hessian hess_J = -S.dot(np.multiply(GpC_inv, GpC_inv.T).dot(S.T)) return J, grad_J,\",\n \"- level) var_target = 1. / ((self.precs[m])[0, 0]) lower.append(l *\",\n \"cond_mean is \\\"something\\\" times D # Gamma is target_score_cov.T.dot(prec_target) num_opt\",\n \"check for no skipped groups if not np.all(np.diff(np.unique(agroups)) == 1):\",\n \"ug) in zip(gamma, active_dirs.values())] return block_diag(*[i for gp in to_diag\",\n \"function checks the user-specified group scheme and raises an exception\",\n \"to actually use the Jacobian information (in self.C) arguments conjugate_arg:\",\n \"conditional mean of optimization variables (model on _setup_implied_gaussian) cond_cov: conditional\",\n \"of target and score of randomized query. solve_args : dict,\",\n \"fill_value='extrapolate') grid = np.linspace(self.stat_grid[m].min(), self.stat_grid[m].max(), 1000) logW = (approx_fn(grid) -\",\n \"= interp1d(self.stat_grid[m], log_ref, kind='quadratic', bounds_error=False, fill_value='extrapolate') grid = np.linspace(self.stat_grid[m].min(), self.stat_grid[m].max(),\",\n \"order, start at 0, and have no gaps (e.g., if\",\n \"useJacobian=True, dispersion=None): \\\"\\\"\\\"Do selective_MLE for group_lasso Note: this masks the\",\n \"precision, feasible_point, con_linear, con_offset, C, active_dirs, useJacobian=True, step=1, nstep=2000, min_its=500,\",\n \"and itercount >= min_its: current = proposal current_value = proposed_value\",\n \"objective(gs): p1 = -gs.T.dot(conjugate_arg) p2 = gs.T.dot(precision).dot(gs) / 2. if\",\n \"**solve_args) initial_subgrad = -(self.loglike.smooth_objective(initial_soln, 'grad') + quad.objective(initial_soln, 'grad')) return initial_soln,\",\n \"collections import numpy as np from numpy import log from\",\n \"target_lin is \\\"something\\\" times Gamma, # where \\\"something\\\" comes from\",\n \"dispersion, solve_args={'tol': 1.e-12}, useIP=True): \\\"\\\"\\\" Produce p-values and confidence intervals\",\n \"norm as ndist from scipy.interpolate import interp1d import collections import\",\n \"prec_opt, init_soln, linear_part, offset, self.C, self.active_dirs, useJacobian, **solve_args) final_estimator =\",\n \"variables cond_mean: conditional mean of optimization variables (model on _setup_implied_gaussian)\",\n \"target_linear.dot(observed_target_uni)).reshape( (target_linear.shape[0],)) target_lin = -self.logdens_linear.dot(target_linear) target_off = (self.cond_mean - target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],))\",\n \"solve_args: passed on to solver level: level of confidence intervals\",\n \"__future__ import print_function from scipy.linalg import block_diag from scipy.stats import\",\n \"proposal = current - step * cur_grad proposed_value = objective(proposal)\",\n \"(from lasso) offset: like b_scaling (from lasso) solve_args: passed on\",\n \"= X.shape XE = self.XE Q = self.Q observed_target =\",\n \": ndarray Estimated covaraince of target. target_score_cov : ndarray Estimated\",\n \"step * cur_grad if np.all(con_offset - con_linear.dot(proposal) > 0): break\",\n \"from selected_targets init_soln: (opt_state) initial (observed) value of optimization variables\",\n \"else: _P = target_linear.T.dot(self.randomizer_prec).dot(target_offset) _prec = prec_target + (target_linear.T.dot(self.randomizer_prec).dot(target_linear)) -\",\n \"val + conjugate_arg.T.dot(cond_cov).dot(conjugate_arg) / 2. result = pd.DataFrame({'MLE': final_estimator, 'SE':\",\n \"if parameter is not None: pivots = self._approx_pivots(parameter, alternatives=alternatives) else:\",\n \"kind='quadratic', bounds_error=False, fill_value='extrapolate') grid = np.linspace(self.stat_grid[m].min(), self.stat_grid[m].max(), 1000) logW =\",\n \"selected_targets target_cov_score: from selected_targets init_soln: (opt_state) initial (observed) value of\",\n \"not None: self._initial_omega = perturb if self._initial_omega is None: self._initial_omega\",\n \"from that method. Parameters ---------- observed_target: from selected_targets target_cov: from\",\n \"C, active_dirs)[0] else: p3 = 0 p4 = log(1. +\",\n \"# check for no skipped groups if not np.all(np.diff(np.unique(agroups)) ==\",\n \"= rr.identity_quadratic(self.ridge_term, 0, -self._initial_omega, 0) problem = rr.simple_problem(self.loglike, self.penalty) #\",\n \"= _beta_unpenalized # refit OLS beta with zeros self._beta_full =\",\n \"- 1))) Q, _ = qr(Z) Vg = Q[:, 1:]\",\n \"self.offset if np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no target specified')\",\n \"if len(self.selection_variable['active_groups']) == 0: return np.sign(soln), soln # otherwise continue\",\n \"problems. Sorting feature groups is potentially tedious for the user\",\n \"Note: this masks the selective_MLE inherited from query because that\",\n \"implied_prec val, soln, _ = solver(np.asarray([conjugate_arg]), np.reshape(implied_prec, (1,1)), eta.T.dot(self.init_soln), A.reshape((A.shape[0],1)),\",\n \"+ self.r[m] _cdf = family.cdf((mean[0] - self.observed_target[m]) / var_target, x=self.observed_target[m])\",\n \"self.loglike = loglike self.nfeature = self.loglike.shape[0] # ridge parameter self.ridge_term\",\n \"self.observed_target[m]) / var_target, x=self.observed_target[m]) print(\\\"variable completed \\\", m) if alternatives[m]\",\n \"** 2 / var_target) logW -= logW.max() self._families.append(discrete_family(grid, np.exp(logW))) def\",\n \"covaraince of target. target_score_cov : ndarray Estimated covariance of target\",\n \"useIP def summary(self, alternatives=None, parameter=None, level=0.9): \\\"\\\"\\\" Produce p-values and\",\n \"if norm(soln[group_mask]) > tol * norm(soln): # is group g\",\n \"import norm, qr, inv, eig import pandas as pd import\",\n \"target_cov self.init_soln = query.observed_opt_state self.randomizer_prec = query.randomizer_prec self.score_offset = query.observed_score_state\",\n \"var_target = 1. / ((self.precs[m])[0, 0]) log_ref = self.log_reference(observed_target_uni, target_cov_uni,\",\n \"** 2 / var_target) logW -= logW.max() self._families.append(discrete_family(self.stat_grid[m], np.exp(logW))) else:\",\n \"# is group g appreciably nonzero ordered_groups.append(g) # variables in\",\n \"group_lasso(loglike, groups, weights, ridge_term, randomizer, use_lasso, perturb) def _setup_implied_gaussian(self): _,\",\n \"number of assumptions that group_lasso makes about how groups are\",\n \"= problem.solve(quad, **solve_args) initial_subgrad = -(self.loglike.smooth_objective(initial_soln, 'grad') + quad.objective(initial_soln, 'grad'))\",\n \"are not a 1D array_like\\\") # check sorted if np.any(agroups[:-1]\",\n \": ndarray Observed estimate of target. target_cov : ndarray Estimated\",\n \"= {} S = {} r = {} p =\",\n \"active_dirs, 'active_groups': active_groups} # kind of redundant with keys of\",\n \"self.cond_precision score_offset = self.observed_score_state + self.opt_offset # target_lin determines how\",\n \"Jacobian #J = log(evalues).sum() J = np.log(np.linalg.det(GammaMinus + C)) #\",\n \"from scipy.interpolate import interp1d import collections import numpy as np\",\n \"if not np.all(np.diff(np.unique(agroups)) == 1): raise ValueError(\\\"Some group is skipped\\\")\",\n \"adapted for the group_lasso. Also, assumes you have already run\",\n \"step *= 2 hess = inv(precision + barrier_hessian(current)) return current_value,\",\n \"# check array_like agroups = np.array(groups) # check dimension if\",\n \"1.5 * _scale[j], observed_target[j] + 1.5 * _scale[j], num=ngrid) else:\",\n \"# selected groups with no penalty overall = np.ones(self.nfeature, np.bool)\",\n \"current_value)) # stop if relative decrease is small if np.fabs(current_value\",\n \"- con_linear.dot(gs)) ** 2.) + 1. / ((con_offset - con_linear.dot(gs))\",\n \"return (observed_target, cov_target, crosscov_target_score, alternatives) class approximate_grid_inference(object): def __init__(self, query,\",\n \"interp1d import collections import numpy as np from numpy import\",\n \"* np.sqrt(np.diag(observed_info_mean))]).T log_ref = val + conjugate_arg.T.dot(cond_cov).dot(conjugate_arg) / 2. result\",\n \"= np.zeros((ntarget, ngrid)) for j in range(ntarget): self.stat_grid[j, :] =\",\n \"on E overall, solve_args=solve_args) beta_bar = np.zeros(self.nfeature) beta_bar[overall] = _beta_unpenalized\",\n \"self._ordered_groups = ordered_groups # exception if no groups are selected\",\n \"if feasible_point is None: feasible_point = 1. / scaling def\",\n \"self.linear_part.shape[0] cond_mean_grid = (target_lin.dot(np.atleast_1d(grid[k] - observed_target)) + self.cond_mean) #direction for\",\n \"Vs = [compute_Vg(ug) for ug in sorted_active_dirs.values()] V = block_diag(*Vs)\",\n \"(as a function of gamma vector, active directions) \\\"\\\"\\\" to_diag\",\n \"= np.identity(num_opt) - _A.dot(eta.T) A = self.linear_part.dot(_A).reshape((-1,)) b = self.offset-self.linear_part.dot(R).dot(self.init_soln)\",\n \"(n - 1.)) randomizer = randomization.isotropic_gaussian((p,), randomizer_scale) return group_lasso(loglike, groups,\",\n \"+ p2 + p3 + p4 def barrier_hessian(gs): # contribution\",\n \"upper.append(u * var_target + observed_target) return np.asarray(lower), np.asarray(upper) ### Private\",\n \"return Lg sorted_active_dirs = collections.OrderedDict(sorted(active_dirs.items())) Vs = [compute_Vg(ug) for ug\",\n \"XE = X[:, ordered_vars] # changed to ordered_vars Q =\",\n \"min_its: current = proposal current_value = proposed_value break current =\",\n \"= 1. / target_cov_uni target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) target_linear\",\n \"TypeError(\\\"Groups are not integers\\\") # check starts with 0 if\",\n \"if not hasattr(self, \\\"_families\\\"): self._construct_families() lower, upper = [], []\",\n \"ValueError('value is NaN: %f, %f' % (proposed_value, current_value)) # stop\",\n \"randomizer_scale is None: randomizer_scale = np.sqrt(mean_diag) * 0.5 * np.std(Y)\",\n \"ndarray Observed estimate of target. target_cov : ndarray Estimated covaraince\",\n \"applicable - defaults to True randomizer_scale=None): loglike = rr.glm.gaussian(X, Y,\",\n \"\\\"\\\"\\\" # check array_like agroups = np.array(groups) # check dimension\",\n \"- 1) for (g, ug) in zip(gamma, active_dirs.values())] return block_diag(*[i\",\n \"prec else: cond_precision = self.opt_linear.T.dot(prec.dot(self.opt_linear)) cond_cov = inv(cond_precision) logdens_linear =\",\n \"inherited from query because that is not adapted for the\",\n \"ridge_term, randomizer, use_lasso, perturb) def _setup_implied_gaussian(self): _, prec = self.randomizer.cov_prec\",\n \"self.observed_target, 'pvalue': pvalues, 'lower_confidence': lower, 'upper_confidence': upper}) if not np.all(parameter\",\n \"if itercount % 4 == 0: step *= 2 hess\",\n \"= (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) target_score_cov_uni = self.target_score_cov[m, :].reshape((1,\",\n \"= prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( self.prec_opt).dot(target_lin) _P\",\n \"+ Gamma theta.hat, # target_lin is \\\"something\\\" times Gamma, #\",\n \"else: approx_fn = interp1d(self.stat_grid[m], log_ref, kind='quadratic', bounds_error=False, fill_value='extrapolate') grid =\",\n \"self._construct_families() lower, upper = [], [] for m in range(self.ntarget):\",\n \"including selected features Parameters ---------- query : `gaussian_query` A Gaussian\",\n \"regular lasso penalty if all groups are size 1 if\",\n \"= QI self.C = C U = block_diag(*[ug for ug\",\n \"pg - 1))) Q, _ = qr(Z) Vg = Q[:,\",\n \"> tol * norm(soln): # is group g appreciably nonzero\",\n \"current - step * cur_grad if np.all(con_offset - con_linear.dot(proposal) >\",\n \"solve_args=solve_args) beta_bar = np.zeros(self.nfeature) beta_bar[overall] = _beta_unpenalized # refit OLS\",\n \"= [compute_Vg(ug) for ug in sorted_active_dirs.values()] V = block_diag(*Vs) #\",\n \"= self._W = self.loglike.saturated_loss.hessian(X.dot(beta_bar)) # all 1's for LS opt_linearNoU\",\n \"current = proposal current_value = proposed_value if itercount % 4\",\n \"with zeros self._beta_full = beta_bar X, y = self.loglike.data W\",\n \"final_estimator = target_cov.dot(_prec).dot(observed_target) \\\\ + target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean - soln))) + C\",\n \"raise ValueError('alternative should be in [\\\"twosided\\\", \\\"less\\\", \\\"greater\\\"]') return pivot\",\n \"2 / self._W).sum() / (n - XE.shape[1]) cov_target = self.QI\",\n \"# hessian hess_J = -S.dot(np.multiply(GpC_inv, GpC_inv.T).dot(S.T)) return J, grad_J, hess_J\",\n \"ValueError(\\\"First group is not 0\\\") # check for no skipped\",\n \"orthogonal complement is empty return Vg def compute_Lg(g): pg =\",\n \"hess_J = -S.dot(np.multiply(GpC_inv, GpC_inv.T).dot(S.T)) return J, grad_J, hess_J def _check_groups(groups):\",\n \"sure proposal is feasible count = 0 while True: count\",\n \"sure groups looks sensible # log likelihood : quadratic loss\",\n \"version of group lasso (self.initial_soln, self.initial_subgrad) = self._solve_randomized_problem(perturb=perturb, solve_args=solve_args) #\",\n \"sigma ** 2, quadratic=quadratic) n, p = X.shape mean_diag =\",\n \"target_score_cov self.target_cov = target_cov self.init_soln = query.observed_opt_state self.randomizer_prec = query.randomizer_prec\",\n \"should be values of ['twosided', 'less', 'greater'] parameter : np.array\",\n \"precision: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} feasible_point: gamma's from fitting con_linear: linear part of\",\n \"p3 = - jacobian_grad_hess(gs, C, active_dirs)[0] else: p3 = 0\",\n \"'Zvalue': Z_scores, 'pvalue': pvalues, 'lower_confidence': intervals[:, 0], 'upper_confidence': intervals[:, 1],\",\n \"# check starts with 0 if not np.amin(agroups) == 0:\",\n \"Estimated covaraince of target. target_score_cov : ndarray Estimated covariance of\",\n \"linear_part: like A_scaling (from lasso) offset: like b_scaling (from lasso)\",\n \"estimate of target. target_cov : ndarray Estimated covaraince of target.\",\n \"C will be an empty array return 0, 0, 0\",\n \"features Parameters ---------- alternatives : [str], optional Sequence of strings\",\n \"np.bool) # mask of active features ordered_groups = [] #\",\n \"Vg def compute_Lg(g): pg = active_dirs[g].size Lg = self.penalty.weights[g] *\",\n \"- jacobian_grad_hess(gs, C, active_dirs)[2] else: p2 = 0 return p1\",\n \"no gaps (e.g., if there is a group 2 and\",\n \"all groups are size 1, set up lasso penalty and\",\n \"parameter -- defaults to 0. level : float Confidence level.\",\n \"np.asscalar(eta.T.dot(self.cond_cov).dot(eta)) implied_prec = 1./implied_cov _A = self.cond_cov.dot(eta) * implied_prec R\",\n \"== 'less': pivot.append(_cdf) else: raise ValueError('alternative should be in [\\\"twosided\\\",\",\n \"observed_target) upper.append(u * var_target + observed_target) return np.asarray(lower), np.asarray(upper) ###\",\n \"not None: pivots = self._approx_pivots(parameter, alternatives=alternatives) else: pivots = None\",\n \"a feasible point') # make sure proposal is a descent\",\n \"self.opt_offset = opt_offset self.ordered_vars = ordered_vars self.linear_part = -np.eye(self.observed_opt_state.shape[0]) self.offset\",\n \"solver JacobianPieces: (use self.C defined in fitting) \\\"\\\"\\\" self._setup_implied_gaussian() #\",\n \"len(self.active) if dispersion is None: # use Pearson's X^2 dispersion\",\n \"return 0, 0, 0 else: GammaMinus = calc_GammaMinus(gamma, active_dirs) #\",\n \"C) # summing matrix (gamma.size by C.shape[0]) S = block_diag(*[np.ones((1,\",\n \"prec cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T) * prec else:\",\n \"---------- alternatives : [str], optional Sequence of strings describing the\",\n \"= query.observed_opt_state self.randomizer_prec = query.randomizer_prec self.score_offset = query.observed_score_state + query.opt_offset\",\n \"grid = np.linspace(self.stat_grid[m].min(), self.stat_grid[m].max(), 1000) logW = (approx_fn(grid) - 0.5\",\n \"m in range(self.ntarget): observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1))\",\n \"+ conjugate_arg.T.dot(cond_cov).dot(conjugate_arg) / 2. result = pd.DataFrame({'MLE': final_estimator, 'SE': np.sqrt(np.diag(observed_info_mean)),\",\n \"= target_score_cov_uni.T.dot(prec_target) target_offset = (self.score_offset - target_linear.dot(observed_target_uni)).reshape( (target_linear.shape[0],)) target_lin =\",\n \"self._setup_implied_gaussian() # Calculate useful quantities (observed_target, target_cov, target_score_cov, alternatives) =\",\n \"active_groups.append(g) active_dirs[g] = soln[group_mask] / norm(soln[group_mask]) ordered_opt.append(norm(soln[group_mask])) else: overall[group_mask] =\",\n \"Specifically, we assume that `groups` is a 1-d array_like of\",\n \"pd import regreg.api as rr from .randomization import randomization from\",\n \"of optimization variables (model on _setup_implied_gaussian) logdens_linear: (model on _setup_implied_gaussian)\",\n \"GammaMinus = calc_GammaMinus(gamma, active_dirs) # eigendecomposition #evalues, evectors = eig(GammaMinus\",\n \"implied_prec R = np.identity(num_opt) - _A.dot(eta.T) A = self.linear_part.dot(_A).reshape((-1,)) b\",\n \"self.C defined in fitting) \\\"\\\"\\\" self._setup_implied_gaussian() # Calculate useful quantities\",\n \"self.useIP = useIP def summary(self, alternatives=None, parameter=None, level=0.9): \\\"\\\"\\\" Produce\",\n \"logdens_linear = cond_cov.dot(self.opt_linear.T).dot(prec) cond_mean = -logdens_linear.dot(self.observed_score_state + self.opt_offset) self.cond_mean =\",\n \"= score_offset - target_linear.dot(observed_target) target_lin = - logdens_linear.dot(target_linear) target_off =\",\n \"(from lasso) solve_args: passed on to solver level: level of\",\n \"= np.hstack(ordered_opt) # gammas as array _beta_unpenalized = restricted_estimator(self.loglike, #\",\n \"group labels sorted by label ordered_opt = [] # gamma's\",\n \"query.cond_cov self.C = query.C self.active_dirs = query.active_dirs (observed_target, target_cov, target_score_cov,\",\n \"array_like agroups = np.array(groups) # check dimension if len(agroups.shape) !=\",\n \"break step *= 0.5 if count >= 40: raise ValueError('not\",\n \"* np.minimum(pvalues, 1 - pvalues) alpha = 1 - level\",\n \"#evalues, evectors = eig(GammaMinus + C) # log Jacobian #J\",\n \"solver from ..distributions.discrete_family import discrete_family class group_lasso(object): def __init__(self, loglike,\",\n \"non-group lasso doesn't self.groups = groups self._initial_omega = perturb #\",\n \"this uses results from that method. Parameters ---------- observed_target: from\",\n \"tol=1.e-12): \\\"\\\"\\\" This needs to be updated to actually use\",\n \">= 40: raise ValueError('not finding a feasible point') # make\",\n \"useIP=True): \\\"\\\"\\\" Produce p-values and confidence intervals for targets of\",\n \"reference density on a grid. \\\"\\\"\\\" if np.asarray(observed_target).shape in [(),\",\n \"model including selected features Parameters ---------- query : `gaussian_query` A\",\n \"mean_parameter, alternatives=None): if not hasattr(self, \\\"_families\\\"): self._construct_families() if alternatives is\",\n \"is not None: self._initial_omega = perturb if self._initial_omega is None:\",\n \"intervals for targets of model including selected features Parameters ----------\",\n \"dispersion crosscov_target_score = _score_linear.dot(self.QI).T * dispersion return (observed_target, cov_target, crosscov_target_score,\",\n \"2. + log_jacob[0]) return np.asarray(ref_hat) def _construct_families(self): self._construct_density() self._families =\",\n \"lasso solver be used where applicable - defaults to True\",\n \"Calculate useful quantities (observed_target, target_cov, target_score_cov, alternatives) = self.selected_targets(dispersion) init_soln\",\n \"False: ngrid = 1000 self.stat_grid = np.zeros((ntarget, ngrid)) for j\",\n \"= family.cdf((mean[0] - self.observed_target[m]) / var_target, x=self.observed_target[m]) print(\\\"variable completed \\\",\",\n \"integers if not np.issubdtype(agroups.dtype, np.integer): raise TypeError(\\\"Groups are not integers\\\")\",\n \"+ con_offset - con_linear.dot(gs))) if useJacobian: p3 = - jacobian_grad_hess(gs,\",\n \"implied_cov = np.asscalar(eta.T.dot(self.cond_cov).dot(eta)) implied_prec = 1./implied_cov _A = self.cond_cov.dot(eta) *\",\n \"raise ValueError(\\\"First group is not 0\\\") # check for no\",\n \"as ndist from scipy.interpolate import interp1d import collections import numpy\",\n \"== np.unique(groups).size: # need to provide weights an an np.array\",\n \"groups with no penalty overall = np.ones(self.nfeature, np.bool) # mask\",\n \"eta.T.dot(self.init_soln), A.reshape((A.shape[0],1)), b, **self.solve_args) gamma_ = _A.dot(soln) + R.dot(self.init_soln) log_jacob\",\n \"# check integers if not np.issubdtype(agroups.dtype, np.integer): raise TypeError(\\\"Groups are\",\n \"_setup_implied_gaussian(self): _, prec = self.randomizer.cov_prec if np.asarray(prec).shape in [(), (0,)]:\",\n \"self.r[m] _cdf = family.cdf((mean[0] - self.observed_target[m]) / var_target, x=self.observed_target[m]) print(\\\"variable\",\n \"# gaussian randomization self.randomizer = randomizer def fit(self, solve_args={'tol': 1.e-12,\",\n \"* implied_prec val, soln, _ = solver(np.asarray([conjugate_arg]), np.reshape(implied_prec, (1,1)), eta.T.dot(self.init_soln),\",\n \"(self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) prec_target = 1. / target_cov_uni\",\n \"- _P) _S = np.linalg.inv(_prec).dot(prec_target) S[m] = _S r[m] =\",\n \"# make sure proposal is feasible count = 0 while\",\n \"decomposing o eta = -self.prec_opt.dot(self.logdens_linear.dot(target_score_cov.T)) implied_mean = np.asscalar(eta.T.dot(cond_mean_grid)) implied_cov =\",\n \"\\\"\\\"\\\"Calculate Gamma^minus (as a function of gamma vector, active directions)\",\n \"precs self.S = S self.r = r def solve_barrier_affine_jacobian_py(conjugate_arg, precision,\",\n \"hess = solve_barrier_affine_jacobian_py(conjugate_arg, prec_opt, init_soln, linear_part, offset, self.C, self.active_dirs, useJacobian,\",\n \"np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no target specified') prec_target =\",\n \"logdens_linear: (model on _setup_implied_gaussian) linear_part: like A_scaling (from lasso) offset:\",\n \"at least one feature in group 3). This function checks\",\n \"tol * np.fabs(current_value) and itercount >= min_its: current = proposal\",\n \"as solver from ..distributions.discrete_family import discrete_family class group_lasso(object): def __init__(self,\",\n \"use_lasso, perturb) def _setup_implied_gaussian(self): _, prec = self.randomizer.cov_prec if np.asarray(prec).shape\",\n \"with no penalty overall = np.ones(self.nfeature, np.bool) # mask of\",\n \"self.cond_cov logdens_linear = self.logdens_linear linear_part = self.linear_part offset = self.offset\",\n \"label group_mask = self.groups == g soln = self.initial_soln #\",\n \"quadratic=None, ridge_term=0., perturb=None, use_lasso=True, # should lasso solver be used\",\n \"= proposed_value break current = proposal current_value = proposed_value if\",\n \"solver be used when applicable - defaults to True randomizer_scale=None):\",\n \"for the user and in future we might do this\",\n \"2. result = pd.DataFrame({'MLE': final_estimator, 'SE': np.sqrt(np.diag(observed_info_mean)), 'Zvalue': Z_scores, 'pvalue':\",\n \"an an np.array rather than a dictionary weights_np = np.array([w[1]\",\n \"* XE) QI = inv(Q) C = V.T.dot(QI).dot(L).dot(V) self.XE =\",\n \"needs to be updated to actually use the Jacobian information\",\n \"= objective(proposal) if proposed_value <= current_value: break step *= 0.5\",\n \"hessian p1 = con_linear.T.dot(np.diag(-1. / ((scaling + con_offset - con_linear.dot(gs))\",\n \"self.XE = XE self.Q = Q self.QI = QI self.C\",\n \"the gammas cond_mean = self.cond_mean cond_cov = self.cond_cov logdens_linear =\",\n \"return np.asarray(ref_hat) def _construct_families(self): self._construct_density() self._families = [] for m\",\n \"# Gamma is target_score_cov.T.dot(prec_target) num_opt = self.prec_opt.shape[0] num_con = self.linear_part.shape[0]\",\n \"p1 + p2 + p3 + p4 def barrier_hessian(gs): #\",\n \"** 2.))).dot(con_linear) if useJacobian: p2 = - jacobian_grad_hess(gs, C, active_dirs)[2]\",\n \"if dispersion is None: # use Pearson's X^2 dispersion =\",\n \"(self.initial_soln, self.initial_subgrad) = self._solve_randomized_problem(perturb=perturb, solve_args=solve_args) # initialize variables active_groups =\",\n \"if count >= 40: raise ValueError('not finding a feasible point')\",\n \"groups are size 1, set up lasso penalty and run\",\n \"- jacobian_grad_hess(gs, C, active_dirs)[1] else: p3 = 0 p4 =\",\n \"L.dot(hess.dot(L.T)) observed_info_mean = target_cov.dot(observed_info_natural.dot(target_cov)) Z_scores = final_estimator / np.sqrt(np.diag(observed_info_mean)) pvalues\",\n \"query.randomizer_prec self.score_offset = query.observed_score_state + query.opt_offset self.ntarget = ntarget =\",\n \"now we are collecting the directions and norms of the\",\n \"import print_function from scipy.linalg import block_diag from scipy.stats import norm\",\n \"to provide weights an an np.array rather than a dictionary\",\n \"L = block_diag(*Ls) # unpack the list XE = X[:,\",\n \"intervals = np.vstack([final_estimator - quantile * np.sqrt(np.diag(observed_info_mean)), final_estimator + quantile\",\n \"np.ones(self.nfeature, np.bool) # mask of active features ordered_groups = []\",\n \"result = pd.DataFrame({'MLE': final_estimator, 'SE': np.sqrt(np.diag(observed_info_mean)), 'Zvalue': Z_scores, 'pvalue': pvalues,\",\n \"= X[:, ordered_vars] # changed to ordered_vars Q = XE.T.dot(self._W[:,\",\n \">= 20: if not (np.isnan(proposed_value) or np.isnan(current_value)): break else: raise\",\n \"1.e-12, 'min_its': 50}, perturb=None): # solve the randomized version of\",\n \"self.cond_mean cond_cov = self.cond_cov logdens_linear = self.logdens_linear linear_part = self.linear_part\",\n \"or C solver JacobianPieces: (use self.C defined in fitting) \\\"\\\"\\\"\",\n \"pivot = [] for m in range(self.ntarget): family = self._families[m]\",\n \"= logdens_linear return cond_mean, cond_cov, cond_precision, logdens_linear def selective_MLE(self, solve_args={'tol':\",\n \"= query.logdens_linear self.cond_mean = query.cond_mean self.prec_opt = np.linalg.inv(query.cond_cov) self.cond_cov =\",\n \"= precs self.S = S self.r = r def solve_barrier_affine_jacobian_py(conjugate_arg,\",\n \"%f, %f' % (proposed_value, current_value)) # stop if relative decrease\",\n \"selected groups with no penalty overall = np.ones(self.nfeature, np.bool) #\",\n \"1) if randomizer_scale is None: randomizer_scale = np.sqrt(mean_diag) * 0.5\",\n \"self.prec_opt = np.linalg.inv(query.cond_cov) self.cond_cov = query.cond_cov self.C = query.C self.active_dirs\",\n \"family = self._families[m] var_target = 1. / ((self.precs[m])[0, 0]) mean\",\n \"L.dot(target_lin) - L.dot(hess.dot(L.T)) observed_info_mean = target_cov.dot(observed_info_natural.dot(target_cov)) Z_scores = final_estimator /\",\n \"def __init__(self, query, dispersion, solve_args={'tol': 1.e-12}, useIP=True): \\\"\\\"\\\" Produce p-values\",\n \"ndist.ppf(1 - alpha / 2.) intervals = np.vstack([final_estimator - quantile\",\n \"1)) for ug in active_dirs.values()]) # gradient grad_J = S.dot(GpC_inv.diagonal())\",\n \"self.active = active def compute_Vg(ug): pg = ug.size # figure\",\n \"column else: Vg = np.zeros((1, 0)) # if the group\",\n \"- XE.shape[1]) cov_target = self.QI * dispersion crosscov_target_score = _score_linear.dot(self.QI).T\",\n \"level : float Confidence level. \\\"\\\"\\\" if parameter is not\",\n \"and confidence intervals for targets of model including selected features\",\n \"np.sqrt(n - 1) if randomizer_scale is None: randomizer_scale = np.sqrt(mean_diag)\",\n \"the directions and norms of the active groups for g\",\n \"False: logW = (log_ref - 0.5 * (self.stat_grid[m] - self.observed_target[m])\",\n \"= -opt_linearNoU.dot(_beta_unpenalized) self.observed_score_state[~overall] += self.loglike.smooth_objective(beta_bar, 'grad')[~overall] active_signs = np.sign(self.initial_soln) active\",\n \"is small if np.fabs(current_value - proposed_value) < tol * np.fabs(current_value)\",\n \"feasible_point = 1. / scaling def objective(gs): p1 = -gs.T.dot(conjugate_arg)\",\n \"p4 def barrier_hessian(gs): # contribution of barrier and jacobian to\",\n \"target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean - soln))) + C unbiased_estimator = target_cov.dot(_prec).dot(observed_target) + target_cov.dot(\",\n \"target_linear.T.dot(target_offset) * self.randomizer_prec _prec = prec_target + (target_linear.T.dot(target_linear) * self.randomizer_prec)\",\n \"/ ((self.precs[m])[0, 0]) mean = self.S[m].dot(mean_parameter[m].reshape((1,))) + self.r[m] _cdf =\",\n \"cond_mean, cond_cov, cond_precision, logdens_linear def selective_MLE(self, solve_args={'tol': 1.e-12}, level=0.9, useJacobian=True,\",\n \"active_dirs)[0] else: p3 = 0 p4 = log(1. + 1.\",\n \"inv(precision + barrier_hessian(current)) return current_value, current, hess # Jacobian calculations\",\n \"ordered_vars Q = XE.T.dot(self._W[:, None] * XE) QI = inv(Q)\",\n \"self.loglike.data W = self._W = self.loglike.saturated_loss.hessian(X.dot(beta_bar)) # all 1's for\",\n \"np.asarray(lower), np.asarray(upper) ### Private method def _construct_density(self): precs = {}\",\n \"upper = self._approx_intervals(level=level) result = pd.DataFrame({'target': self.observed_target, 'pvalue': pvalues, 'lower_confidence':\",\n \"class variable since the non-group lasso doesn't self.groups = groups\",\n \"ndarray Estimated covaraince of target. target_score_cov : ndarray Estimated covariance\",\n \"E overall, solve_args=solve_args) beta_bar = np.zeros(self.nfeature) beta_bar[overall] = _beta_unpenalized #\",\n \"@staticmethod def gaussian(X, Y, groups, weights, sigma=1., quadratic=None, ridge_term=0., perturb=None,\",\n \"np.fabs(current_value) and itercount >= min_its: current = proposal current_value =\",\n \"soln, hess = solve_barrier_affine_jacobian_py(conjugate_arg, prec_opt, init_soln, linear_part, offset, self.C, self.active_dirs,\",\n \"of assumptions that group_lasso makes about how groups are specified.\",\n \"implied_mean * implied_prec val, soln, _ = solver(np.asarray([conjugate_arg]), np.reshape(implied_prec, (1,1)),\",\n \"if pg > 1: Z = np.column_stack((ug, np.eye(pg, pg -\",\n \"perturb) def _setup_implied_gaussian(self): _, prec = self.randomizer.cov_prec if np.asarray(prec).shape in\",\n \"to solver. \\\"\\\"\\\" self.solve_args = solve_args result, inverse_info = query.selective_MLE(dispersion=dispersion)[:2]\",\n \"target_cov_score: from selected_targets init_soln: (opt_state) initial (observed) value of optimization\",\n \"dispersion=None, solve_args={'tol': 1.e-12, 'min_its': 50}): X, y = self.loglike.data n,\",\n \"J = np.log(np.linalg.det(GammaMinus + C)) # inverse #GpC_inv = evectors.dot(np.diag(1\",\n \"+ 1. / ((con_offset - con_linear.dot(gs)) / scaling)).sum() return p1\",\n \"lower, 'upper_confidence': upper}) if not np.all(parameter == 0): result.insert(4, 'pivot',\",\n \"= target_linear.T.dot(target_offset) * self.randomizer_prec _prec = prec_target + (target_linear.T.dot(target_linear) *\",\n \"to True randomizer_scale=None): loglike = rr.glm.gaussian(X, Y, coef=1. / sigma\",\n \"for parameter -- defaults to 0. level : float Confidence\",\n \"target specified') prec_target = np.linalg.inv(target_cov) target_lin = - self.logdens_linear.dot(target_score_cov.T.dot(prec_target)) ref_hat\",\n \"gamma vector, active directions) \\\"\\\"\\\" to_diag = [[g] * (ug.size\",\n \"if alternatives[m] == 'twosided': pivot.append(2 * min(_cdf, 1 - _cdf))\",\n \"list XE = X[:, ordered_vars] # changed to ordered_vars Q\",\n \"times Gamma, # where \\\"something\\\" comes from implied Gaussian #\",\n \"np.zeros((ntarget, ngrid)) for j in range(ntarget): self.stat_grid[j, :] = np.linspace(observed_target[j]\",\n \"barrier function C: V^T Q^{-1} \\\\\\\\Lambda V active_dirs: \\\"\\\"\\\" scaling\",\n \"_scale[j], observed_target[j] + 1.5 * _scale[j], num=ngrid) else: ngrid =\",\n \"variables (model on _setup_implied_gaussian) logdens_linear: (model on _setup_implied_gaussian) linear_part: like\",\n \".randomization import randomization from ..base import restricted_estimator from ..algorithms.barrier_affine import\",\n \"np.exp(logW))) def _approx_pivots(self, mean_parameter, alternatives=None): if not hasattr(self, \\\"_families\\\"): self._construct_families()\",\n \"completed \\\", m) if alternatives[m] == 'twosided': pivot.append(2 * min(_cdf,\",\n \"/ ((scaling + con_offset - con_linear.dot(gs)) ** 2.) + 1.\",\n \"gamma's ordered by group labels ordered_vars = [] # indices\",\n \"Produce p-values and confidence intervals for targets of model including\",\n \"problem.solve(quad, **solve_args) initial_subgrad = -(self.loglike.smooth_objective(initial_soln, 'grad') + quad.objective(initial_soln, 'grad')) return\",\n \"con_linear.dot(proposal) > 0): break step *= 0.5 if count >=\",\n \"np.zeros(self.observed_opt_state.shape[0]) return active_signs, soln def _solve_randomized_problem(self, perturb=None, solve_args={'tol': 1.e-15, 'min_its':\",\n \"'SE': np.sqrt(np.diag(observed_info_mean)), 'Zvalue': Z_scores, 'pvalue': pvalues, 'lower_confidence': intervals[:, 0], 'upper_confidence':\",\n \"There are a number of assumptions that group_lasso makes about\",\n \"# dictionary: keys are group labels, values are unit-norm coefficients\",\n \"cond_precision = self.opt_linear.T.dot(prec.dot(self.opt_linear)) cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T).dot(prec) cond_mean\",\n \"randomizer, use_lasso=True, # should lasso solver be used where applicable\",\n \"cond_mean self.cond_cov = cond_cov self.cond_precision = cond_precision self.logdens_linear = logdens_linear\",\n \"implied_mean = np.asscalar(eta.T.dot(cond_mean_grid)) implied_cov = np.asscalar(eta.T.dot(self.cond_cov).dot(eta)) implied_prec = 1./implied_cov _A\",\n \"density # depends on the score, not how the mean\",\n \"active_signs = np.sign(self.initial_soln) active = np.flatnonzero(active_signs) self.active = active def\",\n \"active_dirs self.opt_offset = opt_offset self.ordered_vars = ordered_vars self.linear_part = -np.eye(self.observed_opt_state.shape[0])\",\n \"Z = np.column_stack((ug, np.eye(pg, pg - 1))) Q, _ =\",\n \"result = pd.DataFrame({'target': self.observed_target, 'pvalue': pvalues, 'lower_confidence': lower, 'upper_confidence': upper})\",\n \"self.randomizer_prec = self.randomizer.cov_prec # now we are collecting the directions\",\n \"the fit method since this uses results from that method.\",\n \"of redundant with keys of active_dirs self._ordered_groups = ordered_groups #\",\n \"ref_hat = [] for k in range(grid.shape[0]): # in the\",\n \"p2 + p3 + p4 def grad(gs): p1 = -conjugate_arg\",\n \"since this uses results from that method. Parameters ---------- observed_target:\",\n \"of target. target_cov : ndarray Estimated covaraince of target. target_score_cov\",\n \"active_dirs[g] = soln[group_mask] / norm(soln[group_mask]) ordered_opt.append(norm(soln[group_mask])) else: overall[group_mask] = False\",\n \"raises an exception if it finds any problems. Sorting feature\",\n \"self._beta_full = beta_bar X, y = self.loglike.data W = self._W\",\n \"\\\"\\\"\\\"Do selective_MLE for group_lasso Note: this masks the selective_MLE inherited\",\n \"prec_opt = self.cond_precision score_offset = self.observed_score_state + self.opt_offset # target_lin\",\n \"if it finds any problems. Sorting feature groups is potentially\",\n \"approx_fn = interp1d(self.stat_grid[m], log_ref, kind='quadratic', bounds_error=False, fill_value='extrapolate') grid = np.linspace(self.stat_grid[m].min(),\",\n \"def _construct_families(self): self._construct_density() self._families = [] for m in range(self.ntarget):\",\n \"return J, grad_J, hess_J def _check_groups(groups): \\\"\\\"\\\"Make sure that the\",\n \"from __future__ import print_function from scipy.linalg import block_diag from scipy.stats\",\n \"opt_linearNoU[var, i] += self.ridge_term opt_offset = self.initial_subgrad self.observed_score_state = -opt_linearNoU.dot(_beta_unpenalized)\",\n \"count >= 20: if not (np.isnan(proposed_value) or np.isnan(current_value)): break else:\",\n \"be an empty array return 0, 0, 0 else: GammaMinus\",\n \"self.cond_cov = query.cond_cov self.C = query.C self.active_dirs = query.active_dirs (observed_target,\",\n \"if randomizer_scale is None: randomizer_scale = np.sqrt(mean_diag) * 0.5 *\",\n \"calculations def calc_GammaMinus(gamma, active_dirs): \\\"\\\"\\\"Calculate Gamma^minus (as a function of\",\n \"alternatives) = self.selected_targets(dispersion) init_soln = self.observed_opt_state # just the gammas\",\n \"0): break step *= 0.5 if count >= 40: raise\",\n \"is not adapted for the group_lasso. Also, assumes you have\",\n \"alternatives[m] == 'less': pivot.append(_cdf) else: raise ValueError('alternative should be in\",\n \"+ barrier_hessian(current)) return current_value, current, hess # Jacobian calculations def\",\n \"\\\\\\\\bar{\\\\\\\\Sigma}^{-1} feasible_point: gamma's from fitting con_linear: linear part of affine\",\n \"active_dirs)[2] else: p2 = 0 return p1 + p2 current\",\n \"lower, upper = self._approx_intervals(level=level) result = pd.DataFrame({'target': self.observed_target, 'pvalue': pvalues,\",\n \"ntarget = target_cov.shape[0] _scale = 4 * np.sqrt(np.diag(inverse_info)) if useIP\",\n \"target_lin.T.dot( self.prec_opt).dot(target_lin) _P = target_linear.T.dot(target_offset) * self.randomizer_prec _r = (1.\",\n \"self.ordered_vars = ordered_vars self.linear_part = -np.eye(self.observed_opt_state.shape[0]) self.offset = np.zeros(self.observed_opt_state.shape[0]) return\",\n \"self.ridge_term = ridge_term # group lasso penalty (from regreg) #\",\n \"active directions) \\\"\\\"\\\" to_diag = [[g] * (ug.size - 1)\",\n \"zeros self._beta_full = beta_bar X, y = self.loglike.data W =\",\n \"* prec cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T) * prec\",\n \"if np.all(con_offset - con_linear.dot(proposal) > 0): break step *= 0.5\",\n \"+ self.cond_mean) #direction for decomposing o eta = -self.prec_opt.dot(self.logdens_linear.dot(target_score_cov.T)) implied_mean\",\n \"family = self._families[m] observed_target = self.observed_target[m] l, u = family.equal_tailed_interval(observed_target,\",\n \"cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T).dot(prec) cond_mean = -logdens_linear.dot(self.observed_score_state +\",\n \"query.opt_offset self.ntarget = ntarget = target_cov.shape[0] _scale = 4 *\",\n \"logW.max() self._families.append(discrete_family(self.stat_grid[m], np.exp(logW))) else: approx_fn = interp1d(self.stat_grid[m], log_ref, kind='quadratic', bounds_error=False,\",\n \"the Jacobian information (in self.C) arguments conjugate_arg: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} \\\\bar{\\\\\\\\mu} precision:\",\n \"implied Gaussian # cond_mean is \\\"something\\\" times D # Gamma\",\n \"for m in range(self.ntarget): observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1,\",\n \"np.log(np.linalg.det(GammaMinus + C)) # inverse #GpC_inv = evectors.dot(np.diag(1 / evalues).dot(evectors.T))\",\n \"from numpy import log from numpy.linalg import norm, qr, inv,\",\n \"parameter : np.array Hypothesized value for parameter -- defaults to\",\n \"grad_J = S.dot(GpC_inv.diagonal()) # hessian hess_J = -S.dot(np.multiply(GpC_inv, GpC_inv.T).dot(S.T)) return\",\n \"upper = [], [] for m in range(self.ntarget): # construction\",\n \"gamma_ = _A.dot(soln) + R.dot(self.init_soln) log_jacob = jacobian_grad_hess(gamma_, self.C, self.active_dirs)\",\n \"self.stat_grid = np.zeros((ntarget, ngrid)) for j in range(ntarget): self.stat_grid[j, :]\",\n \"/ var_target) logW -= logW.max() self._families.append(discrete_family(self.stat_grid[m], np.exp(logW))) else: approx_fn =\",\n \"the randomized version of group lasso (self.initial_soln, self.initial_subgrad) = self._solve_randomized_problem(perturb=perturb,\",\n \"# check sorted if np.any(agroups[:-1] > agroups[1:]) < 0: raise\",\n \"small if np.fabs(current_value - proposed_value) < tol * np.fabs(current_value) and\",\n \"num_con = self.linear_part.shape[0] cond_mean_grid = (target_lin.dot(np.atleast_1d(grid[k] - observed_target)) + self.cond_mean)\",\n \"times D # Gamma is target_score_cov.T.dot(prec_target) num_opt = self.prec_opt.shape[0] num_con\",\n \"the user-specified group scheme and raises an exception if it\",\n \"= target_cov.shape[0] _scale = 4 * np.sqrt(np.diag(inverse_info)) if useIP ==\",\n \"from query because that is not adapted for the group_lasso.\",\n \"1)) target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) var_target = 1. /\",\n \"self.target_cov = target_cov self.init_soln = query.observed_opt_state self.randomizer_prec = query.randomizer_prec self.score_offset\",\n \"a group 2 and a group 4, there must also\",\n \"not np.all(parameter == 0): result.insert(4, 'pivot', pivots) result.insert(5, 'parameter', parameter)\",\n \"* _scale[j], num=ngrid) self.opt_linear = query.opt_linear self.useIP = useIP def\",\n \"- target_lin.T.dot(prec_opt).dot(target_off)) L = target_lin.T.dot(prec_opt) observed_info_natural = _prec + L.dot(target_lin)\",\n \"self.QI * dispersion crosscov_target_score = _score_linear.dot(self.QI).T * dispersion return (observed_target,\",\n \"randomizer, use_lasso, perturb) def _setup_implied_gaussian(self): _, prec = self.randomizer.cov_prec if\",\n \"else: overall[group_mask] = False self.selection_variable = {'directions': active_dirs, 'active_groups': active_groups}\",\n \"potentially tedious for the user and in future we might\",\n \"intervals from families follows `selectinf.learning.core` family = self._families[m] observed_target =\",\n \"range(ntarget): self.stat_grid[j, :] = np.linspace(observed_target[j] - 1.5 * _scale[j], observed_target[j]\",\n \"self.log_reference(observed_target_uni, target_cov_uni, target_score_cov_uni, self.stat_grid[m]) if self.useIP == False: logW =\",\n \"np.reshape(implied_prec, (1,1)), eta.T.dot(self.init_soln), A.reshape((A.shape[0],1)), b, **self.solve_args) gamma_ = _A.dot(soln) +\",\n \"else: active_groups.append(g) active_dirs[g] = soln[group_mask] / norm(soln[group_mask]) ordered_opt.append(norm(soln[group_mask])) else: overall[group_mask]\",\n \"in [(), (0,)]: cond_precision = self.opt_linear.T.dot(self.opt_linear) * prec cond_cov =\",\n \"descent count = 0 while True: count += 1 proposal\",\n \"describe implied Gaussian. observed_target : ndarray Observed estimate of target.\",\n \"block_diag(*[ug for ug in sorted_active_dirs.values()]).T self.opt_linear = opt_linearNoU.dot(U) self.active_dirs =\",\n \"redundant with keys of active_dirs self._ordered_groups = ordered_groups # exception\",\n \"= self._approx_pivots(parameter, alternatives=alternatives) else: pivots = None pvalues = self._approx_pivots(np.zeros_like(self.observed_target),\",\n \"1.e-20 _, self.randomizer_prec = self.randomizer.cov_prec # now we are collecting\",\n \"alternatives is None: alternatives = ['twosided'] * self.ntarget pivot =\",\n \"= S.dot(GpC_inv.diagonal()) # hessian hess_J = -S.dot(np.multiply(GpC_inv, GpC_inv.T).dot(S.T)) return J,\",\n \"self.cond_cov = cond_cov self.cond_precision = cond_precision self.logdens_linear = logdens_linear return\",\n \"logdens_linear.dot(target_linear) target_off = cond_mean - target_lin.dot(observed_target) if np.asarray(self.randomizer_prec).shape in [(),\",\n \"self.loglike.smooth_objective(beta_bar, 'grad')[~overall] active_signs = np.sign(self.initial_soln) active = np.flatnonzero(active_signs) self.active =\",\n \"(model on _setup_implied_gaussian) linear_part: like A_scaling (from lasso) offset: like\",\n \"np.identity(num_opt) - _A.dot(eta.T) A = self.linear_part.dot(_A).reshape((-1,)) b = self.offset-self.linear_part.dot(R).dot(self.init_soln) conjugate_arg\",\n \"of integers that are sorted in increasing order, start at\",\n \"first column else: Vg = np.zeros((1, 0)) # if the\",\n \"'grad') + quad.objective(initial_soln, 'grad')) return initial_soln, initial_subgrad @staticmethod def gaussian(X,\",\n \"= np.array([w[1] for w in sorted(weights.items())]) self.penalty = rr.weighted_l1norm(weights=weights_np, lagrange=1.)\",\n \"to ordered_vars Q = XE.T.dot(self._W[:, None] * XE) QI =\",\n \"implied Gaussian. observed_target : ndarray Observed estimate of target. target_cov\",\n \"an np.array rather than a dictionary weights_np = np.array([w[1] for\",\n \"range(self.ntarget): family = self._families[m] var_target = 1. / ((self.precs[m])[0, 0])\",\n \"C.shape == (0, 0): # when all groups are size\",\n \"** 2.) + 1. / ((con_offset - con_linear.dot(gs)) ** 2.))).dot(con_linear)\",\n \"/ self._W).sum() / (n - XE.shape[1]) cov_target = self.QI *\",\n \"def barrier_hessian(gs): # contribution of barrier and jacobian to hessian\",\n \"optional Arguments passed to solver. \\\"\\\"\\\" self.solve_args = solve_args result,\",\n \"grid. \\\"\\\"\\\" if np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no target\",\n \"((self.precs[m])[0, 0]) lower.append(l * var_target + observed_target) upper.append(u * var_target\",\n \"target_offset = (self.score_offset - target_linear.dot(observed_target_uni)).reshape( (target_linear.shape[0],)) target_lin = -self.logdens_linear.dot(target_linear) target_off\",\n \"self.nfeature = self.loglike.shape[0] # ridge parameter self.ridge_term = ridge_term #\",\n \"selected_targets(self, dispersion=None, solve_args={'tol': 1.e-12, 'min_its': 50}): X, y = self.loglike.data\",\n \"% (proposed_value, current_value)) # stop if relative decrease is small\",\n \"logdens_linear determines how the argument of the optimization density #\",\n \"= 1. / (con_offset - con_linear.dot(gs)) return p1 + p2\",\n \"2 and a group 4, there must also be at\",\n \"-self._initial_omega, 0) problem = rr.simple_problem(self.loglike, self.penalty) # if all groups\",\n \"# initialize variables active_groups = [] # active group labels\",\n \"self.logdens_linear = query.logdens_linear self.cond_mean = query.cond_mean self.prec_opt = np.linalg.inv(query.cond_cov) self.cond_cov\",\n \"sure proposal is a descent count = 0 while True:\",\n \"opt_linearNoU = np.dot(X.T, X[:, ordered_vars] * W[:, np.newaxis]) for i,\",\n \"pg > 1: Z = np.column_stack((ug, np.eye(pg, pg - 1)))\",\n \"pandas as pd import regreg.api as rr from .randomization import\",\n \"m in range(self.ntarget): # construction of intervals from families follows\",\n \"= cond_mean self.cond_cov = cond_cov self.cond_precision = cond_precision self.logdens_linear =\",\n \"as pd import regreg.api as rr from .randomization import randomization\",\n \"= ug.size # figure out size of g'th group if\",\n \"count >= 40: raise ValueError('not finding a feasible point') #\",\n \"Jacobian information (in self.C) arguments conjugate_arg: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} \\\\bar{\\\\\\\\mu} precision: \\\\\\\\bar{\\\\\\\\Sigma}^{-1}\",\n \"current_value, current, hess # Jacobian calculations def calc_GammaMinus(gamma, active_dirs): \\\"\\\"\\\"Calculate\",\n \"ordered_groups = [] # active group labels sorted by label\",\n \"self.precs = precs self.S = S self.r = r def\",\n \"hess # Jacobian calculations def calc_GammaMinus(gamma, active_dirs): \\\"\\\"\\\"Calculate Gamma^minus (as\",\n \"in range(self.ntarget): # construction of intervals from families follows `selectinf.learning.core`\",\n \"self.target_score_cov[m, :].reshape((1, p)) target_linear = target_score_cov_uni.T.dot(prec_target) target_offset = (self.score_offset -\",\n \"lasso penalty (from regreg) # use regular lasso penalty if\",\n \"self.initial_subgrad self.observed_score_state = -opt_linearNoU.dot(_beta_unpenalized) self.observed_score_state[~overall] += self.loglike.smooth_objective(beta_bar, 'grad')[~overall] active_signs =\",\n \"return Vg def compute_Lg(g): pg = active_dirs[g].size Lg = self.penalty.weights[g]\",\n \"perturb is not None: self._initial_omega = perturb if self._initial_omega is\",\n \"self.selection_variable = {'directions': active_dirs, 'active_groups': active_groups} # kind of redundant\",\n \"qr, inv, eig import pandas as pd import regreg.api as\",\n \"for j in range(ntarget): self.stat_grid[j, :] = np.linspace(observed_target[j] - 1.5\",\n \"_approx_intervals(self, level=0.9): if not hasattr(self, \\\"_families\\\"): self._construct_families() lower, upper =\",\n \"quantile = ndist.ppf(1 - alpha / 2.) intervals = np.vstack([final_estimator\",\n \"# drop the first column else: Vg = np.zeros((1, 0))\",\n \"dimension if len(agroups.shape) != 1: raise ValueError(\\\"Groups are not a\",\n \"and a group 4, there must also be at least\",\n \"V^T Q^{-1} \\\\\\\\Lambda V active_dirs: \\\"\\\"\\\" scaling = np.sqrt(np.diag(con_linear.dot(precision).dot(con_linear.T))) if\",\n \"lasso solver... (see existing code)... initial_soln = problem.solve(quad, **solve_args) initial_subgrad\",\n \"- target_linear.dot(observed_target) target_lin = - logdens_linear.dot(target_linear) target_off = cond_mean -\",\n \"def _approx_intervals(self, level=0.9): if not hasattr(self, \\\"_families\\\"): self._construct_families() lower, upper\",\n \"out size of g'th group if pg > 1: Z\",\n \"Jacobian calculations def calc_GammaMinus(gamma, active_dirs): \\\"\\\"\\\"Calculate Gamma^minus (as a function\",\n \"if not np.amin(agroups) == 0: raise ValueError(\\\"First group is not\",\n \"* (grid - self.observed_target[m]) ** 2 / var_target) logW -=\",\n \"\\\"\\\"\\\" if np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no target specified')\",\n \"(gamma.size square matrix) \\\"\\\"\\\" if C.shape == (0, 0): #\",\n \"self.cond_mean = cond_mean self.cond_cov = cond_cov self.cond_precision = cond_precision self.logdens_linear\",\n \"var_target) logW -= logW.max() self._families.append(discrete_family(self.stat_grid[m], np.exp(logW))) else: approx_fn = interp1d(self.stat_grid[m],\",\n \"X.shape mean_diag = np.mean((X ** 2).sum(0)) if ridge_term is None:\",\n \"observed_target: from selected_targets target_cov: from selected_targets target_cov_score: from selected_targets init_soln:\",\n \"selected_targets init_soln: (opt_state) initial (observed) value of optimization variables cond_mean:\",\n \"np.newaxis]) for i, var in enumerate(ordered_vars): opt_linearNoU[var, i] += self.ridge_term\",\n \"in to_diag for i in gp]) def jacobian_grad_hess(gamma, C, active_dirs):\",\n \"empty array return 0, 0, 0 else: GammaMinus = calc_GammaMinus(gamma,\",\n \"of confidence intervals useC: whether to use python or C\",\n \"sorted(weights.items())]) self.penalty = rr.weighted_l1norm(weights=weights_np, lagrange=1.) else: self.penalty = rr.group_lasso(groups, weights=weights,\",\n \"is \\\"something\\\" times D # Gamma is target_score_cov.T.dot(prec_target) num_opt =\",\n \"# construction of intervals from families follows `selectinf.learning.core` family =\",\n \"{} p = self.target_score_cov.shape[1] for m in range(self.ntarget): observed_target_uni =\",\n \"used for barrier function con_offset: offset part of affine constraint\",\n \"ordered_vars] * W[:, np.newaxis]) for i, var in enumerate(ordered_vars): opt_linearNoU[var,\",\n \"np.linalg.inv(target_cov) target_lin = - self.logdens_linear.dot(target_score_cov.T.dot(prec_target)) ref_hat = [] for k\",\n \"is None: # use Pearson's X^2 dispersion = ((y -\",\n \"if alternatives is None: alternatives = ['twosided'] * self.ntarget pivot\",\n \"if useJacobian: p3 = - jacobian_grad_hess(gs, C, active_dirs)[1] else: p3\",\n \"= self.S[m].dot(mean_parameter[m].reshape((1,))) + self.r[m] _cdf = family.cdf((mean[0] - self.observed_target[m]) /\",\n \"that method. Parameters ---------- observed_target: from selected_targets target_cov: from selected_targets\",\n \"query.observed_opt_state self.randomizer_prec = query.randomizer_prec self.score_offset = query.observed_score_state + query.opt_offset self.ntarget\",\n \"if useJacobian: p3 = - jacobian_grad_hess(gs, C, active_dirs)[0] else: p3\",\n \"/ (n - XE.shape[1]) cov_target = self.QI * dispersion crosscov_target_score\",\n \"if not hasattr(self, \\\"_families\\\"): self._construct_families() if alternatives is None: alternatives\",\n \"describing the alternatives, should be values of ['twosided', 'less', 'greater']\",\n \"active_dirs)[1] else: p3 = 0 p4 = 1. / (con_offset\",\n \"= _A.dot(soln) + R.dot(self.init_soln) log_jacob = jacobian_grad_hess(gamma_, self.C, self.active_dirs) ref_hat.append(-val\",\n \"ngrid)) for j in range(ntarget): self.stat_grid[j, :] = np.linspace(observed_target[j] -\",\n \"for m in range(self.ntarget): # construction of intervals from families\",\n \"argument of the optimization density # depends on the score,\",\n \": np.array Hypothesized value for parameter -- defaults to 0.\",\n \"= inv(precision + barrier_hessian(current)) return current_value, current, hess # Jacobian\",\n \"for m in range(self.ntarget): family = self._families[m] var_target = 1.\",\n \"to_diag for i in gp]) def jacobian_grad_hess(gamma, C, active_dirs): \\\"\\\"\\\"\",\n \"since the non-group lasso doesn't self.groups = groups self._initial_omega =\",\n \"log Jacobian #J = log(evalues).sum() J = np.log(np.linalg.det(GammaMinus + C))\",\n \"target_cov, target_score_cov, grid): \\\"\\\"\\\" Approximate the log of the reference\",\n \"/ sigma ** 2, quadratic=quadratic) n, p = X.shape mean_diag\",\n \"log_ref def selected_targets(self, dispersion=None, solve_args={'tol': 1.e-12, 'min_its': 50}): X, y\",\n \"information to describe implied Gaussian. observed_target : ndarray Observed estimate\",\n \"we assume that `groups` is a 1-d array_like of integers\",\n \": ndarray Estimated covariance of target and score of randomized\",\n \"feature in group 3). This function checks the user-specified group\",\n \"labels tol = 1.e-20 _, self.randomizer_prec = self.randomizer.cov_prec # now\",\n \"= [] # indices \\\"ordered\\\" by sorting group labels tol\",\n \"_S = np.linalg.inv(_prec).dot(prec_target) S[m] = _S r[m] = _r precs[m]\",\n \"proposed_value) < tol * np.fabs(current_value) and itercount >= min_its: current\",\n \"# in the usual D = N + Gamma theta.hat,\",\n \"log_ref = self.log_reference(observed_target_uni, target_cov_uni, target_score_cov_uni, self.stat_grid[m]) if self.useIP == False:\",\n \"groups looks sensible # log likelihood : quadratic loss self.loglike\",\n \"g soln = self.initial_soln # do not need to keep\",\n \"(scalar), gradient (gamma.size vector) and hessian (gamma.size square matrix) \\\"\\\"\\\"\",\n \"level of confidence intervals useC: whether to use python or\",\n \"= randomizer def fit(self, solve_args={'tol': 1.e-12, 'min_its': 50}, perturb=None): #\",\n \"and hessian (gamma.size square matrix) \\\"\\\"\\\" if C.shape == (0,\",\n \"no groups are selected if len(self.selection_variable['active_groups']) == 0: return np.sign(soln),\",\n \"dispersion = ((y - self.loglike.saturated_loss.mean_function( XE.dot(observed_target))) ** 2 / self._W).sum()\",\n \"by label ordered_opt = [] # gamma's ordered by group\",\n \"0 else: GammaMinus = calc_GammaMinus(gamma, active_dirs) # eigendecomposition #evalues, evectors\",\n \"if np.asarray(self.randomizer_prec).shape in [(), (0,)]: _P = target_linear.T.dot(target_offset) * self.randomizer_prec\",\n \"D = N + Gamma theta.hat, # target_lin is \\\"something\\\"\",\n \"likelihood : quadratic loss self.loglike = loglike self.nfeature = self.loglike.shape[0]\",\n \"# gammas as array _beta_unpenalized = restricted_estimator(self.loglike, # refit OLS\",\n \"> 1: Z = np.column_stack((ug, np.eye(pg, pg - 1))) Q,\",\n \"of intervals from families follows `selectinf.learning.core` family = self._families[m] observed_target\",\n \"A = self.linear_part.dot(_A).reshape((-1,)) b = self.offset-self.linear_part.dot(R).dot(self.init_soln) conjugate_arg = implied_mean *\",\n \"self.linear_part.dot(_A).reshape((-1,)) b = self.offset-self.linear_part.dot(R).dot(self.init_soln) conjugate_arg = implied_mean * implied_prec val,\",\n \"assumptions that group_lasso makes about how groups are specified. Specifically,\",\n \"just the gammas cond_mean = self.cond_mean cond_cov = self.cond_cov logdens_linear\",\n \"# take a new perturbation if supplied if perturb is\",\n \"assume that `groups` is a 1-d array_like of integers that\",\n \"1. / ((self.precs[m])[0, 0]) log_ref = self.log_reference(observed_target_uni, target_cov_uni, target_score_cov_uni, self.stat_grid[m])\",\n \"+ p3 + p4 def barrier_hessian(gs): # contribution of barrier\",\n \"break step *= 0.5 if count >= 20: if not\",\n \"make sure proposal is feasible count = 0 while True:\",\n \"size one, C will be an empty array return 0,\",\n \"appreciably nonzero ordered_groups.append(g) # variables in active group ordered_vars.extend(np.flatnonzero(group_mask)) if\",\n \"as array _beta_unpenalized = restricted_estimator(self.loglike, # refit OLS on E\",\n \"p4 = 1. / (con_offset - con_linear.dot(gs)) return p1 +\",\n \"4 == 0: step *= 2 hess = inv(precision +\",\n \"= Q[:, 1:] # drop the first column else: Vg\",\n \"dictionary weights_np = np.array([w[1] for w in sorted(weights.items())]) self.penalty =\",\n \"target_lin.dot(observed_target) if np.asarray(self.randomizer_prec).shape in [(), (0,)]: _P = target_linear.T.dot(target_offset) *\",\n \"np.vstack([final_estimator - quantile * np.sqrt(np.diag(observed_info_mean)), final_estimator + quantile * np.sqrt(np.diag(observed_info_mean))]).T\",\n \"= ['twosided'] * self.ntarget pivot = [] for m in\",\n \"/ scaling def objective(gs): p1 = -gs.T.dot(conjugate_arg) p2 = gs.T.dot(precision).dot(gs)\",\n \"+ p3 + p4 def grad(gs): p1 = -conjugate_arg +\",\n \"observed_target = self.observed_target[m] l, u = family.equal_tailed_interval(observed_target, alpha=1 - level)\",\n \"import log from numpy.linalg import norm, qr, inv, eig import\",\n \"= self._solve_randomized_problem(perturb=perturb, solve_args=solve_args) # initialize variables active_groups = [] #\",\n \"cond_cov self.cond_precision = cond_precision self.logdens_linear = logdens_linear return cond_mean, cond_cov,\",\n \"norm(soln[group_mask]) > tol * norm(soln): # is group g appreciably\",\n \"[(), (0,)]: _P = target_linear.T.dot(target_offset) * self.randomizer_prec _prec = prec_target\",\n \"# unpack the list XE = X[:, ordered_vars] # changed\",\n \"_r precs[m] = _prec self.precs = precs self.S = S\",\n \"1. / scaling def objective(gs): p1 = -gs.T.dot(conjugate_arg) p2 =\",\n \": dict, optional Arguments passed to solver. \\\"\\\"\\\" self.solve_args =\",\n \"(model on _setup_implied_gaussian) logdens_linear: (model on _setup_implied_gaussian) linear_part: like A_scaling\",\n \"active_dirs.values())] return block_diag(*[i for gp in to_diag for i in\",\n \"unit-norm coefficients unpenalized = [] # selected groups with no\",\n \"dispersion is None: # use Pearson's X^2 dispersion = ((y\",\n \"print(\\\"variable completed \\\", m) if alternatives[m] == 'twosided': pivot.append(2 *\",\n \"groups are ok There are a number of assumptions that\",\n \"the selective_MLE inherited from query because that is not adapted\",\n \"for k in range(grid.shape[0]): # in the usual D =\",\n \"observed_target)) + self.cond_mean) #direction for decomposing o eta = -self.prec_opt.dot(self.logdens_linear.dot(target_score_cov.T))\",\n \"np.sqrt(mean_diag) * 0.5 * np.std(Y) * np.sqrt(n / (n -\",\n \"alpha / 2.) intervals = np.vstack([final_estimator - quantile * np.sqrt(np.diag(observed_info_mean)),\",\n \"initial_soln = problem.solve(quad, **solve_args) initial_subgrad = -(self.loglike.smooth_objective(initial_soln, 'grad') + quad.objective(initial_soln,\",\n \"rather than a dictionary weights_np = np.array([w[1] for w in\",\n \"fit(self, solve_args={'tol': 1.e-12, 'min_its': 50}, perturb=None): # solve the randomized\",\n \"proposed_value if itercount % 4 == 0: step *= 2\",\n \"group is not 0\\\") # check for no skipped groups\",\n \"return block_diag(*[i for gp in to_diag for i in gp])\",\n \"query which has information to describe implied Gaussian. observed_target :\",\n \"self.penalty = rr.weighted_l1norm(weights=weights_np, lagrange=1.) else: self.penalty = rr.group_lasso(groups, weights=weights, lagrange=1.)\",\n \"target_score_cov, grid): \\\"\\\"\\\" Approximate the log of the reference density\",\n \"= [] # active group labels active_dirs = {} #\",\n \"self.penalty.weights[g] == 0: unpenalized.append(g) else: active_groups.append(g) active_dirs[g] = soln[group_mask] /\",\n \"targets of model including selected features Parameters ---------- query :\",\n \"range(grid.shape[0]): # in the usual D = N + Gamma\",\n \"in sorted_active_dirs.values()] V = block_diag(*Vs) # unpack the list Ls\",\n \"- soln))) + C unbiased_estimator = target_cov.dot(_prec).dot(observed_target) + target_cov.dot( _P\",\n \"target_score_cov, alternatives) = query.selected_targets(dispersion) self.observed_target = observed_target self.target_score_cov = target_score_cov\",\n \"1000) logW = (approx_fn(grid) - 0.5 * (grid - self.observed_target[m])\",\n \"all groups are size one, C will be an empty\",\n \"np.array([w[1] for w in sorted(weights.items())]) self.penalty = rr.weighted_l1norm(weights=weights_np, lagrange=1.) else:\",\n \"* dispersion return (observed_target, cov_target, crosscov_target_score, alternatives) class approximate_grid_inference(object): def\",\n \"np.linspace(observed_target[j] - 1.5 * _scale[j], observed_target[j] + 1.5 * _scale[j],\",\n \"results from that method. Parameters ---------- observed_target: from selected_targets target_cov:\",\n \"parameter) return result def log_reference(self, observed_target, target_cov, target_score_cov, grid): \\\"\\\"\\\"\",\n \"+ (target_linear.T.dot(target_linear) * self.randomizer_prec) - target_lin.T.dot( prec_opt).dot( target_lin) else: _P\",\n \"= self.log_reference(observed_target_uni, target_cov_uni, target_score_cov_uni, self.stat_grid[m]) if self.useIP == False: logW\",\n \"*= 0.5 if count >= 20: if not (np.isnan(proposed_value) or\",\n \"score, hence the minus sign target_linear = target_score_cov.T.dot(prec_target) target_offset =\",\n \"= N + Gamma theta.hat, # target_lin is \\\"something\\\" times\",\n \"continue as before self.observed_opt_state = np.hstack(ordered_opt) # gammas as array\",\n \"feasible point') # make sure proposal is a descent count\",\n \"g in sorted_active_dirs] L = block_diag(*Ls) # unpack the list\",\n \"2.) + 1. / ((con_offset - con_linear.dot(gs)) ** 2.))).dot(con_linear) if\",\n \"target_score_cov, alternatives) = self.selected_targets(dispersion) init_soln = self.observed_opt_state # just the\",\n \"range(self.ntarget): observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) prec_target =\",\n \"'less', 'greater'] parameter : np.array Hypothesized value for parameter --\",\n \"= np.ones(self.nfeature, np.bool) # mask of active features ordered_groups =\",\n \"will be an empty array return 0, 0, 0 else:\",\n \"self.observed_score_state[~overall] += self.loglike.smooth_objective(beta_bar, 'grad')[~overall] active_signs = np.sign(self.initial_soln) active = np.flatnonzero(active_signs)\",\n \"cur_grad proposed_value = objective(proposal) if proposed_value <= current_value: break step\",\n \"< 0: raise ValueError(\\\"Groups are not sorted\\\") # check integers\",\n \"o eta = -self.prec_opt.dot(self.logdens_linear.dot(target_score_cov.T)) implied_mean = np.asscalar(eta.T.dot(cond_mean_grid)) implied_cov = np.asscalar(eta.T.dot(self.cond_cov).dot(eta))\",\n \"== (0, 0): # when all groups are size one,\",\n \"not np.amin(agroups) == 0: raise ValueError(\\\"First group is not 0\\\")\",\n \"= block_diag(*Ls) # unpack the list XE = X[:, ordered_vars]\",\n \"None] * XE) QI = inv(Q) C = V.T.dot(QI).dot(L).dot(V) self.XE\",\n \"self.opt_linear.T.dot(prec.dot(self.opt_linear)) cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T).dot(prec) cond_mean = -logdens_linear.dot(self.observed_score_state\",\n \"\\\"\\\"\\\" to_diag = [[g] * (ug.size - 1) for (g,\",\n \"if proposed_value <= current_value: break step *= 0.5 if count\",\n \"= 1. / ((self.precs[m])[0, 0]) lower.append(l * var_target + observed_target)\",\n \"one, C will be an empty array return 0, 0,\",\n \"This needs to be updated to actually use the Jacobian\",\n \"observed_target self.target_score_cov = target_score_cov self.target_cov = target_cov self.init_soln = query.observed_opt_state\",\n \"** 2, quadratic=quadratic) n, p = X.shape mean_diag = np.mean((X\",\n \"/ 2. if useJacobian: p3 = - jacobian_grad_hess(gs, C, active_dirs)[0]\",\n \"lower, upper = [], [] for m in range(self.ntarget): #\",\n \"regreg.api as rr from .randomization import randomization from ..base import\",\n \"list Ls = [compute_Lg(g) for g in sorted_active_dirs] L =\",\n \"np.flatnonzero(active_signs) self.active = active def compute_Vg(ug): pg = ug.size #\",\n \"/ np.sqrt(n - 1) if randomizer_scale is None: randomizer_scale =\",\n \"a grid. \\\"\\\"\\\" if np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no\",\n \"observed_target_uni = (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) prec_target = 1.\",\n \"drop the first column else: Vg = np.zeros((1, 0)) #\",\n \"a function of gamma vector, active directions) \\\"\\\"\\\" to_diag =\",\n \"log of the reference density on a grid. \\\"\\\"\\\" if\",\n \"target and score of randomized query. solve_args : dict, optional\",\n \"group ordered_vars.extend(np.flatnonzero(group_mask)) if self.penalty.weights[g] == 0: unpenalized.append(g) else: active_groups.append(g) active_dirs[g]\",\n \"= beta_bar X, y = self.loglike.data W = self._W =\",\n \"# figure out size of g'th group if pg >\",\n \"None: ridge_term = np.std(Y) * np.sqrt(mean_diag) / np.sqrt(n - 1)\",\n \"self.groups == g soln = self.initial_soln # do not need\",\n \"lagrange=1.) else: self.penalty = rr.group_lasso(groups, weights=weights, lagrange=1.) # store groups\",\n \"# log Jacobian #J = log(evalues).sum() J = np.log(np.linalg.det(GammaMinus +\",\n \"np.eye(pg) return Lg sorted_active_dirs = collections.OrderedDict(sorted(active_dirs.items())) Vs = [compute_Vg(ug) for\",\n \"# unpack the list Ls = [compute_Lg(g) for g in\",\n \"\\\\bar{\\\\\\\\mu} precision: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} feasible_point: gamma's from fitting con_linear: linear part\",\n \"make sure groups looks sensible # log likelihood : quadratic\",\n \"_prec).dot(target_lin.T.dot(self.prec_opt).dot(target_off) - _P) _S = np.linalg.inv(_prec).dot(prec_target) S[m] = _S r[m]\",\n \"self.init_soln = query.observed_opt_state self.randomizer_prec = query.randomizer_prec self.score_offset = query.observed_score_state +\",\n \"= (self.observed_target[m]).reshape((1,)) target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) prec_target = 1. /\",\n \"# now we are collecting the directions and norms of\",\n \"+ C)) # inverse #GpC_inv = evectors.dot(np.diag(1 / evalues).dot(evectors.T)) GpC_inv\",\n \"initial_soln, initial_subgrad @staticmethod def gaussian(X, Y, groups, weights, sigma=1., quadratic=None,\",\n \"group labels ordered_vars = [] # indices \\\"ordered\\\" by sorting\",\n \"'min_its': 50}, perturb=None): # solve the randomized version of group\",\n \"ValueError('no target specified') prec_target = np.linalg.inv(target_cov) target_lin = - self.logdens_linear.dot(target_score_cov.T.dot(prec_target))\",\n \"observed_target, target_cov, target_score_cov, grid): \\\"\\\"\\\" Approximate the log of the\",\n \"active_dirs self._ordered_groups = ordered_groups # exception if no groups are\",\n \"= qr(Z) Vg = Q[:, 1:] # drop the first\",\n \"how the argument of the optimization density # depends on\",\n \"Gamma theta.hat, # target_lin is \\\"something\\\" times Gamma, # where\",\n \"- self.logdens_linear.dot(target_score_cov.T.dot(prec_target)) ref_hat = [] for k in range(grid.shape[0]): #\",\n \"np.exp(logW))) else: approx_fn = interp1d(self.stat_grid[m], log_ref, kind='quadratic', bounds_error=False, fill_value='extrapolate') grid\",\n \"observed_target = np.atleast_1d(observed_target) prec_target = inv(target_cov) prec_opt = self.cond_precision score_offset\",\n \"- step * cur_grad if np.all(con_offset - con_linear.dot(proposal) > 0):\",\n \"group_lasso makes about how groups are specified. Specifically, we assume\",\n \"elif alternatives[m] == 'greater': pivot.append(1 - _cdf) elif alternatives[m] ==\",\n \"= self.loglike.data W = self._W = self.loglike.saturated_loss.hessian(X.dot(beta_bar)) # all 1's\",\n \"= query.C self.active_dirs = query.active_dirs (observed_target, target_cov, target_score_cov, alternatives) =\",\n \"[] for m in range(self.ntarget): # construction of intervals from\",\n \"need to keep setting this if norm(soln[group_mask]) > tol *\",\n \"size 1 if use_lasso and groups.size == np.unique(groups).size: # need\",\n \"collecting the directions and norms of the active groups for\",\n \"to solver level: level of confidence intervals useC: whether to\",\n \"a group 4, there must also be at least one\",\n \"np.asarray(self.randomizer_prec).shape in [(), (0,)]: _P = target_linear.T.dot(target_offset) * self.randomizer_prec _prec\",\n \"there must also be at least one feature in group\",\n \"group lasso penalty (from regreg) # use regular lasso penalty\",\n \"= XE self.Q = Q self.QI = QI self.C =\",\n \"(use self.C defined in fitting) \\\"\\\"\\\" self._setup_implied_gaussian() # Calculate useful\",\n \"# indices \\\"ordered\\\" by sorting group labels tol = 1.e-20\",\n \"solve_args={'tol': 1.e-12}, level=0.9, useJacobian=True, dispersion=None): \\\"\\\"\\\"Do selective_MLE for group_lasso Note:\",\n \"self.observed_score_state = -opt_linearNoU.dot(_beta_unpenalized) self.observed_score_state[~overall] += self.loglike.smooth_objective(beta_bar, 'grad')[~overall] active_signs = np.sign(self.initial_soln)\",\n \"keys are group labels, values are unit-norm coefficients unpenalized =\",\n \"XE self.Q = Q self.QI = QI self.C = C\",\n \"self.randomizer_prec) - target_lin.T.dot( prec_opt).dot( target_lin) else: _P = target_linear.T.dot(self.randomizer_prec).dot(target_offset) _prec\",\n \"level=0.9, useJacobian=True, dispersion=None): \\\"\\\"\\\"Do selective_MLE for group_lasso Note: this masks\",\n \"groups, weights, ridge_term, randomizer, use_lasso=True, # should lasso solver be\",\n \"* var_target + observed_target) upper.append(u * var_target + observed_target) return\",\n \"(g, ug) in zip(gamma, active_dirs.values())] return block_diag(*[i for gp in\",\n \"2).sum(0)) if ridge_term is None: ridge_term = np.std(Y) * np.sqrt(mean_diag)\",\n \"self.XE Q = self.Q observed_target = restricted_estimator(self.loglike, self.ordered_vars, solve_args=solve_args) _score_linear\",\n \"that group_lasso makes about how groups are specified. Specifically, we\",\n \"alpha=1 - level) var_target = 1. / ((self.precs[m])[0, 0]) lower.append(l\",\n \"# depends on the score, not how the mean depends\",\n \"not how the mean depends on score, hence the minus\",\n \"summing matrix (gamma.size by C.shape[0]) S = block_diag(*[np.ones((1, ug.size -\",\n \"1.)) randomizer = randomization.isotropic_gaussian((p,), randomizer_scale) return group_lasso(loglike, groups, weights, ridge_term,\",\n \"- observed_target)) + self.cond_mean) #direction for decomposing o eta =\",\n \"ug.size # figure out size of g'th group if pg\",\n \"groups self._initial_omega = perturb # gaussian randomization self.randomizer = randomizer\",\n \"soln))) + C unbiased_estimator = target_cov.dot(_prec).dot(observed_target) + target_cov.dot( _P -\",\n \"-gs.T.dot(conjugate_arg) p2 = gs.T.dot(precision).dot(gs) / 2. if useJacobian: p3 =\",\n \"[] for m in range(self.ntarget): family = self._families[m] var_target =\",\n \"and have no gaps (e.g., if there is a group\",\n \"cur_grad = grad(current) # make sure proposal is feasible count\",\n \"is \\\"something\\\" times Gamma, # where \\\"something\\\" comes from implied\",\n \"1 - pvalues) alpha = 1 - level quantile =\",\n \"least one feature in group 3). This function checks the\",\n \"0)) # if the group is size one, the orthogonal\",\n \"# gamma's ordered by group labels ordered_vars = [] #\",\n \"future we might do this for them. \\\"\\\"\\\" # check\",\n \"collections.OrderedDict(sorted(active_dirs.items())) Vs = [compute_Vg(ug) for ug in sorted_active_dirs.values()] V =\",\n \"depends on the score, not how the mean depends on\",\n \"for itercount in range(nstep): cur_grad = grad(current) # make sure\",\n \"proposal current_value = proposed_value if itercount % 4 == 0:\",\n \"= current - step * cur_grad if np.all(con_offset - con_linear.dot(proposal)\",\n \"import restricted_estimator from ..algorithms.barrier_affine import solve_barrier_affine_py as solver from ..distributions.discrete_family\",\n \"# variables in active group ordered_vars.extend(np.flatnonzero(group_mask)) if self.penalty.weights[g] == 0:\",\n \"ndist from scipy.interpolate import interp1d import collections import numpy as\",\n \"\\\\\\\\Lambda V active_dirs: \\\"\\\"\\\" scaling = np.sqrt(np.diag(con_linear.dot(precision).dot(con_linear.T))) if feasible_point is\",\n \"np.sqrt(np.diag(observed_info_mean)), 'Zvalue': Z_scores, 'pvalue': pvalues, 'lower_confidence': intervals[:, 0], 'upper_confidence': intervals[:,\",\n \"np.all(con_offset - con_linear.dot(proposal) > 0): break step *= 0.5 if\",\n \"it finds any problems. Sorting feature groups is potentially tedious\",\n \"/ norm(soln[group_mask]) ordered_opt.append(norm(soln[group_mask])) else: overall[group_mask] = False self.selection_variable = {'directions':\",\n \"eig(GammaMinus + C) # log Jacobian #J = log(evalues).sum() J\",\n \"= self._approx_pivots(np.zeros_like(self.observed_target), alternatives=alternatives) lower, upper = self._approx_intervals(level=level) result = pd.DataFrame({'target':\",\n \"self.penalty.weights[g] * np.eye(pg) return Lg sorted_active_dirs = collections.OrderedDict(sorted(active_dirs.items())) Vs =\",\n \"\\\"\\\"\\\" Produce p-values and confidence intervals for targets of model\",\n \"(from regreg) # use regular lasso penalty if all groups\",\n \"#GpC_inv = evectors.dot(np.diag(1 / evalues).dot(evectors.T)) GpC_inv = np.linalg.inv(GammaMinus + C)\",\n \"= family.equal_tailed_interval(observed_target, alpha=1 - level) var_target = 1. / ((self.precs[m])[0,\",\n \"n, p = X.shape mean_diag = np.mean((X ** 2).sum(0)) if\",\n \"= Q self.QI = QI self.C = C U =\",\n \"crosscov_target_score = _score_linear.dot(self.QI).T * dispersion return (observed_target, cov_target, crosscov_target_score, alternatives)\",\n \"solve_args result, inverse_info = query.selective_MLE(dispersion=dispersion)[:2] self.linear_part = query.linear_part self.offset =\",\n \"\\\"ordered\\\" by sorting group labels tol = 1.e-20 _, self.randomizer_prec\",\n \"in zip(gamma, active_dirs.values())] return block_diag(*[i for gp in to_diag for\",\n \"= opt_offset self.ordered_vars = ordered_vars self.linear_part = -np.eye(self.observed_opt_state.shape[0]) self.offset =\",\n \"already run the fit method since this uses results from\",\n \"Parameters ---------- observed_target: from selected_targets target_cov: from selected_targets target_cov_score: from\",\n \"'lower_confidence': intervals[:, 0], 'upper_confidence': intervals[:, 1], 'unbiased': unbiased_estimator}) return result,\",\n \"- con_linear.dot(gs))) if useJacobian: p3 = - jacobian_grad_hess(gs, C, active_dirs)[1]\",\n \"+= self.loglike.smooth_objective(beta_bar, 'grad')[~overall] active_signs = np.sign(self.initial_soln) active = np.flatnonzero(active_signs) self.active\",\n \"cond_mean = -logdens_linear.dot(self.observed_score_state + self.opt_offset) self.cond_mean = cond_mean self.cond_cov =\",\n \"in future we might do this for them. \\\"\\\"\\\" #\",\n \"not np.issubdtype(agroups.dtype, np.integer): raise TypeError(\\\"Groups are not integers\\\") # check\",\n \"query, dispersion, solve_args={'tol': 1.e-12}, useIP=True): \\\"\\\"\\\" Produce p-values and confidence\",\n \"# eigendecomposition #evalues, evectors = eig(GammaMinus + C) # log\",\n \"target_cov.dot(_P - target_lin.T.dot(prec_opt).dot(target_off)) conjugate_arg = prec_opt.dot(cond_mean) val, soln, hess =\",\n \"= -S.dot(np.multiply(GpC_inv, GpC_inv.T).dot(S.T)) return J, grad_J, hess_J def _check_groups(groups): \\\"\\\"\\\"Make\",\n \"weights, ridge_term, randomizer, use_lasso, perturb) def _setup_implied_gaussian(self): _, prec =\",\n \"2 / var_target) logW -= logW.max() self._families.append(discrete_family(grid, np.exp(logW))) def _approx_pivots(self,\",\n \"solve the randomized version of group lasso (self.initial_soln, self.initial_subgrad) =\",\n \"# g is group label group_mask = self.groups == g\",\n \"/ target_cov_uni target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) target_linear = target_score_cov_uni.T.dot(prec_target)\",\n \"specified. Specifically, we assume that `groups` is a 1-d array_like\",\n \"optimization variables # vary with target # logdens_linear determines how\",\n \"beta_bar = np.zeros(self.nfeature) beta_bar[overall] = _beta_unpenalized # refit OLS beta\",\n \"quad = rr.identity_quadratic(self.ridge_term, 0, -self._initial_omega, 0) problem = rr.simple_problem(self.loglike, self.penalty)\",\n \"cond_precision self.logdens_linear = logdens_linear return cond_mean, cond_cov, cond_precision, logdens_linear def\",\n \"of active features ordered_groups = [] # active group labels\",\n \"= XE.T.dot(self._W[:, None] * XE) QI = inv(Q) C =\",\n \"target_linear.T.dot(target_offset) * self.randomizer_prec _r = (1. / _prec).dot(target_lin.T.dot(self.prec_opt).dot(target_off) - _P)\",\n \"by group labels ordered_vars = [] # indices \\\"ordered\\\" by\",\n \"function of gamma vector, active directions) \\\"\\\"\\\" to_diag = [[g]\",\n \"(ug.size - 1) for (g, ug) in zip(gamma, active_dirs.values())] return\",\n \"solver level: level of confidence intervals useC: whether to use\",\n \"values are unit-norm coefficients unpenalized = [] # selected groups\",\n \"/ (con_offset - con_linear.dot(gs)) return p1 + p2 + p3\",\n \"20: if not (np.isnan(proposed_value) or np.isnan(current_value)): break else: raise ValueError('value\",\n \"pvalues) alpha = 1 - level quantile = ndist.ppf(1 -\",\n \"= 4 * np.sqrt(np.diag(inverse_info)) if useIP == False: ngrid =\",\n \"including selected features Parameters ---------- alternatives : [str], optional Sequence\",\n \"is target_score_cov.T.dot(prec_target) num_opt = self.prec_opt.shape[0] num_con = self.linear_part.shape[0] cond_mean_grid =\",\n \"\\\"\\\"\\\" self.solve_args = solve_args result, inverse_info = query.selective_MLE(dispersion=dispersion)[:2] self.linear_part =\",\n \"import regreg.api as rr from .randomization import randomization from ..base\",\n \"pivot.append(2 * min(_cdf, 1 - _cdf)) elif alternatives[m] == 'greater':\",\n \"refit OLS beta with zeros self._beta_full = beta_bar X, y\",\n \"in [(), (0,)]: raise ValueError('no target specified') prec_target = np.linalg.inv(target_cov)\",\n \"target_lin = - self.logdens_linear.dot(target_score_cov.T.dot(prec_target)) ref_hat = [] for k in\",\n \"randomizer_scale=None): loglike = rr.glm.gaussian(X, Y, coef=1. / sigma ** 2,\",\n \"/ ((con_offset - con_linear.dot(gs)) ** 2.))).dot(con_linear) if useJacobian: p2 =\",\n \"= query.cond_mean self.prec_opt = np.linalg.inv(query.cond_cov) self.cond_cov = query.cond_cov self.C =\",\n \"should lasso solver be used where applicable - defaults to\",\n \"'active_groups': active_groups} # kind of redundant with keys of active_dirs\",\n \"target_score_cov_uni, self.stat_grid[m]) if self.useIP == False: logW = (log_ref -\",\n \"useJacobian: p2 = - jacobian_grad_hess(gs, C, active_dirs)[2] else: p2 =\",\n \"else: GammaMinus = calc_GammaMinus(gamma, active_dirs) # eigendecomposition #evalues, evectors =\",\n \"array return 0, 0, 0 else: GammaMinus = calc_GammaMinus(gamma, active_dirs)\",\n \"target_lin.T.dot(prec_opt) observed_info_natural = _prec + L.dot(target_lin) - L.dot(hess.dot(L.T)) observed_info_mean =\",\n \"conjugate_arg: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} \\\\bar{\\\\\\\\mu} precision: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} feasible_point: gamma's from fitting con_linear:\",\n \"= -XE.T.dot(self._W[:, None] * X).T alternatives = ['twosided'] * len(self.active)\",\n \"== 0: return np.sign(soln), soln # otherwise continue as before\",\n \"self.loglike.saturated_loss.mean_function( XE.dot(observed_target))) ** 2 / self._W).sum() / (n - XE.shape[1])\",\n \"randomizer def fit(self, solve_args={'tol': 1.e-12, 'min_its': 50}, perturb=None): # solve\",\n \"be used when applicable - defaults to True randomizer_scale=None): loglike\",\n \"= self.linear_part.shape[0] cond_mean_grid = (target_lin.dot(np.atleast_1d(grid[k] - observed_target)) + self.cond_mean) #direction\",\n \"in [\\\"twosided\\\", \\\"less\\\", \\\"greater\\\"]') return pivot def _approx_intervals(self, level=0.9): if\",\n \"if not np.all(parameter == 0): result.insert(4, 'pivot', pivots) result.insert(5, 'parameter',\",\n \"-(self.loglike.smooth_objective(initial_soln, 'grad') + quad.objective(initial_soln, 'grad')) return initial_soln, initial_subgrad @staticmethod def\",\n \"np.linspace(self.stat_grid[m].min(), self.stat_grid[m].max(), 1000) logW = (approx_fn(grid) - 0.5 * (grid\",\n \"of active_dirs self._ordered_groups = ordered_groups # exception if no groups\",\n \"block_diag(*Ls) # unpack the list XE = X[:, ordered_vars] #\",\n \"self.opt_offset # target_lin determines how the conditional mean of optimization\",\n \"as rr from .randomization import randomization from ..base import restricted_estimator\",\n \"[(), (0,)]: raise ValueError('no target specified') observed_target = np.atleast_1d(observed_target) prec_target\",\n \"group label group_mask = self.groups == g soln = self.initial_soln\",\n \"(1,1)), eta.T.dot(self.init_soln), A.reshape((A.shape[0],1)), b, **self.solve_args) gamma_ = _A.dot(soln) + R.dot(self.init_soln)\",\n \"integers that are sorted in increasing order, start at 0,\",\n \"solver. \\\"\\\"\\\" self.solve_args = solve_args result, inverse_info = query.selective_MLE(dispersion=dispersion)[:2] self.linear_part\",\n \"Z_scores = final_estimator / np.sqrt(np.diag(observed_info_mean)) pvalues = ndist.cdf(Z_scores) pvalues =\",\n \"is feasible count = 0 while True: count += 1\",\n \"variables active_groups = [] # active group labels active_dirs =\",\n \"..base import restricted_estimator from ..algorithms.barrier_affine import solve_barrier_affine_py as solver from\",\n \"con_linear.T.dot(np.diag(-1. / ((scaling + con_offset - con_linear.dot(gs)) ** 2.) +\",\n \"calc_GammaMinus(gamma, active_dirs): \\\"\\\"\\\"Calculate Gamma^minus (as a function of gamma vector,\",\n \"figure out size of g'th group if pg > 1:\",\n \"tol = 1.e-20 _, self.randomizer_prec = self.randomizer.cov_prec # now we\",\n \"self.loglike.saturated_loss.hessian(X.dot(beta_bar)) # all 1's for LS opt_linearNoU = np.dot(X.T, X[:,\",\n \"self.selected_targets(dispersion) init_soln = self.observed_opt_state # just the gammas cond_mean =\",\n \"query.offset self.logdens_linear = query.logdens_linear self.cond_mean = query.cond_mean self.prec_opt = np.linalg.inv(query.cond_cov)\",\n \"block_diag(*[i for gp in to_diag for i in gp]) def\",\n \"for the group_lasso. Also, assumes you have already run the\",\n \"= _prec self.precs = precs self.S = S self.r =\",\n \"_cdf = family.cdf((mean[0] - self.observed_target[m]) / var_target, x=self.observed_target[m]) print(\\\"variable completed\",\n \"self._initial_omega = self.randomizer.sample() quad = rr.identity_quadratic(self.ridge_term, 0, -self._initial_omega, 0) problem\",\n \"var_target = 1. / ((self.precs[m])[0, 0]) mean = self.S[m].dot(mean_parameter[m].reshape((1,))) +\",\n \"= self.loglike.shape[0] # ridge parameter self.ridge_term = ridge_term # group\",\n \"target_off = cond_mean - target_lin.dot(observed_target) if np.asarray(self.randomizer_prec).shape in [(), (0,)]:\",\n \"+ observed_target) upper.append(u * var_target + observed_target) return np.asarray(lower), np.asarray(upper)\",\n \"\\\"\\\"\\\" scaling = np.sqrt(np.diag(con_linear.dot(precision).dot(con_linear.T))) if feasible_point is None: feasible_point =\",\n \"not hasattr(self, \\\"_families\\\"): self._construct_families() lower, upper = [], [] for\",\n \"(con_offset - con_linear.dot(gs)) return p1 + p2 + p3 +\",\n \"if C.shape == (0, 0): # when all groups are\",\n \"evalues).dot(evectors.T)) GpC_inv = np.linalg.inv(GammaMinus + C) # summing matrix (gamma.size\",\n \"about how groups are specified. Specifically, we assume that `groups`\",\n \"_r = (1. / _prec).dot(target_lin.T.dot(self.prec_opt).dot(target_off) - _P) _S = np.linalg.inv(_prec).dot(prec_target)\",\n \"= useIP def summary(self, alternatives=None, parameter=None, level=0.9): \\\"\\\"\\\" Produce p-values\",\n \"= feasible_point current_value = np.inf for itercount in range(nstep): cur_grad\",\n \"the orthogonal complement is empty return Vg def compute_Lg(g): pg\",\n \"the list XE = X[:, ordered_vars] # changed to ordered_vars\",\n \"\\\"\\\"\\\" Calculate the log-Jacobian (scalar), gradient (gamma.size vector) and hessian\",\n \"alternatives=None, parameter=None, level=0.9): \\\"\\\"\\\" Produce p-values and confidence intervals for\",\n \"/ ((con_offset - con_linear.dot(gs)) / scaling)).sum() return p1 + p2\",\n \"target_cov_uni = (np.diag(self.target_cov)[m]).reshape((1, 1)) target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p)) var_target\",\n \"before self.observed_opt_state = np.hstack(ordered_opt) # gammas as array _beta_unpenalized =\",\n \"var_target) logW -= logW.max() self._families.append(discrete_family(grid, np.exp(logW))) def _approx_pivots(self, mean_parameter, alternatives=None):\",\n \"p3 = 0 p4 = 1. / (con_offset - con_linear.dot(gs))\",\n \"# summing matrix (gamma.size by C.shape[0]) S = block_diag(*[np.ones((1, ug.size\",\n \"= log(evalues).sum() J = np.log(np.linalg.det(GammaMinus + C)) # inverse #GpC_inv\",\n \"sure that the user-specific groups are ok There are a\",\n \"self._families[m] observed_target = self.observed_target[m] l, u = family.equal_tailed_interval(observed_target, alpha=1 -\",\n \"# refit OLS on E overall, solve_args=solve_args) beta_bar = np.zeros(self.nfeature)\",\n \"final_estimator, 'SE': np.sqrt(np.diag(observed_info_mean)), 'Zvalue': Z_scores, 'pvalue': pvalues, 'lower_confidence': intervals[:, 0],\",\n \"_prec = prec_target + (target_linear.T.dot(self.randomizer_prec).dot(target_linear)) - target_lin.T.dot( prec_opt).dot(target_lin) C =\",\n \":].reshape((1, p)) var_target = 1. / ((self.precs[m])[0, 0]) log_ref =\",\n \"/ (n - 1.)) randomizer = randomization.isotropic_gaussian((p,), randomizer_scale) return group_lasso(loglike,\",\n \"# target_lin is \\\"something\\\" times Gamma, # where \\\"something\\\" comes\",\n \"= solver(np.asarray([conjugate_arg]), np.reshape(implied_prec, (1,1)), eta.T.dot(self.init_soln), A.reshape((A.shape[0],1)), b, **self.solve_args) gamma_ =\",\n \"from .randomization import randomization from ..base import restricted_estimator from ..algorithms.barrier_affine\",\n \"sorted_active_dirs.values()] V = block_diag(*Vs) # unpack the list Ls =\",\n \"norms of the active groups for g in sorted(np.unique(self.groups)): #\",\n \"quantile * np.sqrt(np.diag(observed_info_mean)), final_estimator + quantile * np.sqrt(np.diag(observed_info_mean))]).T log_ref =\",\n \"use_lasso and groups.size == np.unique(groups).size: # need to provide weights\",\n \"quad.objective(initial_soln, 'grad')) return initial_soln, initial_subgrad @staticmethod def gaussian(X, Y, groups,\",\n \"unbiased_estimator = target_cov.dot(_prec).dot(observed_target) + target_cov.dot( _P - target_lin.T.dot(prec_opt).dot(target_off)) L =\",\n \"= self._approx_intervals(level=level) result = pd.DataFrame({'target': self.observed_target, 'pvalue': pvalues, 'lower_confidence': lower,\",\n \"L = target_lin.T.dot(prec_opt) observed_info_natural = _prec + L.dot(target_lin) - L.dot(hess.dot(L.T))\",\n \"= [], [] for m in range(self.ntarget): # construction of\",\n \"run usual lasso solver... (see existing code)... initial_soln = problem.solve(quad,\",\n \"current = proposal current_value = proposed_value break current = proposal\",\n \"XE) QI = inv(Q) C = V.T.dot(QI).dot(L).dot(V) self.XE = XE\",\n \"self.cond_precision = cond_precision self.logdens_linear = logdens_linear return cond_mean, cond_cov, cond_precision,\",\n \"target_lin = -self.logdens_linear.dot(target_linear) target_off = (self.cond_mean - target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],)) _prec =\",\n \"{'directions': active_dirs, 'active_groups': active_groups} # kind of redundant with keys\",\n \"norm, qr, inv, eig import pandas as pd import regreg.api\",\n \"confidence intervals for targets of model including selected features Parameters\",\n \"from scipy.stats import norm as ndist from scipy.interpolate import interp1d\",\n \"= query.observed_score_state + query.opt_offset self.ntarget = ntarget = target_cov.shape[0] _scale\",\n \"= np.linspace(self.stat_grid[m].min(), self.stat_grid[m].max(), 1000) logW = (approx_fn(grid) - 0.5 *\",\n \"check sorted if np.any(agroups[:-1] > agroups[1:]) < 0: raise ValueError(\\\"Groups\",\n \"= final_estimator / np.sqrt(np.diag(observed_info_mean)) pvalues = ndist.cdf(Z_scores) pvalues = 2\",\n \"for barrier function C: V^T Q^{-1} \\\\\\\\Lambda V active_dirs: \\\"\\\"\\\"\",\n \"= 0 return p1 + p2 current = feasible_point current_value\",\n \"of model including selected features Parameters ---------- alternatives : [str],\",\n \"Ls = [compute_Lg(g) for g in sorted_active_dirs] L = block_diag(*Ls)\",\n \"- ((conjugate_arg ** 2) * implied_cov)/ 2. + log_jacob[0]) return\",\n \"Calculate the log-Jacobian (scalar), gradient (gamma.size vector) and hessian (gamma.size\",\n \"perturbation if supplied if perturb is not None: self._initial_omega =\",\n \"inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T).dot(prec) cond_mean = -logdens_linear.dot(self.observed_score_state + self.opt_offset) self.cond_mean\",\n \"+= 1 proposal = current - step * cur_grad proposed_value\",\n \"changed to ordered_vars Q = XE.T.dot(self._W[:, None] * XE) QI\",\n \"elif alternatives[m] == 'less': pivot.append(_cdf) else: raise ValueError('alternative should be\",\n \"than a dictionary weights_np = np.array([w[1] for w in sorted(weights.items())])\",\n \"else: cond_precision = self.opt_linear.T.dot(prec.dot(self.opt_linear)) cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T).dot(prec)\",\n \"= perturb if self._initial_omega is None: self._initial_omega = self.randomizer.sample() quad\",\n \"1: raise ValueError(\\\"Groups are not a 1D array_like\\\") # check\",\n \"score of randomized query. solve_args : dict, optional Arguments passed\",\n \"= grad(current) # make sure proposal is feasible count =\",\n \"selective_MLE inherited from query because that is not adapted for\",\n \"+ p4 def grad(gs): p1 = -conjugate_arg + precision.dot(gs) p2\",\n \"'upper_confidence': intervals[:, 1], 'unbiased': unbiased_estimator}) return result, observed_info_mean, log_ref def\",\n \"= self.randomizer.cov_prec # now we are collecting the directions and\",\n \"if supplied if perturb is not None: self._initial_omega = perturb\",\n \"Z_scores, 'pvalue': pvalues, 'lower_confidence': intervals[:, 0], 'upper_confidence': intervals[:, 1], 'unbiased':\",\n \"to describe implied Gaussian. observed_target : ndarray Observed estimate of\",\n \"solve_args={'tol': 1.e-15, 'min_its': 100}): # take a new perturbation if\",\n \"= self.observed_target[m] l, u = family.equal_tailed_interval(observed_target, alpha=1 - level) var_target\",\n \"_prec + L.dot(target_lin) - L.dot(hess.dot(L.T)) observed_info_mean = target_cov.dot(observed_info_natural.dot(target_cov)) Z_scores =\",\n \"- 0.5 * (self.stat_grid[m] - self.observed_target[m]) ** 2 / var_target)\",\n \"and in future we might do this for them. \\\"\\\"\\\"\",\n \"cond_cov = inv(cond_precision) logdens_linear = cond_cov.dot(self.opt_linear.T) * prec else: cond_precision\",\n \"compute_Vg(ug): pg = ug.size # figure out size of g'th\",\n \"def _solve_randomized_problem(self, perturb=None, solve_args={'tol': 1.e-15, 'min_its': 100}): # take a\",\n \"tedious for the user and in future we might do\",\n \"useIP == False: ngrid = 1000 self.stat_grid = np.zeros((ntarget, ngrid))\",\n \"* self.randomizer_prec) - target_lin.T.dot( self.prec_opt).dot(target_lin) _P = target_linear.T.dot(target_offset) * self.randomizer_prec\",\n \"dispersion=None): \\\"\\\"\\\"Do selective_MLE for group_lasso Note: this masks the selective_MLE\",\n \"_A.dot(eta.T) A = self.linear_part.dot(_A).reshape((-1,)) b = self.offset-self.linear_part.dot(R).dot(self.init_soln) conjugate_arg = implied_mean\",\n \"prec_target = 1. / target_cov_uni target_score_cov_uni = self.target_score_cov[m, :].reshape((1, p))\",\n \"are selected if len(self.selection_variable['active_groups']) == 0: return np.sign(soln), soln #\",\n \"*= 2 hess = inv(precision + barrier_hessian(current)) return current_value, current,\",\n \"True randomizer_scale=None): loglike = rr.glm.gaussian(X, Y, coef=1. / sigma **\",\n \"2.) intervals = np.vstack([final_estimator - quantile * np.sqrt(np.diag(observed_info_mean)), final_estimator +\",\n \"_S r[m] = _r precs[m] = _prec self.precs = precs\",\n \"feasible_point is None: feasible_point = 1. / scaling def objective(gs):\",\n \"strings describing the alternatives, should be values of ['twosided', 'less',\",\n \"- con_linear.dot(gs)) return p1 + p2 + p3 + p4\",\n \"= self.offset if np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no target\",\n \"pg = ug.size # figure out size of g'th group\",\n \"= np.asscalar(eta.T.dot(self.cond_cov).dot(eta)) implied_prec = 1./implied_cov _A = self.cond_cov.dot(eta) * implied_prec\",\n \"query.opt_linear self.useIP = useIP def summary(self, alternatives=None, parameter=None, level=0.9): \\\"\\\"\\\"\",\n \"= active_dirs[g].size Lg = self.penalty.weights[g] * np.eye(pg) return Lg sorted_active_dirs\",\n \"determines how the argument of the optimization density # depends\",\n \"* np.sqrt(np.diag(observed_info_mean)), final_estimator + quantile * np.sqrt(np.diag(observed_info_mean))]).T log_ref = val\",\n \"observed_info_mean, log_ref def selected_targets(self, dispersion=None, solve_args={'tol': 1.e-12, 'min_its': 50}): X,\",\n \"result def log_reference(self, observed_target, target_cov, target_score_cov, grid): \\\"\\\"\\\" Approximate the\",\n \"self.linear_part offset = self.offset if np.asarray(observed_target).shape in [(), (0,)]: raise\",\n \"start at 0, and have no gaps (e.g., if there\",\n \"[], [] for m in range(self.ntarget): # construction of intervals\",\n \"self.prec_opt.shape[0] num_con = self.linear_part.shape[0] cond_mean_grid = (target_lin.dot(np.atleast_1d(grid[k] - observed_target)) +\",\n \"= ['twosided'] * len(self.active) if dispersion is None: # use\",\n \"self.solve_args = solve_args result, inverse_info = query.selective_MLE(dispersion=dispersion)[:2] self.linear_part = query.linear_part\",\n \"= (self.score_offset - target_linear.dot(observed_target_uni)).reshape( (target_linear.shape[0],)) target_lin = -self.logdens_linear.dot(target_linear) target_off =\",\n \"QI = inv(Q) C = V.T.dot(QI).dot(L).dot(V) self.XE = XE self.Q\",\n \"to be updated to actually use the Jacobian information (in\",\n \"from ..base import restricted_estimator from ..algorithms.barrier_affine import solve_barrier_affine_py as solver\",\n \"target_cov, target_score_cov, alternatives) = query.selected_targets(dispersion) self.observed_target = observed_target self.target_score_cov =\",\n \"cond_cov.dot(self.opt_linear.T).dot(prec) cond_mean = -logdens_linear.dot(self.observed_score_state + self.opt_offset) self.cond_mean = cond_mean self.cond_cov\",\n \"directions) \\\"\\\"\\\" to_diag = [[g] * (ug.size - 1) for\",\n \"result.insert(4, 'pivot', pivots) result.insert(5, 'parameter', parameter) return result def log_reference(self,\",\n \"target_lin.T.dot( prec_opt).dot( target_lin) else: _P = target_linear.T.dot(self.randomizer_prec).dot(target_offset) _prec = prec_target\",\n \"C = V.T.dot(QI).dot(L).dot(V) self.XE = XE self.Q = Q self.QI\",\n \"= target_cov.dot(_prec).dot(observed_target) \\\\ + target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean - soln))) + C unbiased_estimator\",\n \"+= self.ridge_term opt_offset = self.initial_subgrad self.observed_score_state = -opt_linearNoU.dot(_beta_unpenalized) self.observed_score_state[~overall] +=\",\n \"logW = (approx_fn(grid) - 0.5 * (grid - self.observed_target[m]) **\",\n \"that are sorted in increasing order, start at 0, and\",\n \"problem = rr.simple_problem(self.loglike, self.penalty) # if all groups are size\",\n \"import norm as ndist from scipy.interpolate import interp1d import collections\",\n \"'pvalue': pvalues, 'lower_confidence': intervals[:, 0], 'upper_confidence': intervals[:, 1], 'unbiased': unbiased_estimator})\",\n \"Y, coef=1. / sigma ** 2, quadratic=quadratic) n, p =\",\n \"value for parameter -- defaults to 0. level : float\",\n \"of optimization variables cond_mean: conditional mean of optimization variables (model\",\n \"feasible_point: gamma's from fitting con_linear: linear part of affine constraint\",\n \"# ridge parameter self.ridge_term = ridge_term # group lasso penalty\",\n \"precs[m] = _prec self.precs = precs self.S = S self.r\",\n \"- step * cur_grad proposed_value = objective(proposal) if proposed_value <=\",\n \"- target_lin.T.dot( self.prec_opt).dot(target_lin) _P = target_linear.T.dot(target_offset) * self.randomizer_prec _r =\",\n \"def objective(gs): p1 = -gs.T.dot(conjugate_arg) p2 = gs.T.dot(precision).dot(gs) / 2.\",\n \"step *= 0.5 if count >= 20: if not (np.isnan(proposed_value)\",\n \"* _scale[j], observed_target[j] + 1.5 * _scale[j], num=ngrid) self.opt_linear =\",\n \"XE = self.XE Q = self.Q observed_target = restricted_estimator(self.loglike, self.ordered_vars,\",\n \"useJacobian=True, step=1, nstep=2000, min_its=500, tol=1.e-12): \\\"\\\"\\\" This needs to be\",\n \"empty return Vg def compute_Lg(g): pg = active_dirs[g].size Lg =\",\n \"perturb # gaussian randomization self.randomizer = randomizer def fit(self, solve_args={'tol':\",\n \"C) # log Jacobian #J = log(evalues).sum() J = np.log(np.linalg.det(GammaMinus\",\n \"C, active_dirs, useJacobian=True, step=1, nstep=2000, min_its=500, tol=1.e-12): \\\"\\\"\\\" This needs\",\n \"target # logdens_linear determines how the argument of the optimization\",\n \"= pd.DataFrame({'target': self.observed_target, 'pvalue': pvalues, 'lower_confidence': lower, 'upper_confidence': upper}) if\",\n \"mean = self.S[m].dot(mean_parameter[m].reshape((1,))) + self.r[m] _cdf = family.cdf((mean[0] - self.observed_target[m])\",\n \"groups as a class variable since the non-group lasso doesn't\",\n \"arguments conjugate_arg: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} \\\\bar{\\\\\\\\mu} precision: \\\\\\\\bar{\\\\\\\\Sigma}^{-1} feasible_point: gamma's from fitting\",\n \"= self.Q observed_target = restricted_estimator(self.loglike, self.ordered_vars, solve_args=solve_args) _score_linear = -XE.T.dot(self._W[:,\",\n \"model including selected features Parameters ---------- alternatives : [str], optional\",\n \"use regular lasso penalty if all groups are size 1\",\n \"target_lin.T.dot(prec_opt).dot(target_off)) conjugate_arg = prec_opt.dot(cond_mean) val, soln, hess = solve_barrier_affine_jacobian_py(conjugate_arg, prec_opt,\",\n \"observed_target = restricted_estimator(self.loglike, self.ordered_vars, solve_args=solve_args) _score_linear = -XE.T.dot(self._W[:, None] *\",\n \"2, quadratic=quadratic) n, p = X.shape mean_diag = np.mean((X **\",\n \"self.ntarget pivot = [] for m in range(self.ntarget): family =\",\n \"np.atleast_1d(observed_target) prec_target = inv(target_cov) prec_opt = self.cond_precision score_offset = self.observed_score_state\",\n \"con_linear.dot(gs)) ** 2.) + 1. / ((con_offset - con_linear.dot(gs)) **\",\n \"agroups[1:]) < 0: raise ValueError(\\\"Groups are not sorted\\\") # check\",\n \"def jacobian_grad_hess(gamma, C, active_dirs): \\\"\\\"\\\" Calculate the log-Jacobian (scalar), gradient\",\n \"have already run the fit method since this uses results\",\n \"+ p4 def barrier_hessian(gs): # contribution of barrier and jacobian\",\n \"solve_args={'tol': 1.e-12, 'min_its': 50}): X, y = self.loglike.data n, p\",\n \"and groups.size == np.unique(groups).size: # need to provide weights an\",\n \"barrier function con_offset: offset part of affine constraint used for\",\n \"block_diag(*[np.ones((1, ug.size - 1)) for ug in active_dirs.values()]) # gradient\",\n \"if use_lasso and groups.size == np.unique(groups).size: # need to provide\",\n \"from selected_targets target_cov: from selected_targets target_cov_score: from selected_targets init_soln: (opt_state)\",\n \"var_target = 1. / ((self.precs[m])[0, 0]) lower.append(l * var_target +\",\n \"overall, solve_args=solve_args) beta_bar = np.zeros(self.nfeature) beta_bar[overall] = _beta_unpenalized # refit\",\n \"# logdens_linear determines how the argument of the optimization density\",\n \"(0,)]: raise ValueError('no target specified') prec_target = np.linalg.inv(target_cov) target_lin =\",\n \"1. / (con_offset - con_linear.dot(gs)) return p1 + p2 +\",\n \"self.Q = Q self.QI = QI self.C = C U\",\n \"[] # active group labels sorted by label ordered_opt =\",\n \"(observed_target, target_cov, target_score_cov, alternatives) = self.selected_targets(dispersion) init_soln = self.observed_opt_state #\",\n \"family.cdf((mean[0] - self.observed_target[m]) / var_target, x=self.observed_target[m]) print(\\\"variable completed \\\", m)\",\n \"\\\"greater\\\"]') return pivot def _approx_intervals(self, level=0.9): if not hasattr(self, \\\"_families\\\"):\",\n \"r = {} p = self.target_score_cov.shape[1] for m in range(self.ntarget):\",\n \"raise ValueError('no target specified') observed_target = np.atleast_1d(observed_target) prec_target = inv(target_cov)\",\n \"for LS opt_linearNoU = np.dot(X.T, X[:, ordered_vars] * W[:, np.newaxis])\",\n \"randomizer_scale) return group_lasso(loglike, groups, weights, ridge_term, randomizer, use_lasso, perturb) def\",\n \"of the active groups for g in sorted(np.unique(self.groups)): # g\",\n \"is a group 2 and a group 4, there must\",\n \"decrease is small if np.fabs(current_value - proposed_value) < tol *\",\n \"pvalues = ndist.cdf(Z_scores) pvalues = 2 * np.minimum(pvalues, 1 -\",\n \"in sorted_active_dirs] L = block_diag(*Ls) # unpack the list XE\",\n \"offset: like b_scaling (from lasso) solve_args: passed on to solver\",\n \"= target_cov.dot(_prec).dot(observed_target) + target_cov.dot( _P - target_lin.T.dot(prec_opt).dot(target_off)) L = target_lin.T.dot(prec_opt)\",\n \"group is size one, the orthogonal complement is empty return\",\n \"print_function from scipy.linalg import block_diag from scipy.stats import norm as\",\n \"_score_linear.dot(self.QI).T * dispersion return (observed_target, cov_target, crosscov_target_score, alternatives) class approximate_grid_inference(object):\",\n \"= perturb # gaussian randomization self.randomizer = randomizer def fit(self,\",\n \"alternatives) class approximate_grid_inference(object): def __init__(self, query, dispersion, solve_args={'tol': 1.e-12}, useIP=True):\",\n \"all groups are size 1 if use_lasso and groups.size ==\",\n \"target_score_cov.T.dot(prec_target) target_offset = score_offset - target_linear.dot(observed_target) target_lin = - logdens_linear.dot(target_linear)\",\n \"+ target_cov.dot(target_lin.T.dot(prec_opt.dot(cond_mean - soln))) + C unbiased_estimator = target_cov.dot(_prec).dot(observed_target) +\",\n \"covariance of target and score of randomized query. solve_args :\",\n \"in range(grid.shape[0]): # in the usual D = N +\",\n \"* min(_cdf, 1 - _cdf)) elif alternatives[m] == 'greater': pivot.append(1\",\n \"zip(gamma, active_dirs.values())] return block_diag(*[i for gp in to_diag for i\",\n \"group scheme and raises an exception if it finds any\",\n \"\\\", m) if alternatives[m] == 'twosided': pivot.append(2 * min(_cdf, 1\",\n \"= (approx_fn(grid) - 0.5 * (grid - self.observed_target[m]) ** 2\",\n \"are size 1, set up lasso penalty and run usual\",\n \"usual lasso solver... (see existing code)... initial_soln = problem.solve(quad, **solve_args)\",\n \"contribution of barrier and jacobian to hessian p1 = con_linear.T.dot(np.diag(-1.\",\n \"while True: count += 1 proposal = current - step\",\n \"= proposal current_value = proposed_value if itercount % 4 ==\",\n \"if np.asarray(observed_target).shape in [(), (0,)]: raise ValueError('no target specified') observed_target\",\n \"hence the minus sign target_linear = target_score_cov.T.dot(prec_target) target_offset = score_offset\",\n \"-XE.T.dot(self._W[:, None] * X).T alternatives = ['twosided'] * len(self.active) if\",\n \"self.C = query.C self.active_dirs = query.active_dirs (observed_target, target_cov, target_score_cov, alternatives)\",\n \"implied_prec = 1./implied_cov _A = self.cond_cov.dot(eta) * implied_prec R =\",\n \"for (g, ug) in zip(gamma, active_dirs.values())] return block_diag(*[i for gp\",\n \"pvalues, 'lower_confidence': lower, 'upper_confidence': upper}) if not np.all(parameter == 0):\",\n \"self.randomizer_prec) - target_lin.T.dot( self.prec_opt).dot(target_lin) _P = target_linear.T.dot(target_offset) * self.randomizer_prec _r\",\n \"the optimization density # depends on the score, not how\",\n \"con_offset - con_linear.dot(gs))) if useJacobian: p3 = - jacobian_grad_hess(gs, C,\",\n \"C unbiased_estimator = target_cov.dot(_prec).dot(observed_target) + target_cov.dot( _P - target_lin.T.dot(prec_opt).dot(target_off)) L\",\n \"set up lasso penalty and run usual lasso solver... (see\",\n \"= -self.logdens_linear.dot(target_linear) target_off = (self.cond_mean - target_lin.dot(observed_target_uni)).reshape((target_lin.shape[0],)) _prec = prec_target\",\n \"+ con_offset - con_linear.dot(gs)) ** 2.) + 1. / ((con_offset\",\n \"= target_cov.dot(_P - target_lin.T.dot(prec_opt).dot(target_off)) conjugate_arg = prec_opt.dot(cond_mean) val, soln, hess\",\n \"target. target_score_cov : ndarray Estimated covariance of target and score\",\n \"proposal = current - step * cur_grad if np.all(con_offset -\",\n \"scaling def objective(gs): p1 = -gs.T.dot(conjugate_arg) p2 = gs.T.dot(precision).dot(gs) /\",\n \"numpy as np from numpy import log from numpy.linalg import\",\n \"jacobian to hessian p1 = con_linear.T.dot(np.diag(-1. / ((scaling + con_offset\",\n \"1.5 * _scale[j], observed_target[j] + 1.5 * _scale[j], num=ngrid) self.opt_linear\",\n \"= _prec + L.dot(target_lin) - L.dot(hess.dot(L.T)) observed_info_mean = target_cov.dot(observed_info_natural.dot(target_cov)) Z_scores\",\n \"Approximate the log of the reference density on a grid.\"\n]","isConversational":false}}},{"rowIdx":2299,"cells":{"ngram":{"kind":"list like","value":["k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k","self._occupied()) betarest = 1-sum(betavec[k] for k in ks) # get","for k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for","= np.where(np.diff(seq) != 0) # internal end indices (not incl","+= np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) # add in obs/dur","A, ((A,stateseq[A.start]),) elif A.start <= t < A.stop or B.start","indicating a potentially new label ABIGNUMBER = 10000 # state","in ks]) scores = np.array([(alpha*betavec[k] + ft if k !=","# state labels are sampled uniformly from 0 to abignumber","* (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition (if there is","rle # must override set methods # type(x).__setitem__(x,i) classmethod #","counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add","returns a sequence of length between 1 and 3, where","* beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\ - np.log(alpha * (1-beta[k]) +","== k else 0 another_fromto = 1 if (t >","scores = np.array([(alpha*betavec[k] + (kappa if k == stateseq[t+1] else","slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B) if x.stop","= np.where(self.stateseq[:-1] == k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1] ==","transition score if t < self.T-1: score += np.log(betavec[stateseq[t+1]]) #","[alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate =","k factor if t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:]","stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class","!= SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] ==","= beta self.obs = obs self.dur = dur self.data =","self.stateseq score = 0 # left transition score if t","choice of what state to start in; it's just a","1 if (t > 0 and stateseq[t-1] == k and","= 1-sum(betavec[k] for k in ks) # get the counts","= firststate_dur # run a family-CRF (CRF with durations) forwards","plt stateseq_norep, durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict","def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k):","sample proportional to scores = np.array([(alpha*betavec[k] + (kappa if k","_new_label(self,ks): assert SAMPLING not in ks newlabel = np.random.randint(ABIGNUMBER) while","self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur","stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0","0 score = 0. # unpack variables model = self.model","# so that we can get the indicator sequence #","states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in ks])","while t < T: ks = list(model._occupied() | self._occupied()) betarest","no censoring by adding to score of last # segment","just make sure outside that anything that sets self.stateseq #","= np.array([self._label_score(t,k) for k in ks] + [self._new_label_score(t,ks)]) newlabelidx =","colors_dict is not None: C = np.array([[colors_dict[state] for state in","kappa = self.alpha_0, self.kappa betavec, model, o = self.beta.betavec, self.model,","self.kappa betavec, model, o = self.beta.betavec, self.model, self.obs data, stateseq","t > 0: betarest = 1-sum(betavec[k] for k in ks)","def _counts_to(self,k): assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq)","counts) if t < self.T-1: score += np.log(beta[stateseq[t+1]]) # add","not None: C = np.array([[colors_dict[state] for state in stateseq_norep]]) else:","adding to score of last # segment SAMPLING = -1","in self.stateseq or k1 == k2: return 0 else: stateseq_norep,","# now get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur =","beta updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self):","stateseq[t] = ks[nextstateidx] self.stateseq = stateseq def resample(self): model =","self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores = np.array([(alpha*betavec[k] + ft","pyplot as plt stateseq_norep, durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1))","betavec, model, o = self.beta.betavec, self.model, self.obs data, stateseq =","one) if stateseq[t-1] != k: score += np.log(alpha * beta[k]","= 1 if (t > 0 and stateseq[t-1] == k","that maintains its own rle # must override set methods","SAMPLING in self.stateseq[1:] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k:","combinedata from pyhsmm.util.general import rle as rle # NOTE: assumes","self.model._durs_withlabel(val) # add a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) #","= self.model self.stateseq = np.array([]) ks = list(model._occupied()) + [None]","def _generate(self,T): alpha = self.alpha_0 betavec = self.beta.betavec model =","= stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None):","and maybe self.data assert self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy()","B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B) if x.stop","members norep and lens (or something) # that are either","# build local group of statistics localgroup = [] self.stateseq[wholegroup]","(kappa if k == stateseq[t+1] else 0) + ft) for","get the indicator sequence # TODO if i write the","t > 0 and stateseq[t-1] == k else 0 another_fromto","is one) if t < self.T-1 and stateseq[t+1] != k:","def _new_label_score(self,t,ks): assert t > 0 score = 0. #","if firststateidx == len(ks)-1: firststate = self._new_label(ks) else: firststate =","= ks[newlabelidx] def _label_score(self,t,k): assert t > 0 score =","return score def _new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa betavec,","be occupied. ks = list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks)))","= sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0] = self._new_label(ks) else:","self.obs, self.dur # left transition (if there is one) if","constant for indicating a state or state range that is","\\ - np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition","= np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq =","as plt stateseq_norep, durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if","in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in","not None, 'must pass in T when generating' self._generate(T) elif","of seq return newlabel def _data_withlabel(self,k): assert k != SAMPLING","will be occupied. ks = list(model._occupied()) + [None] firststate =","in self.stateseq or k2 not in self.stateseq or k1 ==","slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B) if x.stop - x.start","and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp -= 1","assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp =","== k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2) class","if t < 0: return slice(0,0) elif t > seq.shape[0]-1:","0 and stateseq[t-1] == k and stateseq[t+1] == k) else","a delta at that label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t]","have a choice of what state to start in; it's","### label sampler stuff def resample_label_version(self): # NOTE never changes","if SAMPLING in stateseq_norep[:-1] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] ==","k in ks]) scores = np.array([(alpha*betavec[k] + ft if k","self.resample_label_version() def _durs_withlabel(self,k): assert k != SAMPLING if len(self.stateseq) >","np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T = len(self.stateseq) def resample(self): self.resample_label_version()","+ model._counts_fromto(k,stateseq[t+1])) \\ - np.log(alpha * (1-beta[k]) + model._counts_from(k)) #","np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate, needed if new state","to counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) #","nextstate = self._new_label(ks) else: nextstate = ks[nextstateidx] # now get","last # segment SAMPLING = -1 # special constant for","= data self.T = data.shape[0] def _generate(self,T): alpha = self.alpha_0","SAMPLING for piece, val in pieces: # get all the","@classmethod def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1, ...) '''","value scores = np.array([self._label_score(t,k) for k in ks] + [self._new_label_score(t,ks)])","internal end indices (not incl -1 and T-1) startindices =","(if there is one) if t < self.T-1 and stateseq[t+1]","new value scores = np.array([self._label_score(t,k) for k in ks] +","it should also call beta updates... class collapsed_states(object): __metaclass__ =","+ [None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate","the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq =","never changes first label: we assume the initial state #","assert k != SAMPLING return self.data[self.stateseq == k] def _occupied(self):","0] else: It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x","if new state at beginning of seq return newlabel def","def resample(self): model = self.model for t in np.random.permutation(self.T): #","while newlabel in ks: newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel]","views self.stateseq = orig_stateseq # return return localgroup @classmethod def","local group of statistics localgroup = [] self.stateseq[wholegroup] = SAMPLING","# restore original views self.stateseq = orig_stateseq # return return","them scores = np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx =","else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq =","k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1]","_counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2 != SAMPLING if","stateseq is None: self.data = data self._generate(data.shape[0]) else: assert data.shape[0]","'must pass in T when generating' self._generate(T) elif data is","in the HDP-HMM # Here, we choose just to sample","1-sum(betavec[k] for k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k)","= self.stateseq obs, durs = self.obs, self.dur # left transition","newlabel in ks: newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] #","override set methods # type(x).__setitem__(x,i) classmethod # also has members","another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) ) # observation score score","stateseq[t+1] != k: score += np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1]))","collections, itertools import abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata","beta forwards for t in range(1,T): self.stateseq = stateseq[:t] ks","len(ks)-1: firststate = self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur","fixed weights beta forwards for t in range(1,T): self.stateseq =","_ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k) if SAMPLING","class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod","k) else 0 score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa if","else: stateseq[0] = ks[firststate] # runs a CRF with fixed","betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model = self.model self.stateseq","in this model, this will always sample # zero, since","self.stateseq[t] = SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks = list(ks)","self.stateseq[t] = SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) # form the","in stateseq_norep[1:] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp","else 0) + ft) for k,ft in zip(ks,fromto_counts)] + [alpha*betarest])","from the exclusion self.stateseq[piece] = orig_stateseq[piece] # restore original views","beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\ - np.log(alpha * (1-beta[k]) + model._counts_from(k))","= SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) # form the scores","score score += o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert k","add a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the","make sure outside that anything that sets self.stateseq # also","score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) # add in","# internal end indices (not incl -1 and T-1) startindices","= self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece to our localgroup","self.obs = obs self.dur = dur self.data = data if","exclusive #################### # States Classes # #################### # TODO an","# that are either read-only or also override setters #","| self._occupied()) betarest = 1-sum(betavec[k] for k in ks) fromto_counts","np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run a family-CRF (CRF with","self.stateseq_norep, self.durations = rle(stateseq) self.data = data self.T = data.shape[0]","self.stateseq[t] = k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING","self.model, self.obs data, stateseq = self.data, self.stateseq score = 0","\\ - np.log(alpha * (1-beta[k]) + model._counts_from(k)) # predictive likelihoods","in right transition (no counts) if t < self.T-1: score","1 if t > 0 and stateseq[t-1] == k else","temp = np.sum(self.stateseq[1:] == k) if SAMPLING in self.stateseq[:-1] and","# self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0]","else: It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in","that is being resampled NEW = -2 # special constant","form the scores and sample from them scores = np.array([self._score(k,t)","self._occupied()) betarest = 1-sum(betavec[k] for k in ks) fromto_counts =","state # going to all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k)","+ [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate","import abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general","(no counts) if t < self.T-1: score += np.log(beta[stateseq[t+1]]) #","ks) # get the counts of new states coming out","na = np.newaxis import collections, itertools import abc from pyhsmm.util.stats","unpack model = self.model alpha = self.alpha_0 beta = self.beta.betavec","# left transition (if there is one) if stateseq[t-1] !=","self.stateseq[:-1] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp -=","(A,B) if x.stop - x.start > 0] else: It =","== k] else: return [] def _counts_fromto(self,k1,k2): assert k1 !=","= self.beta.betavec model = self.model self.stateseq = np.array([]) ks =","= rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k) if SAMPLING in","_local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1, ...) ''' A,B =","score += np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\ - np.log(alpha","family-CRF (CRF with durations) forwards while t < T: ks","t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B)","== k) if SAMPLING in self.stateseq[1:] and \\ self.stateseq[np.where(self.stateseq ==","one) if t < self.T-1 and stateseq[t+1] != k: score","that if this is the # first chain being sampled","C = np.array([[colors_dict[state] for state in stateseq_norep]]) else: C =","# temporarily set stateseq to hypothetical stateseq # so that","stateseq self.data = data self.T = data.shape[0] def _generate(self,T): self.T","the other data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add","slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) != 0) # internal end","set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import pyplot as","# also has members norep and lens (or something) #","and T idx = np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def","as np na = np.newaxis import collections, itertools import abc","== k2) def _counts_from(self,k): assert k != SAMPLING stateseq_norep, _","HDP-HMM # Here, we choose just to sample from beta.","else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition","# must override set methods # type(x).__setitem__(x,i) classmethod # also","+ (kappa if k == stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k))","= seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx]","in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx ==","pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import rle as","# indicators since we may need to include the left","= ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t","return score def _new_label_score(self,t,ks): assert t > 0 score =","list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1:","!= SAMPLING and k2 != SAMPLING if k1 not in","t < 0: return slice(0,0) elif t > seq.shape[0]-1: return","those states plus a new one, sample proportional to scores","temp -= 1 return temp def _counts_to(self,k): assert k !=","self.beta.betavec stateseq = self.stateseq obs, durs = self.obs, self.dur #","+= np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\ - np.log(alpha *","self.data = data if (data,stateseq) == (None,None): # generating assert","else: nextstate = ks[nextstateidx] # now get the duration of","= np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T = len(self.stateseq) def resample(self):","else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert t > 0","k1 not in self.stateseq or k2 not in self.stateseq or","\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp -= 1 return","+= np.log(beta[stateseq[t+1]]) # add in sum over k factor if","rle # NOTE: assumes censoring. can make no censoring by","= -2 # special constant indicating a potentially new label","to scores = np.array([(alpha*betavec[k] + (kappa if k == stateseq[t+1]","= sample_discrete_from_log(scores) # set the state if idx == scores.shape[0]-1:","####################### # Utility Functions # ####################### def fill(seq,t): if t","for k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set the","(None,None): # generating assert T is not None, 'must pass","> 0 and stateseq[t-1] == k else 0 another_fromto =","= rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1) # EXCEPT last","seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx] =","def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2 != SAMPLING","# type(x).__setitem__(x,i) classmethod # also has members norep and lens","#################### # TODO an array class that maintains its own","if x.stop - x.start > 0] ####################### # Utility Functions","sample_discrete_from_log(scores) # set the state if idx == scores.shape[0]-1: self.stateseq[t]","# add in sum over k factor if t <","read-only or also override setters # for now, i'll just","stateseq # so that we can get the indicator sequence","assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations =","this is the # first chain being sampled in this","stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) +","sampler stuff def resample_label_version(self): # NOTE never changes first label:","firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur #","self.data = data self.T = data.shape[0] def _generate(self,T): self.T =","and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp -= 1","EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert k","used piece from the exclusion self.stateseq[piece] = orig_stateseq[piece] # restore","#################### # States Classes # #################### # TODO an array","np.sum(stateseq_norep[:-1] == k) if SAMPLING in stateseq_norep[1:] and \\ stateseq_norep[np.where(stateseq_norep","= sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks) else:","= rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k) if SAMPLING in","return [] def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2","k1 == k2: return 0 else: stateseq_norep, _ = rle(self.stateseq)","assumes censoring. can make no censoring by adding to score","class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa = kappa","of local pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score +=","stateseq = np.zeros(T,dtype=np.int) model = self.model self.stateseq = stateseq[:0] #","(0,1) temp = np.sum(self.stateseq[1:] == k) if SAMPLING in self.stateseq[:-1]","= np.array([(alpha*betavec[k] + (kappa if k == stateseq[t+1] else 0)","+ self._counts_fromto(stateseq[t-1],k) for k in ks]) # for those states","k2 not in self.stateseq or k1 == k2: return 0","may need to include the left transition in # counts","t < self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation score score","# add in right transition (no counts) if t <","+ [alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t]","== k and stateseq[t+1] == k) else 0 score +=","k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build","in self.stateseq[:-1] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp","CRF with fixed weights beta forwards for t in range(1,T):","elif data is None: self.T = stateseq.shape[0] self.stateseq = stateseq","= collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx] = canondict[s] reversedict","''' # temporarily modifies members, like self.stateseq and maybe self.data","changes first label: we assume the initial state # distribution","betarest = 1-sum(betavec[k] for k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1])))","= data.shape[0] def _generate(self,T): alpha = self.alpha_0 betavec = self.beta.betavec","that we can get the indicator sequence # TODO if","np.log(beta[stateseq[t+1]]) # add in sum over k factor if t","at beginning of seq return newlabel def _data_withlabel(self,k): assert k","np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if t < self.T-1: score","ABIGNUMBER = 10000 # state labels are sampled uniformly from","self.model for t in np.random.permutation(self.T): # throw out old value","= self.beta.betavec, self.model, self.obs data, stateseq = self.data, self.stateseq score","is one) if stateseq[t-1] != k: score += np.log(alpha *","= self.stateseq.copy() # temporarily set stateseq to hypothetical stateseq #","= list(ks) # sample a new value scores = np.array([self._label_score(t,k)","exchangeably, not independently) another_from = 1 if t > 0","chain being sampled in this model, this will always sample","3, where each sequence element is ((data,otherdata), (dur,otherdurs)) ''' #","fill(stateseq,t-1), fill(stateseq,t+1) if A == B: return A, ((A,stateseq[A.start]),) elif","# left transition (only from counts, no to counts) score","ks[nextstateidx] self.stateseq = stateseq def resample(self): model = self.model for","T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T idx","self.stateseq[1:] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp -=","are scoring exchangeably, not independently) another_from = 1 if t","another_from = 1 if t > 0 and stateseq[t-1] ==","idx = np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq","score = 0 # left transition score if t >","and stateseq[t-1] == k else 0 another_fromto = 1 if","t += nextstate_dur self.T = len(self.stateseq) def resample(self): self.resample_label_version() def","stateseq is None: self.data = data # self._generate(data.shape[0]) # initialized","transition score if t > 0: score += np.log( (alpha*betavec[k]","score += o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert k !=","k: score += np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\ -","idx = sample_discrete_from_log(scores) # set the state if idx ==","== SAMPLING)[0]+1] == k: temp -= 1 return temp def","self.stateseq[piece] = orig_stateseq[piece] # restore original views self.stateseq = orig_stateseq","stateseq_norep, durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is","self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run a family-CRF","rle as rle # NOTE: assumes censoring. can make no","_score(self,k,t): alpha, kappa = self.alpha_0, self.kappa betavec, model, o =","def canonize(seq): seq = seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s","of last # segment SAMPLING = -1 # special constant","collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx] = canondict[s] reversedict =","newlabel = np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel = np.random.randint(ABIGNUMBER)","= data if (data,stateseq) == (None,None): # generating assert T","== SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1] == k) if","temp -= 1 return temp def _counts_fromto(self,k1,k2): assert k1 !=","self.dur = dur self.data = data if (data,stateseq) == (None,None):","(piece1, ...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A ==","== k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model","add in sum over k factor if t < self.T-1:","likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata) +","self.stateseq = stateseq def resample(self): model = self.model for t","choice that isn't specified in the HDP-HMM # Here, we","< self.T-1: score += np.log(beta[stateseq[t+1]]) # add in sum over","np.array([(alpha*betavec[k] + ft if k != self.stateseq[t-1] else 0) for","or also override setters # for now, i'll just make","class that maintains its own rle # must override set","_new_label_score(self,t,ks): assert t > 0 score = 0. # unpack","self.stateseq # also sets self.stateseq_norep and self.durations # it should","sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0]","self.T = data.shape[0] def _generate(self,T): alpha = self.alpha_0 betavec =","stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right","+ [None] firststate = sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0]","if t < self.T - 1: # indicators since we","hypothetical stateseq # so that we can get the indicator","_counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING","not in self.stateseq or k2 not in self.stateseq or k1","_data_withlabel(self,k): assert k != SAMPLING return self.data[self.stateseq == k] def","if t > 0: betarest = 1-sum(betavec[k] for k in","k != SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1) temp","return A, ((A,stateseq[A.start]),) elif A.start <= t < A.stop or","# instantiate, needed if new state at beginning of seq","in self.stateseq[1:] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp","get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq","in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks","kappa = self.alpha_0, self.kappa betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int)","beta = self.beta.betavec stateseq = self.stateseq obs, durs = self.obs,","k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx","+ model._counts_from(stateseq[t-1])) # right transition (if there is one) if","k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model =","10000 # state labels are sampled uniformly from 0 to","rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None: C","occupied. ks = list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks))) if","self.T = len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k","element is ((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies members, like","self.data assert self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy() # temporarily","<= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy() canondict","localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1, ...)","SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1]","# form the scores and sample from them scores =","first chain being sampled in this model, this will always","> 0: betarest = 1-sum(betavec[k] for k in ks) score","we assume the initial state # distribution is a delta","are sampled uniformly from 0 to abignumber exclusive #################### #","plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa =","from counts, no to counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]])","(alpha*betavec[stateseq[t+1]] + (kappa if k == stateseq[t+1] else 0) +","o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert k != SAMPLING assert","SAMPLING orig_stateseq = self.stateseq.copy() # temporarily set stateseq to hypothetical","another_from) ) # observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return score","we have a choice of what state to start in;","= list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx ==","else: stateseq[t] = ks[nextstateidx] self.stateseq = stateseq def resample(self): model","of our current state # going to all other states","indicator sequence # TODO if i write the special stateseq","or B.start <= t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for","division import numpy as np na = np.newaxis import collections,","0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) )","for k in ks]) # for those states plus a","= np.sum(stateseq_norep[:-1] == k) if SAMPLING in stateseq_norep[1:] and \\","return temp ### label sampler stuff def resample_label_version(self): # NOTE","not in ks newlabel = np.random.randint(ABIGNUMBER) while newlabel in ks:","A.stop or B.start <= t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start])","> 0 and stateseq[t-1] == k and stateseq[t+1] == k)","nextstate = ks[nextstateidx] # now get the duration of nextstate!","SAMPLING if k1 not in self.stateseq or k2 not in","indicators since we may need to include the left transition","= abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass","zero, since no states will be occupied. ks = list(model._occupied())","newlabelidx = sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks)","this will always sample # zero, since no states will","norep and lens (or something) # that are either read-only","startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T idx =","new states coming out of our current state # going","to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece from","always sample # zero, since no states will be occupied.","\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp -= 1 return","= np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) #","for now, i'll just make sure outside that anything that","own rle # must override set methods # type(x).__setitem__(x,i) classmethod","include the left transition in # counts (since we are","self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) # sample a new value","score if t < self.T - 1: # indicators since","= np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run a family-CRF (CRF","temporarily set stateseq to hypothetical stateseq # so that we","self.data, self.stateseq score = 0 # left transition score if","stateseq_norep[1:] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp -=","# going to all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) +","t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) !=","else: stateseq_norep, _ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1)","self.T = data.shape[0] def _generate(self,T): self.T = T alpha, kappa","need to include the left transition in # counts (since","# return return localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns slices:","reversedict class dummytrans(object): def __init__(self,A): self.A = A def resample(self,*args,**kwargs):","= self.beta.betavec stateseq = self.stateseq obs, durs = self.obs, self.dur","!= 0) # internal end indices (not incl -1 and","data if (data,stateseq) == (None,None): # generating assert T is","stateseq_norep[:-1] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp -=","# get the counts of new states coming out of","[None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate =","setters # for now, i'll just make sure outside that","# unpack model = self.model alpha = self.alpha_0 beta =","stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k) if","k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k):","return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 =","= 1-sum(betavec[k] for k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) #","[alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t] =","(1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition (if there is one)","for k in ks) # get the counts of new","self.kappa = kappa self.model = model self.beta = beta self.obs","ks newlabel = np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel =","= self.beta.betavec[newlabel] # instantiate, needed if new state at beginning","= obs self.data = data if (data,stateseq) == (None,None): #","= np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert data.shape[0] == stateseq.shape[0]","_counts_from(self,k): assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp","@abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING not in","in ks]) # for those states plus a new one,","np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0","needed if new state at beginning of seq return newlabel","ks[firststate] # runs a CRF with fixed weights beta forwards","= 1 if t > 0 and stateseq[t-1] == k","- x.start > 0] else: It = slice(t,t+1) return slice(A.start,B.stop),","= stateseq.shape[0] self.stateseq = stateseq elif stateseq is None: self.data","the scores and sample from them scores = np.array([self._score(k,t) for","def _data_withlabel(self,k): assert k != SAMPLING return self.data[self.stateseq == k]","score def _new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa betavec, model,","in T when generating' self._generate(T) elif data is None: self.T","abignumber exclusive #################### # States Classes # #################### # TODO","k2 != SAMPLING if k1 not in self.stateseq or k2","from the prior # self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0])","returns slices: wholegroup, (piece1, ...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1)","transition (no counts) if t < self.T-1: score += np.log(beta[stateseq[t+1]])","plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa","sure outside that anything that sets self.stateseq # also sets","SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) # form the scores and","self.T = T alpha, kappa = self.alpha_0, self.kappa betavec =","statistics localgroup = [] self.stateseq[wholegroup] = SAMPLING for piece, val","in ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx ==","class dummytrans(object): def __init__(self,A): self.A = A def resample(self,*args,**kwargs): pass","in self.stateseq or k2 not in self.stateseq: return 0 else:","assert k != SAMPLING if len(self.stateseq) > 0: stateseq_norep, durations","= obs self.dur = dur self.data = data if (data,stateseq)","= self._new_label(ks) else: self.stateseq[t] = ks[idx] def _score(self,k,t): alpha, kappa","self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T = len(self.stateseq)","this will need fixing self.stateseq[t] = k wholegroup, pieces =","self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert data.shape[0] ==","firststate == len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0] = ks[firststate]","each sequence element is ((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies","obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): ''' returns a","self.model alpha = self.alpha_0 beta = self.beta.betavec stateseq = self.stateseq","old value self.stateseq[t] = SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) #","if SAMPLING in stateseq_norep[1:] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] ==","k != self.stateseq[t-1] else 0) for k,ft in zip(ks,fromto_counts)] +","last return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert k !=","newlabel def _data_withlabel(self,k): assert k != SAMPLING return self.data[self.stateseq ==","len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0] = ks[firststate] # runs","A.start <= t < A.stop or B.start <= t <","return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import pyplot","isn't specified in the HDP-HMM # Here, we choose just","potentially new label ABIGNUMBER = 10000 # state labels are","for state in stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1))","_counts_to(self,k): assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING) in","sequence element is ((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies members,","plot(self,colors_dict): from matplotlib import pyplot as plt stateseq_norep, durations =","self.model self.stateseq = stateseq[:0] # NOTE: we have a choice","<= t < A.stop or B.start <= t < B.stop:","call beta updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def","assert k1 != SAMPLING and k2 != SAMPLING if k1","def _generate(self,T): self.T = T alpha, kappa = self.alpha_0, self.kappa","for k in ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if","if firststate == len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0] =","collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod def","= self.obs, self.dur # left transition (only from counts, no","0 score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k ==","that anything that sets self.stateseq # also sets self.stateseq_norep and","# Here, we choose just to sample from beta. Note","o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa","or k2 not in self.stateseq or k1 == k2: return","''' returns a sequence of length between 1 and 3,","pass def _new_label(self,ks): assert SAMPLING not in ks newlabel =","return return localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup,","1: # indicators since we may need to include the","== stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data","left transition in # counts (since we are scoring exchangeably,","k in ks) # get the counts of new states","EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None):","t < T: ks = list(model._occupied() | self._occupied()) betarest =","k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx","_ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1) # EXCEPT","None: self.T = stateseq.shape[0] self.stateseq = stateseq elif stateseq is","== k2: return 0 else: stateseq_norep, _ = rle(self.stateseq) from_indices,","= stateseq def resample(self): model = self.model for t in","seq[idx] = canondict[s] reversedict = {} for k,v in canondict.iteritems():","= k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING #","+= np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if t < self.T-1:","# #################### # TODO an array class that maintains its","None: C = np.array([[colors_dict[state] for state in stateseq_norep]]) else: C","= stateseq elif stateseq is None: self.data = data self._generate(data.shape[0])","1-sum(betavec[k] for k in ks) # get the counts of","nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t +=","get all the other data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val)","- 1: # indicators since we may need to include","0 another_fromto = 1 if (t > 0 and stateseq[t-1]","self.model = model self.beta = beta self.obs = obs self.data","resample_label_version(self): # NOTE never changes first label: we assume the","when generating' self._generate(T) elif data is None: self.T = stateseq.shape[0]","otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece to","scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k):","betavec = self.beta.betavec model = self.model self.stateseq = np.array([]) ks","val in pieces: # get all the other data otherdata,","(alpha*betavec[k] + (kappa if k == stateseq[t-1] else 0) +","score += np.log(betavec[stateseq[t+1]]) # observation score score += o.log_marginal_likelihood(data[t]) return","the prior # self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T","k return seq, canondict, reversedict class dummytrans(object): def __init__(self,A): self.A","k: score += np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\ -","model._counts_from(stateseq[t-1])) # add in right transition (no counts) if t","sets self.stateseq_norep and self.durations # it should also call beta","+ durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert t > 0","# observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t):","def _durs_withlabel(self,k): assert k != SAMPLING if len(self.stateseq) > 0:","def _counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING not in ks","< self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation score score +=","return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B) if x.stop -","transition (only from counts, no to counts) score += np.log(alpha)","idx,s in enumerate(seq): seq[idx] = canondict[s] reversedict = {} for","it's just a # definition choice that isn't specified in","+ ft if k != self.stateseq[t-1] else 0) for k,ft","new label ABIGNUMBER = 10000 # state labels are sampled","lens (or something) # that are either read-only or also","= rle(stateseq) self.data = data self.T = data.shape[0] def _generate(self,T):","indicating a state or state range that is being resampled","if t < self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation score","0. # unpack model = self.model alpha = self.alpha_0 beta","orig_stateseq[piece] # restore original views self.stateseq = orig_stateseq # return","being resampled NEW = -2 # special constant indicating a","obs self.data = data if (data,stateseq) == (None,None): # generating","stateseq def resample(self): model = self.model for t in np.random.permutation(self.T):","else 0 another_fromto = 1 if (t > 0 and","add in obs/dur scores of local pieces for (data,otherdata), (dur,otherdurs)","override setters # for now, i'll just make sure outside","temp def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2 !=","# get all the other data otherdata, otherdurs = self.model._data_withlabel(val),","= np.sum(self.stateseq[1:] == k) if SAMPLING in self.stateseq[:-1] and \\","k) if SAMPLING in self.stateseq[:-1] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1]","scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq =","ks[newlabelidx] def _label_score(self,t,k): assert t > 0 score = 0.","slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy() canondict = collections.defaultdict(itertools.count().next) for","(1-beta[k]) + model._counts_from(k)) # predictive likelihoods for (data,otherdata), (dur,otherdurs) in","self.stateseq and maybe self.data assert self.stateseq[t] == SAMPLING orig_stateseq =","t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score","self.T-1 and stateseq[t+1] != k: score += np.log(alpha * beta[stateseq[t+1]]","like self.stateseq and maybe self.data assert self.stateseq[t] == SAMPLING orig_stateseq","''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A == B: return","== k: temp -= 1 return temp def _counts_to(self,k): assert","data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece","and sample from them scores = np.array([self._score(k,t) for k in","== scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq","((A,stateseq[A.start]),) elif A.start <= t < A.stop or B.start <=","self.beta.housekeeping(ks) # form the scores and sample from them scores","return seq, canondict, reversedict class dummytrans(object): def __init__(self,A): self.A =","# TODO if i write the special stateseq class, this","if k == stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1]))","\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp -= 1 return","0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score","self.stateseq.copy() # temporarily set stateseq to hypothetical stateseq # so","{} for k,v in canondict.iteritems(): reversedict[v] = k return seq,","SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:] == k) if SAMPLING","(data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return","t > 0 score = 0. # unpack model =","(not incl -1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl","+ (kappa if k == stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1])","fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in ks]) #","self.data = data self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0] self.stateseq","firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate","newweight = self.beta.betavec[newlabel] # instantiate, needed if new state at","of new states coming out of our current state #","T when generating' self._generate(T) elif data is None: self.T =","stateseq[t] = self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq = stateseq","+ model._counts_from(stateseq[t-1])) # add in right transition (no counts) if","= self.alpha_0, self.kappa betavec, model, o = self.beta.betavec, self.model, self.obs","def _local_group(self,t,k): ''' returns a sequence of length between 1","alpha_0 self.kappa = kappa self.model = model self.beta = beta","one, sample proportional to scores = np.array([(alpha*betavec[k] + (kappa if","in (0,1) temp = np.sum(self.stateseq[:-1] == k) if SAMPLING in","0 and T idx = np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1])","ks = list(ks) # sample a new value scores =","in self.stateseq: return 0 else: from_indices, = np.where(self.stateseq[:-1] == k1)","SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:]","!= self.stateseq[t-1] else 0) for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest])","all the other data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) #","sequence of length between 1 and 3, where each sequence","sequence # TODO if i write the special stateseq class,","special constant for indicating a state or state range that","nextstate_dur self.T = len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert","label sampler stuff def resample_label_version(self): # NOTE never changes first","newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate, needed if","ks[idx] def _score(self,k,t): alpha, kappa = self.alpha_0, self.kappa betavec, model,","prior # self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T =","== k] def _occupied(self): return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict):","= rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None:","localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece from the exclusion","= sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate = self._new_label(ks) else:","0 score = 0. # unpack model = self.model alpha","not independently) another_from = 1 if t > 0 and","1 return temp def _counts_to(self,k): assert k != SAMPLING assert","seq return newlabel def _data_withlabel(self,k): assert k != SAMPLING return","else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) + another_from)","otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece to our","between 1 and 3, where each sequence element is ((data,otherdata),","if (t > 0 and stateseq[t-1] == k and stateseq[t+1]","np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert k != SAMPLING stateseq_norep,",") # right transition score if t < self.T -","np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k == stateseq[t+1] else 0)","= np.array([[colors_dict[state] for state in stateseq_norep]]) else: C = stateseq_norep[na,:]","elif stateseq is None: self.data = data # self._generate(data.shape[0]) #","if k != self.stateseq[t-1] else 0) for k,ft in zip(ks,fromto_counts)]","self.alpha_0 betavec = self.beta.betavec model = self.model self.stateseq = np.array([])","score = 0. # unpack model = self.model alpha =","States Classes # #################### # TODO an array class that","# runs a CRF with fixed weights beta forwards for","== k) else 0 score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa","to start in; it's just a # definition choice that","* beta[k] + model._counts_fromto(stateseq[t-1],k)) \\ - np.log(alpha * (1-beta[stateseq[t-1]]) +","1 return temp def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and","0: betarest = 1-sum(betavec[k] for k in ks) score +=","_counts_to(self,k): assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp","going to all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k)","collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model = model self.beta","or k2 not in self.stateseq: return 0 else: from_indices, =","data is None: self.T = stateseq.shape[0] self.stateseq = stateseq elif","counts (since we are scoring exchangeably, not independently) another_from =","self._new_label(ks) else: nextstate = ks[nextstateidx] # now get the duration","slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B) if x.stop - x.start","with durations) forwards while t < T: ks = list(model._occupied()","obs, durs = self.obs, self.dur # left transition (only from","observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha,","for x in (A,B) if x.stop - x.start > 0]","T is not None, 'must pass in T when generating'","np.zeros(T,dtype=np.int) model = self.model self.stateseq = stateseq[:0] # NOTE: we","another_fromto = 1 if (t > 0 and stateseq[t-1] ==","nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t] = ks[nextstateidx]","range that is being resampled NEW = -2 # special","model._counts_fromto(stateseq[t-1],k)) \\ - np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right","(only from counts, no to counts) score += np.log(alpha) -","there is one) if t < self.T-1 and stateseq[t+1] !=","something) # that are either read-only or also override setters","= data # self._generate(data.shape[0]) # initialized from the prior #","enumerate(seq): seq[idx] = canondict[s] reversedict = {} for k,v in","= model self.beta = beta self.obs = obs self.dur =","durs = self.obs, self.dur # left transition (if there is","if colors_dict is not None: C = np.array([[colors_dict[state] for state","== k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2) def","@abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def","else 0) for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx =","= orig_stateseq # return return localgroup @classmethod def _local_slices(cls,stateseq,t): '''","from them scores = np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx","stuff def resample_label_version(self): # NOTE never changes first label: we","local pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata)","stateseq.shape[0] self.stateseq = stateseq elif stateseq is None: self.data =","< B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B) if","= -1 # special constant for indicating a state or","to abignumber exclusive #################### # States Classes # #################### #","_ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k) if SAMPLING","else: from_indices, = np.where(self.stateseq[:-1] == k1) # EXCEPT last return","self.stateseq = stateseq self.data = data self.T = data.shape[0] def","other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in","# unpack variables model = self.model alpha = self.alpha_0 beta","indices (not incl -1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) #","ks = list(model._occupied()) self.beta.housekeeping(ks) # form the scores and sample","# zero, since no states will be occupied. ks =","the exclusion self.stateseq[piece] = orig_stateseq[piece] # restore original views self.stateseq","| self._occupied()) betarest = 1-sum(betavec[k] for k in ks) #","= self.alpha_0 betavec = self.beta.betavec model = self.model self.stateseq =","model self.beta = beta self.obs = obs self.data = data","score def _new_label_score(self,t,ks): assert t > 0 score = 0.","= 0. # unpack variables model = self.model alpha =","in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set the state if","either read-only or also override setters # for now, i'll","to include the left transition in # counts (since we","temp = np.sum(stateseq_norep[1:] == k) if SAMPLING in stateseq_norep[:-1] and","np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\ - np.log(alpha * (1-beta[stateseq[t-1]])","= [] self.stateseq[wholegroup] = SAMPLING for piece, val in pieces:","self.kappa betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model = self.model","= np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None: C = np.array([[colors_dict[state]","ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for k","np.sum(self.stateseq[1:] == k) if SAMPLING in self.stateseq[:-1] and \\ self.stateseq[np.where(self.stateseq","if x.stop - x.start > 0] else: It = slice(t,t+1)","an array class that maintains its own rle # must","self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k):","by adding to score of last # segment SAMPLING =","right transition (if there is one) if t < self.T-1","instantiate, needed if new state at beginning of seq return","i'll just make sure outside that anything that sets self.stateseq","runs a CRF with fixed weights beta forwards for t","alpha = self.alpha_0 betavec = self.beta.betavec model = self.model self.stateseq","current state # going to all other states fromto_counts =","our current state # going to all other states fromto_counts","self.stateseq obs, durs = self.obs, self.dur # left transition (if","stateseq to hypothetical stateseq # so that we can get","now, i'll just make sure outside that anything that sets","== stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) #","model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) ) # observation","self.beta.housekeeping(ks) ks = list(ks) # sample a new value scores","t = firststate_dur # run a family-CRF (CRF with durations)","is the # first chain being sampled in this model,","sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate","== k) if SAMPLING in stateseq_norep[1:] and \\ stateseq_norep[np.where(stateseq_norep ==","self.stateseq = stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data = data","k,v in canondict.iteritems(): reversedict[v] = k return seq, canondict, reversedict","0 else: stateseq_norep, _ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] ==","k and stateseq[t+1] == k) else 0 score += np.log(","def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks): assert","= data self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0] self.stateseq =","NEW = -2 # special constant indicating a potentially new","k: temp -= 1 return temp ### label sampler stuff","sampled in this model, this will always sample # zero,","== SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:] == k) if","k) if SAMPLING in self.stateseq[1:] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1]","ks = list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks))) if firststate","0) for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores)","the initial state # distribution is a delta at that","alpha_0 self.model = model self.beta = beta self.obs = obs","modifies members, like self.stateseq and maybe self.data assert self.stateseq[t] ==","# self._generate(data.shape[0]) # initialized from the prior # self.stateseq =","self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp -= 1 return temp","fixing self.stateseq[t] = k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] =","< self.T-1 and stateseq[t+1] != k: score += np.log(alpha *","A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A == B: return A,","self.stateseq_norep and self.durations # it should also call beta updates...","== k: temp -= 1 return temp def _counts_fromto(self,k1,k2): assert","also sets self.stateseq_norep and self.durations # it should also call","= self.model self.stateseq = stateseq[:0] # NOTE: we have a","= np.sum(self.stateseq[:-1] == k) if SAMPLING in self.stateseq[1:] and \\","transition score if t < self.T - 1: # indicators","if A == B: return A, ((A,stateseq[A.start]),) elif A.start <=","censoring. can make no censoring by adding to score of","exclusion self.stateseq[piece] = orig_stateseq[piece] # restore original views self.stateseq =","maybe self.data assert self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy() #","seq, canondict, reversedict class dummytrans(object): def __init__(self,A): self.A = A","# incl 0 and T idx = np.where(startindices <= t)[0][-1]","== SAMPLING)[0]+1] == k: temp -= 1 return temp ###","stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep == k] else: return","= ks[nextstateidx] # now get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate))))","if t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod()","= self.data, self.stateseq score = 0 # left transition score","the used piece from the exclusion self.stateseq[piece] = orig_stateseq[piece] #","ks = list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx","in; it's just a # definition choice that isn't specified","self.stateseq[t-1] else 0) for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx","durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert t > 0 score","return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B) if x.stop -","x.start > 0] ####################### # Utility Functions # ####################### def","in (A,It,B) if x.stop - x.start > 0] ####################### #","betarest = 1-sum(betavec[k] for k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k)","self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs)))","forwards while t < T: ks = list(model._occupied() | self._occupied())","pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod","-= 1 return temp ### label sampler stuff def resample_label_version(self):","+ model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) ) #","durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): ''' returns a sequence of","outside that anything that sets self.stateseq # also sets self.stateseq_norep","model, o = self.beta.betavec, self.model, self.obs data, stateseq = self.data,","left transition score if t > 0: score += np.log(","return score def _counts_from(self,k): assert k != SAMPLING assert np.sum(self.stateseq","start in; it's just a # definition choice that isn't","all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k","else: endindices, = np.where(np.diff(seq) != 0) # internal end indices","first label: we assume the initial state # distribution is","temp def _counts_to(self,k): assert k != SAMPLING assert np.sum(self.stateseq ==","np.sum(stateseq_norep[1:] == k) if SAMPLING in stateseq_norep[:-1] and \\ stateseq_norep[np.where(stateseq_norep","stateseq[:0] # NOTE: we have a choice of what state","= np.sum(stateseq_norep[1:] == k) if SAMPLING in stateseq_norep[:-1] and \\","write the special stateseq class, this will need fixing self.stateseq[t]","self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum())","np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\ - np.log(alpha * (1-beta[k])","dur self.data = data if (data,stateseq) == (None,None): # generating","score += np.log(beta[stateseq[t+1]]) # add in sum over k factor","right transition (no counts) if t < self.T-1: score +=","+= np.log( (alpha*betavec[k] + (kappa if k == stateseq[t-1] else","score += np.log(self.beta.remaining) # add in obs/dur scores of local","def _score(self,k,t): alpha, kappa = self.alpha_0, self.kappa betavec, model, o","# TODO an array class that maintains its own rle","and stateseq[t-1] == k and stateseq[t+1] == k) else 0","score += np.log( (alpha*betavec[k] + (kappa if k == stateseq[t-1]","from __future__ import division import numpy as np na =","censoring by adding to score of last # segment SAMPLING","ft) for k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores)","# right transition (if there is one) if t <","add in right transition (no counts) if t < self.T-1:","k2) def _counts_from(self,k): assert k != SAMPLING stateseq_norep, _ =","[(x,stateseq[x.start]) for x in (A,B) if x.stop - x.start >","import division import numpy as np na = np.newaxis import","[] def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2 !=","= 1-sum(betavec[k] for k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) +","+= np.log(self.beta.remaining) # add in obs/dur scores of local pieces","firststateidx == len(ks)-1: firststate = self._new_label(ks) else: firststate = ks[firststateidx]","= SAMPLING for piece, val in pieces: # get all","np.array([[colors_dict[state] for state in stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1)","self.data = data self.T = data.shape[0] def _generate(self,T): alpha =","label ABIGNUMBER = 10000 # state labels are sampled uniformly","orig_stateseq # return return localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns","data self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq","for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if","ks: newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate, needed","= list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks))) if firststate ==","= slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B) if","pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass def","scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate = ks[nextstateidx] # now","and lens (or something) # that are either read-only or","temp = np.sum(stateseq_norep[:-1] == k) if SAMPLING in stateseq_norep[1:] and","at that label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING","constant indicating a potentially new label ABIGNUMBER = 10000 #","k == stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) )","self.stateseq obs, durs = self.obs, self.dur # left transition (only","= list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for k in","what state to start in; it's just a # definition","!= SAMPLING if len(self.stateseq) > 0: stateseq_norep, durations = rle(self.stateseq)","# ####################### def fill(seq,t): if t < 0: return slice(0,0)","0) + ft) for k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx","= dur self.data = data if (data,stateseq) == (None,None): #","for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks = self.model._occupied()","+= o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert k != SAMPLING","just to sample from beta. Note that if this is","temp -= 1 return temp ### label sampler stuff def","build local group of statistics localgroup = [] self.stateseq[wholegroup] =","_counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING not in ks newlabel","assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1)","beta[k] + model._counts_fromto(stateseq[t-1],k)) \\ - np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1]))","for k,v in canondict.iteritems(): reversedict[v] = k return seq, canondict,","self.stateseq or k2 not in self.stateseq or k1 == k2:","self._generate(T) elif data is None: self.T = stateseq.shape[0] self.stateseq =","data # self._generate(data.shape[0]) # initialized from the prior # self.stateseq","of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t","k != SAMPLING return self.data[self.stateseq == k] def _occupied(self): return","stateseq_norep, _ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1) #","+ another_from) ) # observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return","= stateseq self.data = data self.T = data.shape[0] def _generate(self,T):","self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model = self.model self.stateseq = stateseq[:0]","if i write the special stateseq class, this will need","itertools import abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from","= data self.T = data.shape[0] def _generate(self,T): self.T = T","/ (alpha+kappa+model._counts_from(k) + another_from) ) # observation score score +=","transition (if there is one) if t < self.T-1 and","+= np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k == stateseq[t+1] else","(CRF with durations) forwards while t < T: ks =","SAMPLING and k2 != SAMPLING if k1 not in self.stateseq","ks[nextstateidx] # now get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur","k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set the state","self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert data.shape[0]","and 3, where each sequence element is ((data,otherdata), (dur,otherdurs)) '''","that are either read-only or also override setters # for","in ks newlabel = np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel","choose just to sample from beta. Note that if this","duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate))","from pyhsmm.util.general import rle as rle # NOTE: assumes censoring.","stateseq[t+1] else 0) + ft) for k,ft in zip(ks,fromto_counts)] +","now get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs()","and self.durations # it should also call beta updates... class","# EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def","assert t > 0 score = 0. # unpack model","zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1:","no to counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1]))","the HDP-HMM # Here, we choose just to sample from","firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate = self._new_label(ks)","need fixing self.stateseq[t] = k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t]","maintains its own rle # must override set methods #","np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in right transition (no counts)","# temporarily modifies members, like self.stateseq and maybe self.data assert","plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 =","# NOTE: assumes censoring. can make no censoring by adding","of what state to start in; it's just a #","<= t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in","= np.where(stateseq_norep[:-1] == k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1] ==","# initialized from the prior # self.stateseq = self.stateseq[:self.T] self.stateseq","resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k != SAMPLING if len(self.stateseq)","return localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1,","firststate_dur # run a family-CRF (CRF with durations) forwards while","t < self.T - 1: # indicators since we may","x in (A,It,B) if x.stop - x.start > 0] #######################","self.data[self.stateseq == k] def _occupied(self): return set(self.stateseq) - set((SAMPLING,)) def","SAMPLING in stateseq_norep[:-1] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k:","+ (kappa if k == stateseq[t+1] else 0) + ft)","list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for k in ks)","else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations","scores = np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores)","= np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate, needed if new","if SAMPLING in self.stateseq[1:] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] ==","matplotlib import pyplot as plt stateseq_norep, durations = rle(self.stateseq) X,Y","for t in np.random.permutation(self.T): # throw out old value self.stateseq[t]","endindices, = np.where(np.diff(seq) != 0) # internal end indices (not","-2 # special constant indicating a potentially new label ABIGNUMBER","no states will be occupied. ks = list(model._occupied()) + [None]","(1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) # add","new state at beginning of seq return newlabel def _data_withlabel(self,k):","a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used","stateseq[:t] ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for",") # observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return score def","def _new_label(self,ks): assert SAMPLING not in ks newlabel = np.random.randint(ABIGNUMBER)","that sets self.stateseq # also sets self.stateseq_norep and self.durations #","idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[idx]","canonize(seq): seq = seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s in","self.stateseq = stateseq[:0] # NOTE: we have a choice of","= rle(self.stateseq) return durations[stateseq_norep == k] else: return [] def","self._new_label(ks) else: self.stateseq[t] = ks[idx] def _score(self,k,t): alpha, kappa =","np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores = np.array([(alpha*betavec[k]","pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build local group","Note that if this is the # first chain being","the counts of new states coming out of our current","= self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build local group of","are either read-only or also override setters # for now,","orig_stateseq = self.stateseq.copy() # temporarily set stateseq to hypothetical stateseq","durations[stateseq_norep == k] else: return [] def _counts_fromto(self,k1,k2): assert k1","-1 # special constant for indicating a state or state","also has members norep and lens (or something) # that","if nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t] =","is ((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies members, like self.stateseq","beta self.obs = obs self.dur = dur self.data = data","= len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k !=","np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score +=","piece from the exclusion self.stateseq[piece] = orig_stateseq[piece] # restore original","a # definition choice that isn't specified in the HDP-HMM","range(1,T): self.stateseq = stateseq[:t] ks = list(model._occupied() | self._occupied()) betarest","state or state range that is being resampled NEW =","return temp def _counts_to(self,k): assert k != SAMPLING stateseq_norep, _","== len(ks)-1: firststate = self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate))))","= self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) # sample a new","np na = np.newaxis import collections, itertools import abc from","for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs)","= data.shape[0] else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq","state range that is being resampled NEW = -2 #","throw out old value self.stateseq[t] = SAMPLING ks = list(model._occupied())","a family-CRF (CRF with durations) forwards while t < T:","- np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in right transition (no","self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq","assert SAMPLING not in ks newlabel = np.random.randint(ABIGNUMBER) while newlabel","Classes # #################### # TODO an array class that maintains","self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T = len(self.stateseq) def","for idx,s in enumerate(seq): seq[idx] = canondict[s] reversedict = {}","1 return temp ### label sampler stuff def resample_label_version(self): #","for indicating a state or state range that is being","generating assert T is not None, 'must pass in T","SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k)","from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import rle","= np.zeros(T,dtype=np.int) model = self.model self.stateseq = stateseq[:0] # NOTE:","self.stateseq = stateseq[:t] ks = list(model._occupied() | self._occupied()) betarest =","== SAMPLING orig_stateseq = self.stateseq.copy() # temporarily set stateseq to","sampled uniformly from 0 to abignumber exclusive #################### # States","x.stop - x.start > 0] ####################### # Utility Functions #","specified in the HDP-HMM # Here, we choose just to","self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation score score += o.log_marginal_likelihood(data[t])","is not None, 'must pass in T when generating' self._generate(T)","= self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq = stateseq def","len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k != SAMPLING","k == stateseq[t+1] else 0) + ft) for k,ft in","beta. Note that if this is the # first chain","collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa = kappa self.model","if SAMPLING in self.stateseq[:-1] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] ==","np.where(np.diff(seq) != 0) # internal end indices (not incl -1","_counts_from(self,k): assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING) in","= np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in ks]) # for","the # first chain being sampled in this model, this","scores and sample from them scores = np.array([self._score(k,t) for k","self.alpha_0, self.kappa betavec, model, o = self.beta.betavec, self.model, self.obs data,","+ self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores = np.array([(alpha*betavec[k] +","< A.stop or B.start <= t < B.stop: return slice(A.start,B.stop),","our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece from the","# special constant indicating a potentially new label ABIGNUMBER =","def _new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa betavec, model, o","self.model self.stateseq = np.array([]) ks = list(model._occupied()) + [None] firststateidx","firststate = self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur =","can get the indicator sequence # TODO if i write","state labels are sampled uniformly from 0 to abignumber exclusive","stateseq[t+1] == k) else 0 score += np.log( (alpha*betavec[stateseq[t+1]] +","is None: self.data = data self._generate(data.shape[0]) else: assert data.shape[0] ==","else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.data =","assert np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1] ==","< self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score +=","SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) # sample","in # counts (since we are scoring exchangeably, not independently)","numpy as np na = np.newaxis import collections, itertools import","t < A.stop or B.start <= t < B.stop: return","ks = self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) # sample a","0: stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep == k] else:","just a # definition choice that isn't specified in the","= np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T idx = np.where(startindices","# left transition score if t > 0: score +=","can make no censoring by adding to score of last","_durs_withlabel(self,k): assert k != SAMPLING if len(self.stateseq) > 0: stateseq_norep,","score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k == stateseq[t+1]","assert np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:] ==","= beta self.obs = obs self.data = data if (data,stateseq)","ft if k != self.stateseq[t-1] else 0) for k,ft in","[self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t] =","sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import rle as rle #","t > 0: score += np.log( (alpha*betavec[k] + (kappa if","label: we assume the initial state # distribution is a","T idx = np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq):","and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp -= 1","model = self.model self.stateseq = np.array([]) ks = list(model._occupied()) +","right transition score if t < self.T-1: score += np.log(betavec[stateseq[t+1]])","transition score if t > 0: betarest = 1-sum(betavec[k] for","model._counts_fromto(k,stateseq[t+1])) \\ - np.log(alpha * (1-beta[k]) + model._counts_from(k)) # predictive","# also sets self.stateseq_norep and self.durations # it should also","resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass","self.beta = beta self.obs = obs self.data = data if","= self.alpha_0, self.kappa betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model","None: self.data = data # self._generate(data.shape[0]) # initialized from the","canondict[s] reversedict = {} for k,v in canondict.iteritems(): reversedict[v] =","SAMPLING in self.stateseq[:-1] and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k:","of statistics localgroup = [] self.stateseq[wholegroup] = SAMPLING for piece,","and k2 != SAMPLING if k1 not in self.stateseq or","def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1, ...) ''' A,B","independently) another_from = 1 if t > 0 and stateseq[t-1]","to sample from beta. Note that if this is the","score of last # segment SAMPLING = -1 # special","ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1:","if t < self.T-1 and stateseq[t+1] != k: score +=","k] else: return [] def _counts_fromto(self,k1,k2): assert k1 != SAMPLING","stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp -= 1 return temp","also override setters # for now, i'll just make sure","is None: self.T = stateseq.shape[0] self.stateseq = stateseq elif stateseq","nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate = ks[nextstateidx]","if t > 0: score += np.log( (alpha*betavec[k] + (kappa","self.beta.betavec model = self.model self.stateseq = np.array([]) ks = list(model._occupied())","> 0 score = 0. # unpack model = self.model","== k: temp -= 1 return temp ### label sampler","TODO an array class that maintains its own rle #","(np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks =","return slice(0,0) elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices,","pyhsmm.util.general import rle as rle # NOTE: assumes censoring. can","np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T idx = np.where(startindices <=","factor if t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *=","import pyplot as plt stateseq_norep, durations = rle(self.stateseq) X,Y =","(alpha+kappa+model._counts_from(k) + another_from) ) # observation score score += o.log_predictive(data[t],model._data_withlabel(k))","!= SAMPLING return self.data[self.stateseq == k] def _occupied(self): return set(self.stateseq)","(alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score if t < self.T","x.stop - x.start > 0] else: It = slice(t,t+1) return","self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur","= 10000 # state labels are sampled uniformly from 0","score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in","return temp def _counts_to(self,k): assert k != SAMPLING assert np.sum(self.stateseq","stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp -= 1 return temp","weights beta forwards for t in range(1,T): self.stateseq = stateseq[:t]","(data,stateseq) == (None,None): # generating assert T is not None,","where each sequence element is ((data,otherdata), (dur,otherdurs)) ''' # temporarily","should also call beta updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta","set stateseq to hypothetical stateseq # so that we can","== (None,None): # generating assert T is not None, 'must","1 and 3, where each sequence element is ((data,otherdata), (dur,otherdurs))","@abc.abstractmethod def resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def","####################### def fill(seq,t): if t < 0: return slice(0,0) elif","states plus a new one, sample proportional to scores =","there is one) if stateseq[t-1] != k: score += np.log(alpha","SAMPLING)[0]+1] == k: temp -= 1 return temp ### label","else 0 score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k","return temp def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2","slices: wholegroup, (piece1, ...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if","# right transition score if t < self.T-1: score +=","delta at that label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] =","to score of last # segment SAMPLING = -1 #","score += np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\ - np.log(alpha","has members norep and lens (or something) # that are","np.sum(self.stateseq[:-1] == k) if SAMPLING in self.stateseq[1:] and \\ self.stateseq[np.where(self.stateseq","k in ks]) # for those states plus a new","self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert t > 0 score","in canondict.iteritems(): reversedict[v] = k return seq, canondict, reversedict class","> 0: score += np.log( (alpha*betavec[k] + (kappa if k","def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model = model self.beta =","k) if SAMPLING in stateseq_norep[:-1] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1]","stateseq[0] = self._new_label(ks) else: stateseq[0] = ks[firststate] # runs a","sets self.stateseq # also sets self.stateseq_norep and self.durations # it","np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set","self.T = data.shape[0] else: assert data.shape[0] == stateseq.shape[0] self.stateseq =","forwards for t in range(1,T): self.stateseq = stateseq[:t] ks =","sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate = self._new_label(ks) else: firststate","= np.newaxis import collections, itertools import abc from pyhsmm.util.stats import","# left transition score if t > 0: betarest =","= k return seq, canondict, reversedict class dummytrans(object): def __init__(self,A):","np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:] == k)","is a delta at that label for t in (np.random.permutation(self.T-1)+1):","durations = rle(self.stateseq) return durations[stateseq_norep == k] else: return []","incl 0 and T idx = np.where(startindices <= t)[0][-1] return","stateseq[t-1] == k and stateseq[t+1] == k) else 0 score","model = self.model alpha = self.alpha_0 beta = self.beta.betavec stateseq","x in (A,B) if x.stop - x.start > 0] else:","pass @abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING not","k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states):","is None: self.data = data # self._generate(data.shape[0]) # initialized from","score if t < self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation","in sum over k factor if t < self.T-1: betas","self.beta.betavec[newlabel] # instantiate, needed if new state at beginning of","for k in ks]) scores = np.array([(alpha*betavec[k] + ft if","self.T - 1: # indicators since we may need to","< 0: return slice(0,0) elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0])","NOTE: assumes censoring. can make no censoring by adding to","= stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data = data self.T","self.dur # left transition (if there is one) if stateseq[t-1]","def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa = kappa self.model =","def resample_label_version(self): # NOTE never changes first label: we assume","len(self.stateseq) > 0: stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep ==","segment SAMPLING = -1 # special constant for indicating a","= self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert t","class, this will need fixing self.stateseq[t] = k wholegroup, pieces","nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks)","1-sum(betavec[k] for k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right","= alpha_0 self.model = model self.beta = beta self.obs =","score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if t <","> seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) != 0)","coming out of our current state # going to all","k else 0 another_fromto = 1 if (t > 0","stateseq[0] = ks[firststate] # runs a CRF with fixed weights","= stateseq elif stateseq is None: self.data = data #","= self.obs, self.dur # left transition (if there is one)","a new one, sample proportional to scores = np.array([(alpha*betavec[k] +","counts, no to counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) +","left transition (only from counts, no to counts) score +=","> 0] else: It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for","_generate(self,T): self.T = T alpha, kappa = self.alpha_0, self.kappa betavec","= np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores =","stateseq[t-1] == k else 0 another_fromto = 1 if (t","for piece, val in pieces: # get all the other","= list(model._occupied()) self.beta.housekeeping(ks) # form the scores and sample from","k1 not in self.stateseq or k2 not in self.stateseq: return","if t > 0 and stateseq[t-1] == k else 0","elif A.start <= t < A.stop or B.start <= t","and stateseq[t+1] == k) else 0 score += np.log( (alpha*betavec[stateseq[t+1]]","or k1 == k2: return 0 else: stateseq_norep, _ =","the indicator sequence # TODO if i write the special","_generate(self,T): alpha = self.alpha_0 betavec = self.beta.betavec model = self.model","# definition choice that isn't specified in the HDP-HMM #","SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k)","pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) +","(A,It,B) if x.stop - x.start > 0] ####################### # Utility","state # distribution is a delta at that label for","last return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0","reversedict = {} for k,v in canondict.iteritems(): reversedict[v] = k","!= k: score += np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\","localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece from the exclusion self.stateseq[piece]","# add in obs/dur scores of local pieces for (data,otherdata),","members, like self.stateseq and maybe self.data assert self.stateseq[t] == SAMPLING","pass in T when generating' self._generate(T) elif data is None:","abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import","SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1] == k) if SAMPLING","else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states):","resampled NEW = -2 # special constant indicating a potentially","+= np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\ - np.log(alpha *","this model, this will always sample # zero, since no","return 0 else: from_indices, = np.where(self.stateseq[:-1] == k1) # EXCEPT","in obs/dur scores of local pieces for (data,otherdata), (dur,otherdurs) in","score def _counts_from(self,k): assert k != SAMPLING assert np.sum(self.stateseq ==","return durations[stateseq_norep == k] else: return [] def _counts_fromto(self,k1,k2): assert","= data.shape[0] def _generate(self,T): self.T = T alpha, kappa =","stateseq elif stateseq is None: self.data = data # self._generate(data.shape[0])","in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if","beta self.obs = obs self.data = data if (data,stateseq) ==","k: temp -= 1 return temp def _counts_to(self,k): assert k","Here, we choose just to sample from beta. Note that","self.alpha_0, self.kappa betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model =","self.T-1: score += np.log(beta[stateseq[t+1]]) # add in sum over k","if this is the # first chain being sampled in","def _counts_to(self,k): assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING)","= model self.beta = beta self.obs = obs self.data =","t < self.T-1: score += np.log(beta[stateseq[t+1]]) # add in sum","stateseq class, this will need fixing self.stateseq[t] = k wholegroup,","unpack variables model = self.model alpha = self.alpha_0 beta =","if t < self.T-1: score += np.log(beta[stateseq[t+1]]) # add in","= fill(stateseq,t-1), fill(stateseq,t+1) if A == B: return A, ((A,stateseq[A.start]),)","in stateseq_norep[:-1] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp","out of our current state # going to all other","[(x,stateseq[x.start]) for x in (A,It,B) if x.stop - x.start >","np.array([(alpha*betavec[k] + (kappa if k == stateseq[t+1] else 0) +","np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy()","value self.stateseq[t] = SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) # form","end indices (not incl -1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],)))","for those states plus a new one, sample proportional to","also call beta updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod","= self._new_label(ks) else: stateseq[0] = ks[firststate] # runs a CRF","initialized from the prior # self.stateseq = self.stateseq[:self.T] self.stateseq =","elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq)","# predictive likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score +=","temp ### label sampler stuff def resample_label_version(self): # NOTE never","model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score if t","assume the initial state # distribution is a delta at","durs = self.obs, self.dur # left transition (only from counts,","run a family-CRF (CRF with durations) forwards while t <","= self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run","self.T = stateseq.shape[0] self.stateseq = stateseq elif stateseq is None:","@abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks):","elif stateseq is None: self.data = data self._generate(data.shape[0]) else: assert","assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.data = data","return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) != 0) # internal","0: score += np.log( (alpha*betavec[k] + (kappa if k ==","self.alpha_0 beta = self.beta.betavec stateseq = self.stateseq obs, durs =","if k == stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto)","new one, sample proportional to scores = np.array([(alpha*betavec[k] + (kappa","+= np.log(betavec[stateseq[t+1]]) # observation score score += o.log_marginal_likelihood(data[t]) return score","self.stateseq = np.array([]) ks = list(model._occupied()) + [None] firststateidx =","the left transition in # counts (since we are scoring","Utility Functions # ####################### def fill(seq,t): if t < 0:","# observation score score += o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k):","data, stateseq = self.data, self.stateseq score = 0 # left","+ model._counts_from(k)) # predictive likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k):","stateseq = self.data, self.stateseq score = 0 # left transition","# Utility Functions # ####################### def fill(seq,t): if t <","that isn't specified in the HDP-HMM # Here, we choose","abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod","if len(self.stateseq) > 0: stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep","special stateseq class, this will need fixing self.stateseq[t] = k","+= nextstate_dur self.T = len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k):","* (1-beta[k]) + model._counts_from(k)) # predictive likelihoods for (data,otherdata), (dur,otherdurs)","== k) if SAMPLING in self.stateseq[:-1] and \\ self.stateseq[np.where(self.stateseq ==","is being resampled NEW = -2 # special constant indicating","ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in ks])","# sample a new value scores = np.array([self._label_score(t,k) for k","sample # zero, since no states will be occupied. ks","= self.alpha_0 beta = self.beta.betavec stateseq = self.stateseq obs, durs","a choice of what state to start in; it's just","stateseq.shape[0] self.stateseq = stateseq self.data = data self.T = data.shape[0]","return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy() canondict = collections.defaultdict(itertools.count().next)","np.newaxis import collections, itertools import abc from pyhsmm.util.stats import sample_discrete,","np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert data.shape[0] == stateseq.shape[0] self.stateseq","list(model._occupied()) self.beta.housekeeping(ks) # form the scores and sample from them","= 0 # left transition score if t > 0:","+ ft) for k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx =","== stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k)","np.log( (alpha*betavec[k] + (kappa if k == stateseq[t-1] else 0)","self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert t >","betarest = 1-sum(betavec[k] for k in ks) # get the","for k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition","variables model = self.model alpha = self.alpha_0 beta = self.beta.betavec","scoring exchangeably, not independently) another_from = 1 if t >","self.beta.betavec, self.model, self.obs data, stateseq = self.data, self.stateseq score =","so that we can get the indicator sequence # TODO","data self.T = data.shape[0] def _generate(self,T): alpha = self.alpha_0 betavec","self.stateseq = stateseq elif stateseq is None: self.data = data","+ durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): ''' returns a sequence","== scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def","resample(self): model = self.model for t in np.random.permutation(self.T): # throw","# remove the used piece from the exclusion self.stateseq[piece] =","we may need to include the left transition in #","def fill(seq,t): if t < 0: return slice(0,0) elif t","self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp -= 1 return temp","restore original views self.stateseq = orig_stateseq # return return localgroup","beginning of seq return newlabel def _data_withlabel(self,k): assert k !=","counts of new states coming out of our current state","1 return temp def _counts_to(self,k): assert k != SAMPLING stateseq_norep,","sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t]","temporarily modifies members, like self.stateseq and maybe self.data assert self.stateseq[t]","state to start in; it's just a # definition choice","seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) != 0) #","self.obs data, stateseq = self.data, self.stateseq score = 0 #","anything that sets self.stateseq # also sets self.stateseq_norep and self.durations","that label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks","sample from them scores = np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)])","NOTE never changes first label: we assume the initial state","make no censoring by adding to score of last #","__init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model = model self.beta = beta","k2: return 0 else: stateseq_norep, _ = rle(self.stateseq) from_indices, =","alpha, kappa = self.alpha_0, self.kappa betavec, model, o = self.beta.betavec,","# NOTE never changes first label: we assume the initial","model = self.model self.stateseq = stateseq[:0] # NOTE: we have","in ks) # get the counts of new states coming","np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in right transition","= orig_stateseq[piece] # restore original views self.stateseq = orig_stateseq #","== B: return A, ((A,stateseq[A.start]),) elif A.start <= t <","np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in ks]) # for those","self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq = stateseq def resample(self):","from_indices, = np.where(stateseq_norep[:-1] == k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1]","self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run a","newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx]","np.where(stateseq_norep[:-1] == k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2)","self.stateseq: return 0 else: from_indices, = np.where(self.stateseq[:-1] == k1) #","# right transition score if t < self.T - 1:","# EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert","> 0 score = 0. # unpack variables model =","rle(self.stateseq) return durations[stateseq_norep == k] else: return [] def _counts_fromto(self,k1,k2):","= {} for k,v in canondict.iteritems(): reversedict[v] = k return","= self.model for t in np.random.permutation(self.T): # throw out old","data.shape[0] def _generate(self,T): self.T = T alpha, kappa = self.alpha_0,","k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:]","set methods # type(x).__setitem__(x,i) classmethod # also has members norep","alpha, kappa = self.alpha_0, self.kappa betavec = self.beta.betavec stateseq =","scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[idx] def _score(self,k,t):","self.dur # left transition (only from counts, no to counts)","def _label_score(self,t,k): assert t > 0 score = 0. #","# counts (since we are scoring exchangeably, not independently) another_from","canondict.iteritems(): reversedict[v] = k return seq, canondict, reversedict class dummytrans(object):","0 to abignumber exclusive #################### # States Classes # ####################","- x.start > 0] ####################### # Utility Functions # #######################","def plot(self,colors_dict): from matplotlib import pyplot as plt stateseq_norep, durations","canondict = collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx] = canondict[s]","- set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import pyplot as plt","durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not","-1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and","= alpha_0 self.kappa = kappa self.model = model self.beta =","labels are sampled uniformly from 0 to abignumber exclusive ####################","self._counts_fromto(stateseq[t-1],k) for k in ks]) # for those states plus","left transition (if there is one) if stateseq[t-1] != k:","== stateseq[t+1] else 0) + ft) for k,ft in zip(ks,fromto_counts)]","else: self.stateseq[t] = ks[idx] def _score(self,k,t): alpha, kappa = self.alpha_0,","assert t > 0 score = 0. # unpack variables","/ (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score if t <","import rle as rle # NOTE: assumes censoring. can make","0: return slice(0,0) elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else:","classmethod # also has members norep and lens (or something)","ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set the state if idx","assert T is not None, 'must pass in T when","<reponame>mattjj/pyhsmm-collapsedinfinite from __future__ import division import numpy as np na","score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): '''","+ model._counts_fromto(stateseq[t-1],k)) \\ - np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) #","wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build local","obs, durs = self.obs, self.dur # left transition (if there","sum over k factor if t < self.T-1: betas =","> 0] ####################### # Utility Functions # ####################### def fill(seq,t):","self.stateseq or k1 == k2: return 0 else: stateseq_norep, _","(since we are scoring exchangeably, not independently) another_from = 1","import numpy as np na = np.newaxis import collections, itertools","score if t > 0: score += np.log( (alpha*betavec[k] +","< T: ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k]","- np.log(alpha * (1-beta[k]) + model._counts_from(k)) # predictive likelihoods for","is not None: C = np.array([[colors_dict[state] for state in stateseq_norep]])","self.alpha_0 = alpha_0 self.kappa = kappa self.model = model self.beta","k in ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx","None, 'must pass in T when generating' self._generate(T) elif data","obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert t >","in ks: newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate,","t < self.T-1 and stateseq[t+1] != k: score += np.log(alpha","# NOTE: we have a choice of what state to","# generating assert T is not None, 'must pass in","k1 != SAMPLING and k2 != SAMPLING if k1 not","self.durations # it should also call beta updates... class collapsed_states(object):","ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t =","type(x).__setitem__(x,i) classmethod # also has members norep and lens (or","self.model = model self.beta = beta self.obs = obs self.dur","score = 0. # unpack variables model = self.model alpha","to all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for","t in range(1,T): self.stateseq = stateseq[:t] ks = list(model._occupied() |","in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx ==","state if idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t]","a sequence of length between 1 and 3, where each","states coming out of our current state # going to","== k) if SAMPLING in stateseq_norep[:-1] and \\ stateseq_norep[np.where(stateseq_norep ==","def resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k):","self.stateseq or k2 not in self.stateseq: return 0 else: from_indices,","stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data = data self.T =","= self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert","self._generate(data.shape[0]) # initialized from the prior # self.stateseq = self.stateseq[:self.T]","!= SAMPLING if k1 not in self.stateseq or k2 not","+ another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) ) # observation score","data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.data = data self.T","model = self.model for t in np.random.permutation(self.T): # throw out","fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores","transition (if there is one) if stateseq[t-1] != k: score","self._new_label(ks) else: stateseq[0] = ks[firststate] # runs a CRF with","pieces: # get all the other data otherdata, otherdurs =","its own rle # must override set methods # type(x).__setitem__(x,i)","np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None: C = np.array([[colors_dict[state] for","uniformly from 0 to abignumber exclusive #################### # States Classes","a CRF with fixed weights beta forwards for t in","SAMPLING)[0]+1] == k: temp -= 1 return temp def _counts_fromto(self,k1,k2):","score += o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha, kappa =","score def _local_group(self,t,k): ''' returns a sequence of length between","(or something) # that are either read-only or also override","updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self): pass","= SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) #","+= obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert t","(data,otherdata), (dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return","list(ks) # sample a new value scores = np.array([self._label_score(t,k) for","we choose just to sample from beta. Note that if","(dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score","special constant indicating a potentially new label ABIGNUMBER = 10000","plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0","alpha = self.alpha_0 beta = self.beta.betavec stateseq = self.stateseq obs,","(kappa if k == stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) +","temp def _counts_to(self,k): assert k != SAMPLING stateseq_norep, _ =","SAMPLING not in ks newlabel = np.random.randint(ABIGNUMBER) while newlabel in","not in self.stateseq: return 0 else: from_indices, = np.where(self.stateseq[:-1] ==","over k factor if t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200)","from beta. Note that if this is the # first","def _occupied(self): return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from matplotlib","t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks)","self.obs = obs self.data = data if (data,stateseq) == (None,None):","np.random.permutation(self.T): # throw out old value self.stateseq[t] = SAMPLING ks","(kappa if k == stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) /","piece, val in pieces: # get all the other data","kappa self.model = model self.beta = beta self.obs = obs","observation score score += o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert","!= k: score += np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\","group of statistics localgroup = [] self.stateseq[wholegroup] = SAMPLING for","0] ####################### # Utility Functions # ####################### def fill(seq,t): if","k == stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) /","k] def _occupied(self): return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from","0 and stateseq[t-1] == k else 0 another_fromto = 1","zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1:","left transition score if t > 0: betarest = 1-sum(betavec[k]","ks]) scores = np.array([(alpha*betavec[k] + ft if k != self.stateseq[t-1]","+ model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score if","_counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass","obs self.dur = dur self.data = data if (data,stateseq) ==","t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy() canondict =","np.log(alpha * (1-beta[k]) + model._counts_from(k)) # predictive likelihoods for (data,otherdata),","# special constant for indicating a state or state range","= np.array([]) ks = list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks)))","for t in range(1,T): self.stateseq = stateseq[:t] ks = list(model._occupied()","else: return [] def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and","not in self.stateseq or k1 == k2: return 0 else:","== scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate = ks[nextstateidx] #","= sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks) else:","# segment SAMPLING = -1 # special constant for indicating","for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs)","the state if idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else:","SAMPLING # build local group of statistics localgroup = []","self.stateseq[t] = ks[idx] def _score(self,k,t): alpha, kappa = self.alpha_0, self.kappa","self.obs, self.dur # left transition (only from counts, no to","= ks[idx] def _score(self,k,t): alpha, kappa = self.alpha_0, self.kappa betavec,","import collections, itertools import abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log,","predictive likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata)","a new value scores = np.array([self._label_score(t,k) for k in ks]","+= o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha, kappa = self.alpha_0,","0) # internal end indices (not incl -1 and T-1)","with fixed weights beta forwards for t in range(1,T): self.stateseq","= sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else:","stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data =","self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build local group of statistics","if k == stateseq[t+1] else 0) + ft) for k,ft","o = self.beta.betavec, self.model, self.obs data, stateseq = self.data, self.stateseq","np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition (if there","*= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) #","Functions # ####################### def fill(seq,t): if t < 0: return","''' returns slices: wholegroup, (piece1, ...) ''' A,B = fill(stateseq,t-1),","0 # left transition score if t > 0: betarest","# run a family-CRF (CRF with durations) forwards while t","assert self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy() # temporarily set","# first chain being sampled in this model, this will","+ [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t]","reversedict[v] = k return seq, canondict, reversedict class dummytrans(object): def","sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t]","in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def","incl -1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0","= self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model = self.model self.stateseq =","+= obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): ''' returns","self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks):","score score += o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha, kappa","other data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a","self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else:","if (data,stateseq) == (None,None): # generating assert T is not","score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert","nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks)","state in stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq)))","# States Classes # #################### # TODO an array class","scores = np.array([self._label_score(t,k) for k in ks] + [self._new_label_score(t,ks)]) newlabelidx","and stateseq[t+1] != k: score += np.log(alpha * beta[stateseq[t+1]] +","in range(1,T): self.stateseq = stateseq[:t] ks = list(model._occupied() | self._occupied())","in np.random.permutation(self.T): # throw out old value self.stateseq[t] = SAMPLING","B.start <= t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x","= self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs()","stateseq = self.stateseq obs, durs = self.obs, self.dur # left","betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining)","k != SAMPLING if len(self.stateseq) > 0: stateseq_norep, durations =","fill(stateseq,t+1) if A == B: return A, ((A,stateseq[A.start]),) elif A.start","distribution is a delta at that label for t in","< self.T - 1: # indicators since we may need","piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece","B: return A, ((A,stateseq[A.start]),) elif A.start <= t < A.stop","in (A,B) if x.stop - x.start > 0] else: It","model self.beta = beta self.obs = obs self.dur = dur","[None] firststate = sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0] =","= self.model alpha = self.alpha_0 beta = self.beta.betavec stateseq =","must override set methods # type(x).__setitem__(x,i) classmethod # also has","def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k != SAMPLING if","def _counts_from(self,k): assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq)","((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies members, like self.stateseq and","out old value self.stateseq[t] = SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks)","A == B: return A, ((A,stateseq[A.start]),) elif A.start <= t","canondict, reversedict class dummytrans(object): def __init__(self,A): self.A = A def","X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None: C =","= T alpha, kappa = self.alpha_0, self.kappa betavec = self.beta.betavec","== len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0] = ks[firststate] #","data self.T = data.shape[0] def _generate(self,T): self.T = T alpha,","seq = seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq):","we are scoring exchangeably, not independently) another_from = 1 if","self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy() # temporarily set stateseq","__future__ import division import numpy as np na = np.newaxis","x.start > 0] else: It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start])","self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert","right transition score if t < self.T - 1: #","== SAMPLING)[0]-1] == k: temp -= 1 return temp def","data.shape[0] else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep,","a state or state range that is being resampled NEW","+= np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in right","label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks =","localgroup = [] self.stateseq[wholegroup] = SAMPLING for piece, val in","rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k) if SAMPLING in stateseq_norep[1:]","from 0 to abignumber exclusive #################### # States Classes #","model, this will always sample # zero, since no states","# it should also call beta updates... class collapsed_states(object): __metaclass__","and \\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp -= 1","return score def _local_group(self,t,k): ''' returns a sequence of length","array class that maintains its own rle # must override","i write the special stateseq class, this will need fixing","np.array([]) ks = list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks))) if","rle(stateseq) self.data = data self.T = data.shape[0] def _generate(self,T): alpha","self.stateseq[t] = SAMPLING # build local group of statistics localgroup","from_indices, = np.where(self.stateseq[:-1] == k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1]","or state range that is being resampled NEW = -2","return 0 else: stateseq_norep, _ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1]","else: score += np.log(self.beta.remaining) # add in obs/dur scores of","self.data = data # self._generate(data.shape[0]) # initialized from the prior","data.shape[0] def _generate(self,T): alpha = self.alpha_0 betavec = self.beta.betavec model","sample from beta. Note that if this is the #","set the state if idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks)","= np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score","_new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa betavec, model, o =","# distribution is a delta at that label for t","self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.data","k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score","being sampled in this model, this will always sample #","transition in # counts (since we are scoring exchangeably, not","self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[idx] def _score(self,k,t): alpha,","model._counts_from(k)) # predictive likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score","sample_discrete_from_log, combinedata from pyhsmm.util.general import rle as rle # NOTE:","= np.array([(alpha*betavec[k] + ft if k != self.stateseq[t-1] else 0)","_occupied(self): return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import","obs/dur scores of local pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW):","...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A == B:","np.where(self.stateseq[:-1] == k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2)","in stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([])","states will be occupied. ks = list(model._occupied()) + [None] firststate","np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel = np.random.randint(ABIGNUMBER) newweight =","SAMPLING)[0]-1] == k: temp -= 1 return temp def _counts_to(self,k):","set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import pyplot as plt stateseq_norep,","not in self.stateseq or k2 not in self.stateseq: return 0","= ks[nextstateidx] self.stateseq = stateseq def resample(self): model = self.model","(if there is one) if stateseq[t-1] != k: score +=","np.log(self.beta.remaining) # add in obs/dur scores of local pieces for","from matplotlib import pyplot as plt stateseq_norep, durations = rle(self.stateseq)","(t > 0 and stateseq[t-1] == k and stateseq[t+1] ==","wholegroup, (piece1, ...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A","# throw out old value self.stateseq[t] = SAMPLING ks =","ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if t","plus a new one, sample proportional to scores = np.array([(alpha*betavec[k]","of length between 1 and 3, where each sequence element","if k1 not in self.stateseq or k2 not in self.stateseq","will always sample # zero, since no states will be","k) if SAMPLING in stateseq_norep[1:] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1]","== stateseq.shape[0] self.stateseq = stateseq self.data = data self.T =","self.alpha_0 = alpha_0 self.model = model self.beta = beta self.obs","0 # left transition score if t > 0: score","== scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[idx] def","> 0: stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep == k]","-= 1 return temp def _counts_fromto(self,k1,k2): assert k1 != SAMPLING","NOTE: we have a choice of what state to start","since we may need to include the left transition in","for x in (A,It,B) if x.stop - x.start > 0]","since no states will be occupied. ks = list(model._occupied()) +","TODO if i write the special stateseq class, this will","and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T","data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations = rle(stateseq)","betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else:","the special stateseq class, this will need fixing self.stateseq[t] =","self.stateseq[wholegroup] = SAMPLING for piece, val in pieces: # get","SAMPLING = -1 # special constant for indicating a state","= 0. # unpack model = self.model alpha = self.alpha_0","methods # type(x).__setitem__(x,i) classmethod # also has members norep and","= ks[firststate] # runs a CRF with fixed weights beta","None: self.data = data self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0]","in enumerate(seq): seq[idx] = canondict[s] reversedict = {} for k,v","!= SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1) temp =","if k1 not in self.stateseq or k2 not in self.stateseq:","T alpha, kappa = self.alpha_0, self.kappa betavec = self.beta.betavec stateseq","0 else: from_indices, = np.where(self.stateseq[:-1] == k1) # EXCEPT last","initial state # distribution is a delta at that label","stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k) if","if idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] =","[] self.stateseq[wholegroup] = SAMPLING for piece, val in pieces: #","= stateseq[:0] # NOTE: we have a choice of what","# for those states plus a new one, sample proportional","def _counts_from(self,k): assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING)","state at beginning of seq return newlabel def _data_withlabel(self,k): assert","score if t > 0: betarest = 1-sum(betavec[k] for k","self.beta = beta self.obs = obs self.dur = dur self.data","scores of local pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score","self.stateseq = orig_stateseq # return return localgroup @classmethod def _local_slices(cls,stateseq,t):","if nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate =","stateseq[t-1] != k: score += np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k))","_local_group(self,t,k): ''' returns a sequence of length between 1 and","firststate = sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0] = self._new_label(ks)","model._counts_from(stateseq[t-1])) # right transition (if there is one) if t","# add a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove","np.array([self._label_score(t,k) for k in ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores)","proportional to scores = np.array([(alpha*betavec[k] + (kappa if k ==","= stateseq[:t] ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k]","ks]) # for those states plus a new one, sample","nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T","-= 1 return temp def _counts_to(self,k): assert k != SAMPLING","# for now, i'll just make sure outside that anything","return self.data[self.stateseq == k] def _occupied(self): return set(self.stateseq) - set((SAMPLING,))","scores = np.array([(alpha*betavec[k] + ft if k != self.stateseq[t-1] else","C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def","rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1) # EXCEPT last return","we can get the indicator sequence # TODO if i","generating' self._generate(T) elif data is None: self.T = stateseq.shape[0] self.stateseq","durations) forwards while t < T: ks = list(model._occupied() |","stateseq elif stateseq is None: self.data = data self._generate(data.shape[0]) else:","0. # unpack variables model = self.model alpha = self.alpha_0","remove the used piece from the exclusion self.stateseq[piece] = orig_stateseq[piece]","length between 1 and 3, where each sequence element is","!= SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:] ==","to hypothetical stateseq # so that we can get the","np.log(betavec[stateseq[t+1]]) # observation score score += o.log_marginal_likelihood(data[t]) return score def","class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model = model","rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k) if SAMPLING in stateseq_norep[:-1]","a potentially new label ABIGNUMBER = 10000 # state labels","if newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] =","= SAMPLING # build local group of statistics localgroup =","in (0,1) temp = np.sum(self.stateseq[1:] == k) if SAMPLING in","SAMPLING return self.data[self.stateseq == k] def _occupied(self): return set(self.stateseq) -","in self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def","(dur,otherdurs)) ''' # temporarily modifies members, like self.stateseq and maybe","original views self.stateseq = orig_stateseq # return return localgroup @classmethod","(dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score","= canondict[s] reversedict = {} for k,v in canondict.iteritems(): reversedict[v]","will need fixing self.stateseq[t] = k wholegroup, pieces = self._local_slices(self.stateseq,t)","(0,1) temp = np.sum(self.stateseq[:-1] == k) if SAMPLING in self.stateseq[1:]","= kappa self.model = model self.beta = beta self.obs =","It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B)","__metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod def _counts_from(self,k):","SAMPLING in stateseq_norep[1:] and \\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k:","t > 0 score = 0. # unpack variables model","= np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel = np.random.randint(ABIGNUMBER) newweight","temp = np.sum(self.stateseq[:-1] == k) if SAMPLING in self.stateseq[1:] and","k: temp -= 1 return temp def _counts_fromto(self,k1,k2): assert k1","import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import rle as rle","t in np.random.permutation(self.T): # throw out old value self.stateseq[t] =","__init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa = kappa self.model = model","list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1:","definition choice that isn't specified in the HDP-HMM # Here,","\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp -= 1 return","_label_score(self,t,k): assert t > 0 score = 0. # unpack","as rle # NOTE: assumes censoring. can make no censoring","in pieces: # get all the other data otherdata, otherdurs","if stateseq[t-1] != k: score += np.log(alpha * beta[k] +","SAMPLING if len(self.stateseq) > 0: stateseq_norep, durations = rle(self.stateseq) return","# set the state if idx == scores.shape[0]-1: self.stateseq[t] =","k2 not in self.stateseq: return 0 else: from_indices, = np.where(self.stateseq[:-1]","self.durations = rle(stateseq) self.data = data self.T = data.shape[0] def","for k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores) if","np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1] == k)","= self._new_label(ks) else: nextstate = ks[nextstateidx] # now get the","- np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition (if","get the counts of new states coming out of our","return newlabel def _data_withlabel(self,k): assert k != SAMPLING return self.data[self.stateseq","slice(0,0) elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, =","sample a new value scores = np.array([self._label_score(t,k) for k in","np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) # add in obs/dur scores","= self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T =","T: ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for","fill(seq,t): if t < 0: return slice(0,0) elif t >","return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert k != SAMPLING"],"string":"[\n \"k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k\",\n \"self._occupied()) betarest = 1-sum(betavec[k] for k in ks) # get\",\n \"for k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for\",\n \"= np.where(np.diff(seq) != 0) # internal end indices (not incl\",\n \"+= np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) # add in obs/dur\",\n \"A, ((A,stateseq[A.start]),) elif A.start <= t < A.stop or B.start\",\n \"indicating a potentially new label ABIGNUMBER = 10000 # state\",\n \"in ks]) scores = np.array([(alpha*betavec[k] + ft if k !=\",\n \"# state labels are sampled uniformly from 0 to abignumber\",\n \"* (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition (if there is\",\n \"rle # must override set methods # type(x).__setitem__(x,i) classmethod #\",\n \"counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add\",\n \"returns a sequence of length between 1 and 3, where\",\n \"* beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\\\ - np.log(alpha * (1-beta[k]) +\",\n \"== k else 0 another_fromto = 1 if (t >\",\n \"scores = np.array([(alpha*betavec[k] + (kappa if k == stateseq[t+1] else\",\n \"slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B) if x.stop\",\n \"= np.where(self.stateseq[:-1] == k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1] ==\",\n \"transition score if t < self.T-1: score += np.log(betavec[stateseq[t+1]]) #\",\n \"[alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate =\",\n \"k factor if t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:]\",\n \"stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class\",\n \"!= SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] ==\",\n \"= beta self.obs = obs self.dur = dur self.data =\",\n \"self.stateseq score = 0 # left transition score if t\",\n \"choice of what state to start in; it's just a\",\n \"1 if (t > 0 and stateseq[t-1] == k and\",\n \"= 1-sum(betavec[k] for k in ks) # get the counts\",\n \"= firststate_dur # run a family-CRF (CRF with durations) forwards\",\n \"plt stateseq_norep, durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict\",\n \"def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k):\",\n \"sample proportional to scores = np.array([(alpha*betavec[k] + (kappa if k\",\n \"_new_label(self,ks): assert SAMPLING not in ks newlabel = np.random.randint(ABIGNUMBER) while\",\n \"self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur\",\n \"stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0\",\n \"0 score = 0. # unpack variables model = self.model\",\n \"# so that we can get the indicator sequence #\",\n \"states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in ks])\",\n \"while t < T: ks = list(model._occupied() | self._occupied()) betarest\",\n \"no censoring by adding to score of last # segment\",\n \"just make sure outside that anything that sets self.stateseq #\",\n \"= np.array([self._label_score(t,k) for k in ks] + [self._new_label_score(t,ks)]) newlabelidx =\",\n \"colors_dict is not None: C = np.array([[colors_dict[state] for state in\",\n \"kappa = self.alpha_0, self.kappa betavec, model, o = self.beta.betavec, self.model,\",\n \"self.kappa betavec, model, o = self.beta.betavec, self.model, self.obs data, stateseq\",\n \"t > 0: betarest = 1-sum(betavec[k] for k in ks)\",\n \"def _counts_to(self,k): assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq)\",\n \"counts) if t < self.T-1: score += np.log(beta[stateseq[t+1]]) # add\",\n \"not None: C = np.array([[colors_dict[state] for state in stateseq_norep]]) else:\",\n \"adding to score of last # segment SAMPLING = -1\",\n \"in self.stateseq or k1 == k2: return 0 else: stateseq_norep,\",\n \"# now get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur =\",\n \"beta updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self):\",\n \"stateseq[t] = ks[nextstateidx] self.stateseq = stateseq def resample(self): model =\",\n \"self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores = np.array([(alpha*betavec[k] + ft\",\n \"pyplot as plt stateseq_norep, durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1))\",\n \"betavec, model, o = self.beta.betavec, self.model, self.obs data, stateseq =\",\n \"one) if stateseq[t-1] != k: score += np.log(alpha * beta[k]\",\n \"= 1 if (t > 0 and stateseq[t-1] == k\",\n \"that maintains its own rle # must override set methods\",\n \"SAMPLING in self.stateseq[1:] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k:\",\n \"combinedata from pyhsmm.util.general import rle as rle # NOTE: assumes\",\n \"self.model._durs_withlabel(val) # add a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) #\",\n \"= self.model self.stateseq = np.array([]) ks = list(model._occupied()) + [None]\",\n \"def _generate(self,T): alpha = self.alpha_0 betavec = self.beta.betavec model =\",\n \"= stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None):\",\n \"and maybe self.data assert self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy()\",\n \"B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B) if x.stop\",\n \"members norep and lens (or something) # that are either\",\n \"# build local group of statistics localgroup = [] self.stateseq[wholegroup]\",\n \"(kappa if k == stateseq[t+1] else 0) + ft) for\",\n \"get the indicator sequence # TODO if i write the\",\n \"t > 0 and stateseq[t-1] == k else 0 another_fromto\",\n \"is one) if t < self.T-1 and stateseq[t+1] != k:\",\n \"def _new_label_score(self,t,ks): assert t > 0 score = 0. #\",\n \"if firststateidx == len(ks)-1: firststate = self._new_label(ks) else: firststate =\",\n \"= ks[newlabelidx] def _label_score(self,t,k): assert t > 0 score =\",\n \"return score def _new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa betavec,\",\n \"be occupied. ks = list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks)))\",\n \"= sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0] = self._new_label(ks) else:\",\n \"self.obs, self.dur # left transition (if there is one) if\",\n \"constant for indicating a state or state range that is\",\n \"\\\\ - np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition\",\n \"= np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq =\",\n \"as plt stateseq_norep, durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if\",\n \"in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in\",\n \"not None, 'must pass in T when generating' self._generate(T) elif\",\n \"of seq return newlabel def _data_withlabel(self,k): assert k != SAMPLING\",\n \"will be occupied. ks = list(model._occupied()) + [None] firststate =\",\n \"in self.stateseq or k2 not in self.stateseq or k1 ==\",\n \"slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B) if x.stop - x.start\",\n \"and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp -= 1\",\n \"assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp =\",\n \"== k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2) class\",\n \"if t < 0: return slice(0,0) elif t > seq.shape[0]-1:\",\n \"0 and stateseq[t-1] == k and stateseq[t+1] == k) else\",\n \"a delta at that label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t]\",\n \"have a choice of what state to start in; it's\",\n \"### label sampler stuff def resample_label_version(self): # NOTE never changes\",\n \"if SAMPLING in stateseq_norep[:-1] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] ==\",\n \"k in ks]) scores = np.array([(alpha*betavec[k] + ft if k\",\n \"self.resample_label_version() def _durs_withlabel(self,k): assert k != SAMPLING if len(self.stateseq) >\",\n \"np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T = len(self.stateseq) def resample(self): self.resample_label_version()\",\n \"+ model._counts_fromto(k,stateseq[t+1])) \\\\ - np.log(alpha * (1-beta[k]) + model._counts_from(k)) #\",\n \"np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate, needed if new state\",\n \"to counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) #\",\n \"nextstate = self._new_label(ks) else: nextstate = ks[nextstateidx] # now get\",\n \"last # segment SAMPLING = -1 # special constant for\",\n \"= data self.T = data.shape[0] def _generate(self,T): alpha = self.alpha_0\",\n \"SAMPLING for piece, val in pieces: # get all the\",\n \"@classmethod def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1, ...) '''\",\n \"value scores = np.array([self._label_score(t,k) for k in ks] + [self._new_label_score(t,ks)])\",\n \"internal end indices (not incl -1 and T-1) startindices =\",\n \"(if there is one) if t < self.T-1 and stateseq[t+1]\",\n \"new value scores = np.array([self._label_score(t,k) for k in ks] +\",\n \"it should also call beta updates... class collapsed_states(object): __metaclass__ =\",\n \"+ [None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate\",\n \"the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq =\",\n \"never changes first label: we assume the initial state #\",\n \"assert k != SAMPLING return self.data[self.stateseq == k] def _occupied(self):\",\n \"0] else: It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x\",\n \"if new state at beginning of seq return newlabel def\",\n \"def resample(self): model = self.model for t in np.random.permutation(self.T): #\",\n \"while newlabel in ks: newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel]\",\n \"views self.stateseq = orig_stateseq # return return localgroup @classmethod def\",\n \"local group of statistics localgroup = [] self.stateseq[wholegroup] = SAMPLING\",\n \"# restore original views self.stateseq = orig_stateseq # return return\",\n \"them scores = np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx =\",\n \"else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq =\",\n \"k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1]\",\n \"_counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2 != SAMPLING if\",\n \"stateseq is None: self.data = data self._generate(data.shape[0]) else: assert data.shape[0]\",\n \"'must pass in T when generating' self._generate(T) elif data is\",\n \"in the HDP-HMM # Here, we choose just to sample\",\n \"1-sum(betavec[k] for k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k)\",\n \"= self.stateseq obs, durs = self.obs, self.dur # left transition\",\n \"newlabel in ks: newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] #\",\n \"override set methods # type(x).__setitem__(x,i) classmethod # also has members\",\n \"another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) ) # observation score score\",\n \"stateseq[t+1] != k: score += np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1]))\",\n \"collections, itertools import abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata\",\n \"beta forwards for t in range(1,T): self.stateseq = stateseq[:t] ks\",\n \"len(ks)-1: firststate = self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur\",\n \"fixed weights beta forwards for t in range(1,T): self.stateseq =\",\n \"_ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k) if SAMPLING\",\n \"class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod\",\n \"k) else 0 score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa if\",\n \"else: stateseq[0] = ks[firststate] # runs a CRF with fixed\",\n \"betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model = self.model self.stateseq\",\n \"in this model, this will always sample # zero, since\",\n \"self.stateseq[t] = SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks = list(ks)\",\n \"self.stateseq[t] = SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) # form the\",\n \"in stateseq_norep[1:] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp\",\n \"else 0) + ft) for k,ft in zip(ks,fromto_counts)] + [alpha*betarest])\",\n \"from the exclusion self.stateseq[piece] = orig_stateseq[piece] # restore original views\",\n \"beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\\\ - np.log(alpha * (1-beta[k]) + model._counts_from(k))\",\n \"= SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) # form the scores\",\n \"score score += o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert k\",\n \"add a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the\",\n \"make sure outside that anything that sets self.stateseq # also\",\n \"score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) # add in\",\n \"# internal end indices (not incl -1 and T-1) startindices\",\n \"= self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece to our localgroup\",\n \"self.obs = obs self.dur = dur self.data = data if\",\n \"exclusive #################### # States Classes # #################### # TODO an\",\n \"# that are either read-only or also override setters #\",\n \"| self._occupied()) betarest = 1-sum(betavec[k] for k in ks) fromto_counts\",\n \"np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run a family-CRF (CRF with\",\n \"self.stateseq_norep, self.durations = rle(stateseq) self.data = data self.T = data.shape[0]\",\n \"self.stateseq[t] = k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING\",\n \"self.model, self.obs data, stateseq = self.data, self.stateseq score = 0\",\n \"\\\\ - np.log(alpha * (1-beta[k]) + model._counts_from(k)) # predictive likelihoods\",\n \"in right transition (no counts) if t < self.T-1: score\",\n \"1 if t > 0 and stateseq[t-1] == k else\",\n \"temp = np.sum(self.stateseq[1:] == k) if SAMPLING in self.stateseq[:-1] and\",\n \"# self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0]\",\n \"else: It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in\",\n \"that is being resampled NEW = -2 # special constant\",\n \"form the scores and sample from them scores = np.array([self._score(k,t)\",\n \"self._occupied()) betarest = 1-sum(betavec[k] for k in ks) fromto_counts =\",\n \"state # going to all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k)\",\n \"+ [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate\",\n \"import abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general\",\n \"(no counts) if t < self.T-1: score += np.log(beta[stateseq[t+1]]) #\",\n \"ks) # get the counts of new states coming out\",\n \"na = np.newaxis import collections, itertools import abc from pyhsmm.util.stats\",\n \"unpack model = self.model alpha = self.alpha_0 beta = self.beta.betavec\",\n \"# left transition (if there is one) if stateseq[t-1] !=\",\n \"self.stateseq[:-1] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp -=\",\n \"(A,B) if x.stop - x.start > 0] else: It =\",\n \"== k] else: return [] def _counts_fromto(self,k1,k2): assert k1 !=\",\n \"= self.beta.betavec model = self.model self.stateseq = np.array([]) ks =\",\n \"= rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k) if SAMPLING in\",\n \"_local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1, ...) ''' A,B =\",\n \"score += np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\\\ - np.log(alpha\",\n \"family-CRF (CRF with durations) forwards while t < T: ks\",\n \"t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B)\",\n \"== k) if SAMPLING in self.stateseq[1:] and \\\\ self.stateseq[np.where(self.stateseq ==\",\n \"one) if t < self.T-1 and stateseq[t+1] != k: score\",\n \"that if this is the # first chain being sampled\",\n \"C = np.array([[colors_dict[state] for state in stateseq_norep]]) else: C =\",\n \"# temporarily set stateseq to hypothetical stateseq # so that\",\n \"stateseq self.data = data self.T = data.shape[0] def _generate(self,T): self.T\",\n \"the other data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add\",\n \"slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) != 0) # internal end\",\n \"set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import pyplot as\",\n \"# also has members norep and lens (or something) #\",\n \"and T idx = np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def\",\n \"as np na = np.newaxis import collections, itertools import abc\",\n \"== k2) def _counts_from(self,k): assert k != SAMPLING stateseq_norep, _\",\n \"HDP-HMM # Here, we choose just to sample from beta.\",\n \"else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition\",\n \"# must override set methods # type(x).__setitem__(x,i) classmethod # also\",\n \"+ (kappa if k == stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k))\",\n \"= seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx]\",\n \"in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx ==\",\n \"pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import rle as\",\n \"# indicators since we may need to include the left\",\n \"= ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t\",\n \"return score def _new_label_score(self,t,ks): assert t > 0 score =\",\n \"list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1:\",\n \"!= SAMPLING and k2 != SAMPLING if k1 not in\",\n \"t < 0: return slice(0,0) elif t > seq.shape[0]-1: return\",\n \"those states plus a new one, sample proportional to scores\",\n \"temp -= 1 return temp def _counts_to(self,k): assert k !=\",\n \"self.beta.betavec stateseq = self.stateseq obs, durs = self.obs, self.dur #\",\n \"+= np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\\\ - np.log(alpha *\",\n \"self.data = data if (data,stateseq) == (None,None): # generating assert\",\n \"else: nextstate = ks[nextstateidx] # now get the duration of\",\n \"= np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T = len(self.stateseq) def resample(self):\",\n \"else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert t > 0\",\n \"k1 not in self.stateseq or k2 not in self.stateseq or\",\n \"\\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp -= 1 return\",\n \"+= np.log(beta[stateseq[t+1]]) # add in sum over k factor if\",\n \"rle # NOTE: assumes censoring. can make no censoring by\",\n \"= -2 # special constant indicating a potentially new label\",\n \"to scores = np.array([(alpha*betavec[k] + (kappa if k == stateseq[t+1]\",\n \"= sample_discrete_from_log(scores) # set the state if idx == scores.shape[0]-1:\",\n \"####################### # Utility Functions # ####################### def fill(seq,t): if t\",\n \"for k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set the\",\n \"(None,None): # generating assert T is not None, 'must pass\",\n \"> 0 and stateseq[t-1] == k else 0 another_fromto =\",\n \"= rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1) # EXCEPT last\",\n \"seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx] =\",\n \"def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2 != SAMPLING\",\n \"# type(x).__setitem__(x,i) classmethod # also has members norep and lens\",\n \"#################### # TODO an array class that maintains its own\",\n \"if x.stop - x.start > 0] ####################### # Utility Functions\",\n \"sample_discrete_from_log(scores) # set the state if idx == scores.shape[0]-1: self.stateseq[t]\",\n \"# add in sum over k factor if t <\",\n \"read-only or also override setters # for now, i'll just\",\n \"stateseq # so that we can get the indicator sequence\",\n \"assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations =\",\n \"this is the # first chain being sampled in this\",\n \"stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) +\",\n \"sampler stuff def resample_label_version(self): # NOTE never changes first label:\",\n \"firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur #\",\n \"self.data = data self.T = data.shape[0] def _generate(self,T): self.T =\",\n \"and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp -= 1\",\n \"EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert k\",\n \"used piece from the exclusion self.stateseq[piece] = orig_stateseq[piece] # restore\",\n \"#################### # States Classes # #################### # TODO an array\",\n \"np.sum(stateseq_norep[:-1] == k) if SAMPLING in stateseq_norep[1:] and \\\\ stateseq_norep[np.where(stateseq_norep\",\n \"= sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks) else:\",\n \"= rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k) if SAMPLING in\",\n \"return [] def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2\",\n \"k1 == k2: return 0 else: stateseq_norep, _ = rle(self.stateseq)\",\n \"assumes censoring. can make no censoring by adding to score\",\n \"class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa = kappa\",\n \"of local pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score +=\",\n \"stateseq = np.zeros(T,dtype=np.int) model = self.model self.stateseq = stateseq[:0] #\",\n \"(0,1) temp = np.sum(self.stateseq[1:] == k) if SAMPLING in self.stateseq[:-1]\",\n \"= np.array([(alpha*betavec[k] + (kappa if k == stateseq[t+1] else 0)\",\n \"+ self._counts_fromto(stateseq[t-1],k) for k in ks]) # for those states\",\n \"k2 not in self.stateseq or k1 == k2: return 0\",\n \"may need to include the left transition in # counts\",\n \"t < self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation score score\",\n \"# add in right transition (no counts) if t <\",\n \"+ [alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t]\",\n \"== k and stateseq[t+1] == k) else 0 score +=\",\n \"k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build\",\n \"in self.stateseq[:-1] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp\",\n \"CRF with fixed weights beta forwards for t in range(1,T):\",\n \"elif data is None: self.T = stateseq.shape[0] self.stateseq = stateseq\",\n \"= collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx] = canondict[s] reversedict\",\n \"''' # temporarily modifies members, like self.stateseq and maybe self.data\",\n \"changes first label: we assume the initial state # distribution\",\n \"betarest = 1-sum(betavec[k] for k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1])))\",\n \"= data.shape[0] def _generate(self,T): alpha = self.alpha_0 betavec = self.beta.betavec\",\n \"that we can get the indicator sequence # TODO if\",\n \"np.log(beta[stateseq[t+1]]) # add in sum over k factor if t\",\n \"at beginning of seq return newlabel def _data_withlabel(self,k): assert k\",\n \"np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if t < self.T-1: score\",\n \"ABIGNUMBER = 10000 # state labels are sampled uniformly from\",\n \"self.model for t in np.random.permutation(self.T): # throw out old value\",\n \"= self.beta.betavec, self.model, self.obs data, stateseq = self.data, self.stateseq score\",\n \"is one) if stateseq[t-1] != k: score += np.log(alpha *\",\n \"= self.stateseq.copy() # temporarily set stateseq to hypothetical stateseq #\",\n \"= list(ks) # sample a new value scores = np.array([self._label_score(t,k)\",\n \"exchangeably, not independently) another_from = 1 if t > 0\",\n \"chain being sampled in this model, this will always sample\",\n \"3, where each sequence element is ((data,otherdata), (dur,otherdurs)) ''' #\",\n \"fill(stateseq,t-1), fill(stateseq,t+1) if A == B: return A, ((A,stateseq[A.start]),) elif\",\n \"# left transition (only from counts, no to counts) score\",\n \"ks[nextstateidx] self.stateseq = stateseq def resample(self): model = self.model for\",\n \"T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T idx\",\n \"self.stateseq[1:] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp -=\",\n \"are scoring exchangeably, not independently) another_from = 1 if t\",\n \"another_from = 1 if t > 0 and stateseq[t-1] ==\",\n \"idx = np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq\",\n \"score = 0 # left transition score if t >\",\n \"and stateseq[t-1] == k else 0 another_fromto = 1 if\",\n \"t += nextstate_dur self.T = len(self.stateseq) def resample(self): self.resample_label_version() def\",\n \"stateseq is None: self.data = data # self._generate(data.shape[0]) # initialized\",\n \"transition score if t > 0: score += np.log( (alpha*betavec[k]\",\n \"score += o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert k !=\",\n \"k: score += np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\\\ -\",\n \"idx = sample_discrete_from_log(scores) # set the state if idx ==\",\n \"== SAMPLING)[0]+1] == k: temp -= 1 return temp def\",\n \"self.stateseq[piece] = orig_stateseq[piece] # restore original views self.stateseq = orig_stateseq\",\n \"stateseq_norep, durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is\",\n \"self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run a family-CRF\",\n \"rle as rle # NOTE: assumes censoring. can make no\",\n \"_score(self,k,t): alpha, kappa = self.alpha_0, self.kappa betavec, model, o =\",\n \"def canonize(seq): seq = seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s\",\n \"of last # segment SAMPLING = -1 # special constant\",\n \"collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx] = canondict[s] reversedict =\",\n \"newlabel = np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel = np.random.randint(ABIGNUMBER)\",\n \"= data if (data,stateseq) == (None,None): # generating assert T\",\n \"== SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1] == k) if\",\n \"temp -= 1 return temp def _counts_fromto(self,k1,k2): assert k1 !=\",\n \"self.dur = dur self.data = data if (data,stateseq) == (None,None):\",\n \"(piece1, ...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A ==\",\n \"== k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model\",\n \"add in sum over k factor if t < self.T-1:\",\n \"likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata) +\",\n \"self.stateseq = stateseq def resample(self): model = self.model for t\",\n \"choice that isn't specified in the HDP-HMM # Here, we\",\n \"< self.T-1: score += np.log(beta[stateseq[t+1]]) # add in sum over\",\n \"np.array([(alpha*betavec[k] + ft if k != self.stateseq[t-1] else 0) for\",\n \"or also override setters # for now, i'll just make\",\n \"class that maintains its own rle # must override set\",\n \"_new_label_score(self,t,ks): assert t > 0 score = 0. # unpack\",\n \"self.stateseq # also sets self.stateseq_norep and self.durations # it should\",\n \"sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0]\",\n \"self.T = data.shape[0] def _generate(self,T): alpha = self.alpha_0 betavec =\",\n \"stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right\",\n \"+ [None] firststate = sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0]\",\n \"if t < self.T - 1: # indicators since we\",\n \"hypothetical stateseq # so that we can get the indicator\",\n \"_counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING\",\n \"not in self.stateseq or k2 not in self.stateseq or k1\",\n \"_data_withlabel(self,k): assert k != SAMPLING return self.data[self.stateseq == k] def\",\n \"if t > 0: betarest = 1-sum(betavec[k] for k in\",\n \"k != SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1) temp\",\n \"return A, ((A,stateseq[A.start]),) elif A.start <= t < A.stop or\",\n \"# instantiate, needed if new state at beginning of seq\",\n \"in self.stateseq[1:] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp\",\n \"get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq\",\n \"in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks\",\n \"kappa = self.alpha_0, self.kappa betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int)\",\n \"beta = self.beta.betavec stateseq = self.stateseq obs, durs = self.obs,\",\n \"k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx\",\n \"+ model._counts_from(stateseq[t-1])) # right transition (if there is one) if\",\n \"k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model =\",\n \"10000 # state labels are sampled uniformly from 0 to\",\n \"rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None: C\",\n \"occupied. ks = list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks))) if\",\n \"self.T = len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k\",\n \"element is ((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies members, like\",\n \"self.data assert self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy() # temporarily\",\n \"<= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy() canondict\",\n \"localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1, ...)\",\n \"SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1]\",\n \"# form the scores and sample from them scores =\",\n \"first chain being sampled in this model, this will always\",\n \"> 0: betarest = 1-sum(betavec[k] for k in ks) score\",\n \"we assume the initial state # distribution is a delta\",\n \"are sampled uniformly from 0 to abignumber exclusive #################### #\",\n \"plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa =\",\n \"from counts, no to counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]])\",\n \"(alpha*betavec[stateseq[t+1]] + (kappa if k == stateseq[t+1] else 0) +\",\n \"o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert k != SAMPLING assert\",\n \"SAMPLING orig_stateseq = self.stateseq.copy() # temporarily set stateseq to hypothetical\",\n \"another_from) ) # observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return score\",\n \"we have a choice of what state to start in;\",\n \"= list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx ==\",\n \"else: stateseq[t] = ks[nextstateidx] self.stateseq = stateseq def resample(self): model\",\n \"of our current state # going to all other states\",\n \"indicator sequence # TODO if i write the special stateseq\",\n \"or B.start <= t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for\",\n \"division import numpy as np na = np.newaxis import collections,\",\n \"0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) )\",\n \"for k in ks]) # for those states plus a\",\n \"= np.sum(stateseq_norep[:-1] == k) if SAMPLING in stateseq_norep[1:] and \\\\\",\n \"return temp ### label sampler stuff def resample_label_version(self): # NOTE\",\n \"not in ks newlabel = np.random.randint(ABIGNUMBER) while newlabel in ks:\",\n \"A.stop or B.start <= t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start])\",\n \"> 0 and stateseq[t-1] == k and stateseq[t+1] == k)\",\n \"nextstate = ks[nextstateidx] # now get the duration of nextstate!\",\n \"SAMPLING if k1 not in self.stateseq or k2 not in\",\n \"indicators since we may need to include the left transition\",\n \"= abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass\",\n \"zero, since no states will be occupied. ks = list(model._occupied())\",\n \"newlabelidx = sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks)\",\n \"this will always sample # zero, since no states will\",\n \"norep and lens (or something) # that are either read-only\",\n \"startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T idx =\",\n \"new states coming out of our current state # going\",\n \"to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece from\",\n \"always sample # zero, since no states will be occupied.\",\n \"\\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp -= 1 return\",\n \"= np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) #\",\n \"for now, i'll just make sure outside that anything that\",\n \"own rle # must override set methods # type(x).__setitem__(x,i) classmethod\",\n \"include the left transition in # counts (since we are\",\n \"self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) # sample a new value\",\n \"score if t < self.T - 1: # indicators since\",\n \"= np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run a family-CRF (CRF\",\n \"temporarily set stateseq to hypothetical stateseq # so that we\",\n \"self.data, self.stateseq score = 0 # left transition score if\",\n \"stateseq_norep[1:] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp -=\",\n \"# going to all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) +\",\n \"t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) !=\",\n \"else: stateseq_norep, _ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1)\",\n \"self.T = data.shape[0] def _generate(self,T): self.T = T alpha, kappa\",\n \"need to include the left transition in # counts (since\",\n \"# return return localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns slices:\",\n \"reversedict class dummytrans(object): def __init__(self,A): self.A = A def resample(self,*args,**kwargs):\",\n \"= self.beta.betavec stateseq = self.stateseq obs, durs = self.obs, self.dur\",\n \"!= 0) # internal end indices (not incl -1 and\",\n \"data if (data,stateseq) == (None,None): # generating assert T is\",\n \"stateseq_norep[:-1] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp -=\",\n \"# get the counts of new states coming out of\",\n \"[None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate =\",\n \"setters # for now, i'll just make sure outside that\",\n \"# unpack model = self.model alpha = self.alpha_0 beta =\",\n \"stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k) if\",\n \"k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k):\",\n \"return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 =\",\n \"= 1-sum(betavec[k] for k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) #\",\n \"[alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t] =\",\n \"(1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition (if there is one)\",\n \"for k in ks) # get the counts of new\",\n \"self.kappa = kappa self.model = model self.beta = beta self.obs\",\n \"ks newlabel = np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel =\",\n \"= self.beta.betavec[newlabel] # instantiate, needed if new state at beginning\",\n \"= obs self.data = data if (data,stateseq) == (None,None): #\",\n \"= np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert data.shape[0] == stateseq.shape[0]\",\n \"_counts_from(self,k): assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp\",\n \"@abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING not in\",\n \"in ks]) # for those states plus a new one,\",\n \"np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0\",\n \"needed if new state at beginning of seq return newlabel\",\n \"ks[firststate] # runs a CRF with fixed weights beta forwards\",\n \"= 1 if t > 0 and stateseq[t-1] == k\",\n \"- x.start > 0] else: It = slice(t,t+1) return slice(A.start,B.stop),\",\n \"= stateseq.shape[0] self.stateseq = stateseq elif stateseq is None: self.data\",\n \"the scores and sample from them scores = np.array([self._score(k,t) for\",\n \"def _data_withlabel(self,k): assert k != SAMPLING return self.data[self.stateseq == k]\",\n \"score def _new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa betavec, model,\",\n \"in T when generating' self._generate(T) elif data is None: self.T\",\n \"abignumber exclusive #################### # States Classes # #################### # TODO\",\n \"k2 != SAMPLING if k1 not in self.stateseq or k2\",\n \"from the prior # self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0])\",\n \"returns slices: wholegroup, (piece1, ...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1)\",\n \"transition (no counts) if t < self.T-1: score += np.log(beta[stateseq[t+1]])\",\n \"plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa\",\n \"sure outside that anything that sets self.stateseq # also sets\",\n \"SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) # form the scores and\",\n \"self.T = T alpha, kappa = self.alpha_0, self.kappa betavec =\",\n \"statistics localgroup = [] self.stateseq[wholegroup] = SAMPLING for piece, val\",\n \"in ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx ==\",\n \"class dummytrans(object): def __init__(self,A): self.A = A def resample(self,*args,**kwargs): pass\",\n \"in self.stateseq or k2 not in self.stateseq: return 0 else:\",\n \"assert k != SAMPLING if len(self.stateseq) > 0: stateseq_norep, durations\",\n \"= obs self.dur = dur self.data = data if (data,stateseq)\",\n \"= self._new_label(ks) else: self.stateseq[t] = ks[idx] def _score(self,k,t): alpha, kappa\",\n \"self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T = len(self.stateseq)\",\n \"this will need fixing self.stateseq[t] = k wholegroup, pieces =\",\n \"self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert data.shape[0] ==\",\n \"firststate == len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0] = ks[firststate]\",\n \"each sequence element is ((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies\",\n \"obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): ''' returns a\",\n \"self.model alpha = self.alpha_0 beta = self.beta.betavec stateseq = self.stateseq\",\n \"old value self.stateseq[t] = SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) #\",\n \"if SAMPLING in stateseq_norep[1:] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] ==\",\n \"k != self.stateseq[t-1] else 0) for k,ft in zip(ks,fromto_counts)] +\",\n \"last return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert k !=\",\n \"newlabel def _data_withlabel(self,k): assert k != SAMPLING return self.data[self.stateseq ==\",\n \"len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0] = ks[firststate] # runs\",\n \"A.start <= t < A.stop or B.start <= t <\",\n \"return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import pyplot\",\n \"isn't specified in the HDP-HMM # Here, we choose just\",\n \"potentially new label ABIGNUMBER = 10000 # state labels are\",\n \"for state in stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1))\",\n \"_counts_to(self,k): assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING) in\",\n \"sequence element is ((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies members,\",\n \"plot(self,colors_dict): from matplotlib import pyplot as plt stateseq_norep, durations =\",\n \"self.model self.stateseq = stateseq[:0] # NOTE: we have a choice\",\n \"<= t < A.stop or B.start <= t < B.stop:\",\n \"call beta updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def\",\n \"assert k1 != SAMPLING and k2 != SAMPLING if k1\",\n \"def _generate(self,T): self.T = T alpha, kappa = self.alpha_0, self.kappa\",\n \"for k in ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if\",\n \"if firststate == len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0] =\",\n \"collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod def\",\n \"= self.obs, self.dur # left transition (only from counts, no\",\n \"0 score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k ==\",\n \"that anything that sets self.stateseq # also sets self.stateseq_norep and\",\n \"# Here, we choose just to sample from beta. Note\",\n \"o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa\",\n \"or k2 not in self.stateseq or k1 == k2: return\",\n \"''' returns a sequence of length between 1 and 3,\",\n \"pass def _new_label(self,ks): assert SAMPLING not in ks newlabel =\",\n \"return return localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup,\",\n \"1: # indicators since we may need to include the\",\n \"== stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data\",\n \"left transition in # counts (since we are scoring exchangeably,\",\n \"k in ks) # get the counts of new states\",\n \"EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None):\",\n \"t < T: ks = list(model._occupied() | self._occupied()) betarest =\",\n \"k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx\",\n \"_ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1) # EXCEPT\",\n \"None: self.T = stateseq.shape[0] self.stateseq = stateseq elif stateseq is\",\n \"== k2: return 0 else: stateseq_norep, _ = rle(self.stateseq) from_indices,\",\n \"= stateseq def resample(self): model = self.model for t in\",\n \"seq[idx] = canondict[s] reversedict = {} for k,v in canondict.iteritems():\",\n \"= k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING #\",\n \"+= np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if t < self.T-1:\",\n \"# #################### # TODO an array class that maintains its\",\n \"None: C = np.array([[colors_dict[state] for state in stateseq_norep]]) else: C\",\n \"= stateseq elif stateseq is None: self.data = data self._generate(data.shape[0])\",\n \"1-sum(betavec[k] for k in ks) # get the counts of\",\n \"nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t +=\",\n \"get all the other data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val)\",\n \"- 1: # indicators since we may need to include\",\n \"0 another_fromto = 1 if (t > 0 and stateseq[t-1]\",\n \"self.model = model self.beta = beta self.obs = obs self.data\",\n \"resample_label_version(self): # NOTE never changes first label: we assume the\",\n \"when generating' self._generate(T) elif data is None: self.T = stateseq.shape[0]\",\n \"otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece to\",\n \"scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k):\",\n \"betavec = self.beta.betavec model = self.model self.stateseq = np.array([]) ks\",\n \"val in pieces: # get all the other data otherdata,\",\n \"(alpha*betavec[k] + (kappa if k == stateseq[t-1] else 0) +\",\n \"score += np.log(betavec[stateseq[t+1]]) # observation score score += o.log_marginal_likelihood(data[t]) return\",\n \"the prior # self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T\",\n \"k return seq, canondict, reversedict class dummytrans(object): def __init__(self,A): self.A\",\n \"k: score += np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\\\ -\",\n \"model._counts_from(stateseq[t-1])) # add in right transition (no counts) if t\",\n \"sets self.stateseq_norep and self.durations # it should also call beta\",\n \"+ durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert t > 0\",\n \"# observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t):\",\n \"def _durs_withlabel(self,k): assert k != SAMPLING if len(self.stateseq) > 0:\",\n \"def _counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING not in ks\",\n \"< self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation score score +=\",\n \"return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B) if x.stop -\",\n \"transition (only from counts, no to counts) score += np.log(alpha)\",\n \"idx,s in enumerate(seq): seq[idx] = canondict[s] reversedict = {} for\",\n \"it's just a # definition choice that isn't specified in\",\n \"+ ft if k != self.stateseq[t-1] else 0) for k,ft\",\n \"new label ABIGNUMBER = 10000 # state labels are sampled\",\n \"lens (or something) # that are either read-only or also\",\n \"= rle(stateseq) self.data = data self.T = data.shape[0] def _generate(self,T):\",\n \"indicating a state or state range that is being resampled\",\n \"if t < self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation score\",\n \"0. # unpack model = self.model alpha = self.alpha_0 beta\",\n \"orig_stateseq[piece] # restore original views self.stateseq = orig_stateseq # return\",\n \"being resampled NEW = -2 # special constant indicating a\",\n \"obs self.data = data if (data,stateseq) == (None,None): # generating\",\n \"stateseq def resample(self): model = self.model for t in np.random.permutation(self.T):\",\n \"else 0 another_fromto = 1 if (t > 0 and\",\n \"add in obs/dur scores of local pieces for (data,otherdata), (dur,otherdurs)\",\n \"override setters # for now, i'll just make sure outside\",\n \"temp def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2 !=\",\n \"# get all the other data otherdata, otherdurs = self.model._data_withlabel(val),\",\n \"= np.sum(self.stateseq[1:] == k) if SAMPLING in self.stateseq[:-1] and \\\\\",\n \"k) if SAMPLING in self.stateseq[:-1] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1]\",\n \"scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq =\",\n \"ks[newlabelidx] def _label_score(self,t,k): assert t > 0 score = 0.\",\n \"slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy() canondict = collections.defaultdict(itertools.count().next) for\",\n \"(1-beta[k]) + model._counts_from(k)) # predictive likelihoods for (data,otherdata), (dur,otherdurs) in\",\n \"self.stateseq and maybe self.data assert self.stateseq[t] == SAMPLING orig_stateseq =\",\n \"t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score\",\n \"self.T-1 and stateseq[t+1] != k: score += np.log(alpha * beta[stateseq[t+1]]\",\n \"like self.stateseq and maybe self.data assert self.stateseq[t] == SAMPLING orig_stateseq\",\n \"''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A == B: return\",\n \"== k: temp -= 1 return temp def _counts_to(self,k): assert\",\n \"data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece\",\n \"and sample from them scores = np.array([self._score(k,t) for k in\",\n \"== scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq\",\n \"((A,stateseq[A.start]),) elif A.start <= t < A.stop or B.start <=\",\n \"self.beta.housekeeping(ks) # form the scores and sample from them scores\",\n \"return seq, canondict, reversedict class dummytrans(object): def __init__(self,A): self.A =\",\n \"# TODO if i write the special stateseq class, this\",\n \"if k == stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1]))\",\n \"\\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp -= 1 return\",\n \"0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score\",\n \"self.stateseq.copy() # temporarily set stateseq to hypothetical stateseq # so\",\n \"{} for k,v in canondict.iteritems(): reversedict[v] = k return seq,\",\n \"SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:] == k) if SAMPLING\",\n \"(data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return\",\n \"t > 0 score = 0. # unpack model =\",\n \"(not incl -1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl\",\n \"+ (kappa if k == stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1])\",\n \"fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in ks]) #\",\n \"self.data = data self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0] self.stateseq\",\n \"firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate\",\n \"newweight = self.beta.betavec[newlabel] # instantiate, needed if new state at\",\n \"of new states coming out of our current state #\",\n \"T when generating' self._generate(T) elif data is None: self.T =\",\n \"stateseq[t] = self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq = stateseq\",\n \"+ model._counts_from(stateseq[t-1])) # add in right transition (no counts) if\",\n \"= self.alpha_0, self.kappa betavec, model, o = self.beta.betavec, self.model, self.obs\",\n \"def _local_group(self,t,k): ''' returns a sequence of length between 1\",\n \"alpha_0 self.kappa = kappa self.model = model self.beta = beta\",\n \"one, sample proportional to scores = np.array([(alpha*betavec[k] + (kappa if\",\n \"in (0,1) temp = np.sum(self.stateseq[:-1] == k) if SAMPLING in\",\n \"0 and T idx = np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1])\",\n \"ks = list(ks) # sample a new value scores =\",\n \"in self.stateseq: return 0 else: from_indices, = np.where(self.stateseq[:-1] == k1)\",\n \"SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:]\",\n \"!= self.stateseq[t-1] else 0) for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest])\",\n \"all the other data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) #\",\n \"sequence of length between 1 and 3, where each sequence\",\n \"sequence # TODO if i write the special stateseq class,\",\n \"special constant for indicating a state or state range that\",\n \"nextstate_dur self.T = len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert\",\n \"label sampler stuff def resample_label_version(self): # NOTE never changes first\",\n \"newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate, needed if\",\n \"ks[idx] def _score(self,k,t): alpha, kappa = self.alpha_0, self.kappa betavec, model,\",\n \"prior # self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T =\",\n \"== k] def _occupied(self): return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict):\",\n \"= rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None:\",\n \"localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece from the exclusion\",\n \"= sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate = self._new_label(ks) else:\",\n \"0 score = 0. # unpack model = self.model alpha\",\n \"not independently) another_from = 1 if t > 0 and\",\n \"1 return temp def _counts_to(self,k): assert k != SAMPLING assert\",\n \"seq return newlabel def _data_withlabel(self,k): assert k != SAMPLING return\",\n \"else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) + another_from)\",\n \"otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece to our\",\n \"between 1 and 3, where each sequence element is ((data,otherdata),\",\n \"if (t > 0 and stateseq[t-1] == k and stateseq[t+1]\",\n \"np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert k != SAMPLING stateseq_norep,\",\n \") # right transition score if t < self.T -\",\n \"np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k == stateseq[t+1] else 0)\",\n \"= np.array([[colors_dict[state] for state in stateseq_norep]]) else: C = stateseq_norep[na,:]\",\n \"elif stateseq is None: self.data = data # self._generate(data.shape[0]) #\",\n \"if k != self.stateseq[t-1] else 0) for k,ft in zip(ks,fromto_counts)]\",\n \"self.alpha_0 betavec = self.beta.betavec model = self.model self.stateseq = np.array([])\",\n \"score = 0. # unpack model = self.model alpha =\",\n \"States Classes # #################### # TODO an array class that\",\n \"# runs a CRF with fixed weights beta forwards for\",\n \"== k) else 0 score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa\",\n \"to start in; it's just a # definition choice that\",\n \"* beta[k] + model._counts_fromto(stateseq[t-1],k)) \\\\ - np.log(alpha * (1-beta[stateseq[t-1]]) +\",\n \"1 return temp def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and\",\n \"0: betarest = 1-sum(betavec[k] for k in ks) score +=\",\n \"_counts_to(self,k): assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp\",\n \"going to all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k)\",\n \"collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model = model self.beta\",\n \"or k2 not in self.stateseq: return 0 else: from_indices, =\",\n \"data is None: self.T = stateseq.shape[0] self.stateseq = stateseq elif\",\n \"counts (since we are scoring exchangeably, not independently) another_from =\",\n \"self._new_label(ks) else: nextstate = ks[nextstateidx] # now get the duration\",\n \"slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B) if x.stop - x.start\",\n \"with durations) forwards while t < T: ks = list(model._occupied()\",\n \"obs, durs = self.obs, self.dur # left transition (only from\",\n \"observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha,\",\n \"for x in (A,B) if x.stop - x.start > 0]\",\n \"T is not None, 'must pass in T when generating'\",\n \"np.zeros(T,dtype=np.int) model = self.model self.stateseq = stateseq[:0] # NOTE: we\",\n \"another_fromto = 1 if (t > 0 and stateseq[t-1] ==\",\n \"nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t] = ks[nextstateidx]\",\n \"range that is being resampled NEW = -2 # special\",\n \"model._counts_fromto(stateseq[t-1],k)) \\\\ - np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right\",\n \"(only from counts, no to counts) score += np.log(alpha) -\",\n \"there is one) if t < self.T-1 and stateseq[t+1] !=\",\n \"something) # that are either read-only or also override setters\",\n \"= data # self._generate(data.shape[0]) # initialized from the prior #\",\n \"enumerate(seq): seq[idx] = canondict[s] reversedict = {} for k,v in\",\n \"= model self.beta = beta self.obs = obs self.dur =\",\n \"durs = self.obs, self.dur # left transition (if there is\",\n \"if colors_dict is not None: C = np.array([[colors_dict[state] for state\",\n \"== k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2) def\",\n \"@abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def\",\n \"else 0) for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx =\",\n \"= orig_stateseq # return return localgroup @classmethod def _local_slices(cls,stateseq,t): '''\",\n \"from them scores = np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx\",\n \"stuff def resample_label_version(self): # NOTE never changes first label: we\",\n \"local pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata)\",\n \"stateseq.shape[0] self.stateseq = stateseq elif stateseq is None: self.data =\",\n \"< B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B) if\",\n \"= -1 # special constant for indicating a state or\",\n \"to abignumber exclusive #################### # States Classes # #################### #\",\n \"_ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k) if SAMPLING\",\n \"else: from_indices, = np.where(self.stateseq[:-1] == k1) # EXCEPT last return\",\n \"self.stateseq = stateseq self.data = data self.T = data.shape[0] def\",\n \"other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in\",\n \"# unpack variables model = self.model alpha = self.alpha_0 beta\",\n \"indices (not incl -1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) #\",\n \"ks = list(model._occupied()) self.beta.housekeeping(ks) # form the scores and sample\",\n \"# zero, since no states will be occupied. ks =\",\n \"the exclusion self.stateseq[piece] = orig_stateseq[piece] # restore original views self.stateseq\",\n \"| self._occupied()) betarest = 1-sum(betavec[k] for k in ks) #\",\n \"= self.alpha_0 betavec = self.beta.betavec model = self.model self.stateseq =\",\n \"model self.beta = beta self.obs = obs self.data = data\",\n \"score def _new_label_score(self,t,ks): assert t > 0 score = 0.\",\n \"= 0. # unpack variables model = self.model alpha =\",\n \"in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set the state if\",\n \"either read-only or also override setters # for now, i'll\",\n \"to include the left transition in # counts (since we\",\n \"temp = np.sum(stateseq_norep[1:] == k) if SAMPLING in stateseq_norep[:-1] and\",\n \"np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\\\ - np.log(alpha * (1-beta[stateseq[t-1]])\",\n \"= [] self.stateseq[wholegroup] = SAMPLING for piece, val in pieces:\",\n \"self.kappa betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model = self.model\",\n \"= np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None: C = np.array([[colors_dict[state]\",\n \"ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for k\",\n \"np.sum(self.stateseq[1:] == k) if SAMPLING in self.stateseq[:-1] and \\\\ self.stateseq[np.where(self.stateseq\",\n \"if x.stop - x.start > 0] else: It = slice(t,t+1)\",\n \"an array class that maintains its own rle # must\",\n \"self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k):\",\n \"by adding to score of last # segment SAMPLING =\",\n \"right transition (if there is one) if t < self.T-1\",\n \"instantiate, needed if new state at beginning of seq return\",\n \"i'll just make sure outside that anything that sets self.stateseq\",\n \"runs a CRF with fixed weights beta forwards for t\",\n \"alpha = self.alpha_0 betavec = self.beta.betavec model = self.model self.stateseq\",\n \"current state # going to all other states fromto_counts =\",\n \"our current state # going to all other states fromto_counts\",\n \"self.stateseq obs, durs = self.obs, self.dur # left transition (if\",\n \"stateseq to hypothetical stateseq # so that we can get\",\n \"now, i'll just make sure outside that anything that sets\",\n \"== stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) #\",\n \"model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) ) # observation\",\n \"self.beta.housekeeping(ks) ks = list(ks) # sample a new value scores\",\n \"t = firststate_dur # run a family-CRF (CRF with durations)\",\n \"is the # first chain being sampled in this model,\",\n \"sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate\",\n \"== k) if SAMPLING in stateseq_norep[1:] and \\\\ stateseq_norep[np.where(stateseq_norep ==\",\n \"self.stateseq = stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data = data\",\n \"k,v in canondict.iteritems(): reversedict[v] = k return seq, canondict, reversedict\",\n \"0 else: stateseq_norep, _ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] ==\",\n \"k and stateseq[t+1] == k) else 0 score += np.log(\",\n \"def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks): assert\",\n \"= data self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0] self.stateseq =\",\n \"NEW = -2 # special constant indicating a potentially new\",\n \"k: temp -= 1 return temp ### label sampler stuff\",\n \"sampled in this model, this will always sample # zero,\",\n \"== SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:] == k) if\",\n \"k) if SAMPLING in self.stateseq[1:] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1]\",\n \"ks = list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks))) if firststate\",\n \"0) for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores)\",\n \"the initial state # distribution is a delta at that\",\n \"alpha_0 self.model = model self.beta = beta self.obs = obs\",\n \"modifies members, like self.stateseq and maybe self.data assert self.stateseq[t] ==\",\n \"# self._generate(data.shape[0]) # initialized from the prior # self.stateseq =\",\n \"self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp -= 1 return temp\",\n \"fixing self.stateseq[t] = k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] =\",\n \"< self.T-1 and stateseq[t+1] != k: score += np.log(alpha *\",\n \"A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A == B: return A,\",\n \"self.stateseq_norep and self.durations # it should also call beta updates...\",\n \"== k: temp -= 1 return temp def _counts_fromto(self,k1,k2): assert\",\n \"also sets self.stateseq_norep and self.durations # it should also call\",\n \"= self.model self.stateseq = stateseq[:0] # NOTE: we have a\",\n \"= np.sum(self.stateseq[:-1] == k) if SAMPLING in self.stateseq[1:] and \\\\\",\n \"transition score if t < self.T - 1: # indicators\",\n \"if A == B: return A, ((A,stateseq[A.start]),) elif A.start <=\",\n \"censoring. can make no censoring by adding to score of\",\n \"exclusion self.stateseq[piece] = orig_stateseq[piece] # restore original views self.stateseq =\",\n \"maybe self.data assert self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy() #\",\n \"seq, canondict, reversedict class dummytrans(object): def __init__(self,A): self.A = A\",\n \"# incl 0 and T idx = np.where(startindices <= t)[0][-1]\",\n \"== SAMPLING)[0]+1] == k: temp -= 1 return temp ###\",\n \"stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep == k] else: return\",\n \"= ks[nextstateidx] # now get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate))))\",\n \"if t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod()\",\n \"= self.data, self.stateseq score = 0 # left transition score\",\n \"the used piece from the exclusion self.stateseq[piece] = orig_stateseq[piece] #\",\n \"ks = list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx\",\n \"in; it's just a # definition choice that isn't specified\",\n \"self.stateseq[t-1] else 0) for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx\",\n \"durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert t > 0 score\",\n \"return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,B) if x.stop -\",\n \"x.start > 0] ####################### # Utility Functions # ####################### def\",\n \"in (A,It,B) if x.stop - x.start > 0] ####################### #\",\n \"betarest = 1-sum(betavec[k] for k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k)\",\n \"self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs)))\",\n \"forwards while t < T: ks = list(model._occupied() | self._occupied())\",\n \"pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod\",\n \"-= 1 return temp ### label sampler stuff def resample_label_version(self):\",\n \"+ model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) ) #\",\n \"durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): ''' returns a sequence of\",\n \"outside that anything that sets self.stateseq # also sets self.stateseq_norep\",\n \"model, o = self.beta.betavec, self.model, self.obs data, stateseq = self.data,\",\n \"left transition score if t > 0: score += np.log(\",\n \"return score def _counts_from(self,k): assert k != SAMPLING assert np.sum(self.stateseq\",\n \"start in; it's just a # definition choice that isn't\",\n \"all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k\",\n \"else: endindices, = np.where(np.diff(seq) != 0) # internal end indices\",\n \"first label: we assume the initial state # distribution is\",\n \"temp def _counts_to(self,k): assert k != SAMPLING assert np.sum(self.stateseq ==\",\n \"np.sum(stateseq_norep[1:] == k) if SAMPLING in stateseq_norep[:-1] and \\\\ stateseq_norep[np.where(stateseq_norep\",\n \"stateseq[:0] # NOTE: we have a choice of what state\",\n \"= np.sum(stateseq_norep[1:] == k) if SAMPLING in stateseq_norep[:-1] and \\\\\",\n \"write the special stateseq class, this will need fixing self.stateseq[t]\",\n \"self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum())\",\n \"np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\\\ - np.log(alpha * (1-beta[k])\",\n \"dur self.data = data if (data,stateseq) == (None,None): # generating\",\n \"score += np.log(beta[stateseq[t+1]]) # add in sum over k factor\",\n \"right transition (no counts) if t < self.T-1: score +=\",\n \"+= np.log( (alpha*betavec[k] + (kappa if k == stateseq[t-1] else\",\n \"score += np.log(self.beta.remaining) # add in obs/dur scores of local\",\n \"def _score(self,k,t): alpha, kappa = self.alpha_0, self.kappa betavec, model, o\",\n \"# TODO an array class that maintains its own rle\",\n \"and stateseq[t-1] == k and stateseq[t+1] == k) else 0\",\n \"score += np.log( (alpha*betavec[k] + (kappa if k == stateseq[t-1]\",\n \"from __future__ import division import numpy as np na =\",\n \"censoring by adding to score of last # segment SAMPLING\",\n \"ft) for k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores)\",\n \"# right transition (if there is one) if t <\",\n \"add in right transition (no counts) if t < self.T-1:\",\n \"k2) def _counts_from(self,k): assert k != SAMPLING stateseq_norep, _ =\",\n \"[(x,stateseq[x.start]) for x in (A,B) if x.stop - x.start >\",\n \"import division import numpy as np na = np.newaxis import\",\n \"[] def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2 !=\",\n \"= 1-sum(betavec[k] for k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) +\",\n \"+= np.log(self.beta.remaining) # add in obs/dur scores of local pieces\",\n \"firststateidx == len(ks)-1: firststate = self._new_label(ks) else: firststate = ks[firststateidx]\",\n \"= SAMPLING for piece, val in pieces: # get all\",\n \"np.array([[colors_dict[state] for state in stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1)\",\n \"self.data = data self.T = data.shape[0] def _generate(self,T): alpha =\",\n \"label ABIGNUMBER = 10000 # state labels are sampled uniformly\",\n \"orig_stateseq # return return localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns\",\n \"data self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq\",\n \"for k,ft in zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if\",\n \"ks: newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate, needed\",\n \"= list(model._occupied()) + [None] firststate = sample_discrete(np.arange(len(ks))) if firststate ==\",\n \"= slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B) if\",\n \"pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass def\",\n \"scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate = ks[nextstateidx] # now\",\n \"and lens (or something) # that are either read-only or\",\n \"temp = np.sum(stateseq_norep[:-1] == k) if SAMPLING in stateseq_norep[1:] and\",\n \"at that label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING\",\n \"constant indicating a potentially new label ABIGNUMBER = 10000 #\",\n \"k == stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) )\",\n \"self.stateseq obs, durs = self.obs, self.dur # left transition (only\",\n \"= list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for k in\",\n \"what state to start in; it's just a # definition\",\n \"!= SAMPLING if len(self.stateseq) > 0: stateseq_norep, durations = rle(self.stateseq)\",\n \"# ####################### def fill(seq,t): if t < 0: return slice(0,0)\",\n \"0) + ft) for k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx\",\n \"= dur self.data = data if (data,stateseq) == (None,None): #\",\n \"for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks = self.model._occupied()\",\n \"+= o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert k != SAMPLING\",\n \"just to sample from beta. Note that if this is\",\n \"temp -= 1 return temp ### label sampler stuff def\",\n \"build local group of statistics localgroup = [] self.stateseq[wholegroup] =\",\n \"_counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING not in ks newlabel\",\n \"assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1)\",\n \"beta[k] + model._counts_fromto(stateseq[t-1],k)) \\\\ - np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1]))\",\n \"for k,v in canondict.iteritems(): reversedict[v] = k return seq, canondict,\",\n \"self.stateseq or k2 not in self.stateseq or k1 == k2:\",\n \"self._generate(T) elif data is None: self.T = stateseq.shape[0] self.stateseq =\",\n \"data # self._generate(data.shape[0]) # initialized from the prior # self.stateseq\",\n \"of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t\",\n \"k != SAMPLING return self.data[self.stateseq == k] def _occupied(self): return\",\n \"stateseq_norep, _ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1) #\",\n \"+ another_from) ) # observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return\",\n \"= stateseq self.data = data self.T = data.shape[0] def _generate(self,T):\",\n \"self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model = self.model self.stateseq = stateseq[:0]\",\n \"if i write the special stateseq class, this will need\",\n \"itertools import abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from\",\n \"= data self.T = data.shape[0] def _generate(self,T): self.T = T\",\n \"/ (alpha+kappa+model._counts_from(k) + another_from) ) # observation score score +=\",\n \"transition (if there is one) if t < self.T-1 and\",\n \"+= np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k == stateseq[t+1] else\",\n \"(CRF with durations) forwards while t < T: ks =\",\n \"SAMPLING and k2 != SAMPLING if k1 not in self.stateseq\",\n \"ks[nextstateidx] # now get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur\",\n \"k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set the state\",\n \"self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert data.shape[0]\",\n \"and 3, where each sequence element is ((data,otherdata), (dur,otherdurs)) '''\",\n \"that are either read-only or also override setters # for\",\n \"in ks newlabel = np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel\",\n \"choose just to sample from beta. Note that if this\",\n \"duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate))\",\n \"from pyhsmm.util.general import rle as rle # NOTE: assumes censoring.\",\n \"stateseq[t+1] else 0) + ft) for k,ft in zip(ks,fromto_counts)] +\",\n \"now get the duration of nextstate! self.dur.resample(combinedata((model._durs_withlabel(nextstate),self._durs_withlabel(nextstate)))) nextstate_dur = self.dur.rvs()\",\n \"and self.durations # it should also call beta updates... class\",\n \"# EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def\",\n \"assert t > 0 score = 0. # unpack model\",\n \"zip(ks,fromto_counts)] + [alpha*(1-betavec[self.stateseq[t-1]])*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1:\",\n \"no to counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1]))\",\n \"the HDP-HMM # Here, we choose just to sample from\",\n \"firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate = self._new_label(ks)\",\n \"need fixing self.stateseq[t] = k wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t]\",\n \"maintains its own rle # must override set methods #\",\n \"np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in right transition (no counts)\",\n \"# temporarily modifies members, like self.stateseq and maybe self.data assert\",\n \"plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 =\",\n \"# NOTE: assumes censoring. can make no censoring by adding\",\n \"of what state to start in; it's just a #\",\n \"<= t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in\",\n \"= np.where(stateseq_norep[:-1] == k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1] ==\",\n \"# initialized from the prior # self.stateseq = self.stateseq[:self.T] self.stateseq\",\n \"resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k != SAMPLING if len(self.stateseq)\",\n \"return localgroup @classmethod def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1,\",\n \"firststate_dur # run a family-CRF (CRF with durations) forwards while\",\n \"t < self.T - 1: # indicators since we may\",\n \"x in (A,It,B) if x.stop - x.start > 0] #######################\",\n \"self.data[self.stateseq == k] def _occupied(self): return set(self.stateseq) - set((SAMPLING,)) def\",\n \"SAMPLING in stateseq_norep[:-1] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k:\",\n \"+ (kappa if k == stateseq[t+1] else 0) + ft)\",\n \"list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for k in ks)\",\n \"else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations\",\n \"scores = np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores)\",\n \"= np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate, needed if new\",\n \"if SAMPLING in self.stateseq[1:] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] ==\",\n \"matplotlib import pyplot as plt stateseq_norep, durations = rle(self.stateseq) X,Y\",\n \"for t in np.random.permutation(self.T): # throw out old value self.stateseq[t]\",\n \"endindices, = np.where(np.diff(seq) != 0) # internal end indices (not\",\n \"-2 # special constant indicating a potentially new label ABIGNUMBER\",\n \"no states will be occupied. ks = list(model._occupied()) + [None]\",\n \"(1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) # add\",\n \"new state at beginning of seq return newlabel def _data_withlabel(self,k):\",\n \"a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used\",\n \"stateseq[:t] ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for\",\n \") # observation score score += o.log_predictive(data[t],model._data_withlabel(k)) return score def\",\n \"def _new_label(self,ks): assert SAMPLING not in ks newlabel = np.random.randint(ABIGNUMBER)\",\n \"that sets self.stateseq # also sets self.stateseq_norep and self.durations #\",\n \"idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[idx]\",\n \"canonize(seq): seq = seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s in\",\n \"self.stateseq = stateseq[:0] # NOTE: we have a choice of\",\n \"= rle(self.stateseq) return durations[stateseq_norep == k] else: return [] def\",\n \"self._new_label(ks) else: self.stateseq[t] = ks[idx] def _score(self,k,t): alpha, kappa =\",\n \"np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores = np.array([(alpha*betavec[k]\",\n \"pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build local group\",\n \"Note that if this is the # first chain being\",\n \"the counts of new states coming out of our current\",\n \"= self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build local group of\",\n \"are either read-only or also override setters # for now,\",\n \"orig_stateseq = self.stateseq.copy() # temporarily set stateseq to hypothetical stateseq\",\n \"durations[stateseq_norep == k] else: return [] def _counts_fromto(self,k1,k2): assert k1\",\n \"-1 # special constant for indicating a state or state\",\n \"also has members norep and lens (or something) # that\",\n \"if nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t] =\",\n \"is ((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies members, like self.stateseq\",\n \"beta self.obs = obs self.dur = dur self.data = data\",\n \"= len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k !=\",\n \"np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score +=\",\n \"piece from the exclusion self.stateseq[piece] = orig_stateseq[piece] # restore original\",\n \"a # definition choice that isn't specified in the HDP-HMM\",\n \"range(1,T): self.stateseq = stateseq[:t] ks = list(model._occupied() | self._occupied()) betarest\",\n \"state or state range that is being resampled NEW =\",\n \"return temp def _counts_to(self,k): assert k != SAMPLING stateseq_norep, _\",\n \"== len(ks)-1: firststate = self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate))))\",\n \"= self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) # sample a new\",\n \"np na = np.newaxis import collections, itertools import abc from\",\n \"for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs)\",\n \"= data.shape[0] else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq\",\n \"state range that is being resampled NEW = -2 #\",\n \"throw out old value self.stateseq[t] = SAMPLING ks = list(model._occupied())\",\n \"a family-CRF (CRF with durations) forwards while t < T:\",\n \"- np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in right transition (no\",\n \"self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq\",\n \"assert SAMPLING not in ks newlabel = np.random.randint(ABIGNUMBER) while newlabel\",\n \"Classes # #################### # TODO an array class that maintains\",\n \"self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T = len(self.stateseq) def\",\n \"for idx,s in enumerate(seq): seq[idx] = canondict[s] reversedict = {}\",\n \"1 return temp ### label sampler stuff def resample_label_version(self): #\",\n \"for indicating a state or state range that is being\",\n \"generating assert T is not None, 'must pass in T\",\n \"SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k)\",\n \"from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import rle\",\n \"= np.zeros(T,dtype=np.int) model = self.model self.stateseq = stateseq[:0] # NOTE:\",\n \"self.stateseq = stateseq[:t] ks = list(model._occupied() | self._occupied()) betarest =\",\n \"== SAMPLING orig_stateseq = self.stateseq.copy() # temporarily set stateseq to\",\n \"sampled uniformly from 0 to abignumber exclusive #################### # States\",\n \"x.stop - x.start > 0] ####################### # Utility Functions #\",\n \"specified in the HDP-HMM # Here, we choose just to\",\n \"self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation score score += o.log_marginal_likelihood(data[t])\",\n \"is not None, 'must pass in T when generating' self._generate(T)\",\n \"= self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq = stateseq def\",\n \"len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k != SAMPLING\",\n \"k == stateseq[t+1] else 0) + ft) for k,ft in\",\n \"beta. Note that if this is the # first chain\",\n \"collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa = kappa self.model\",\n \"if SAMPLING in self.stateseq[:-1] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] ==\",\n \"np.where(np.diff(seq) != 0) # internal end indices (not incl -1\",\n \"_counts_from(self,k): assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING) in\",\n \"= np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in ks]) # for\",\n \"the # first chain being sampled in this model, this\",\n \"scores and sample from them scores = np.array([self._score(k,t) for k\",\n \"self.alpha_0, self.kappa betavec, model, o = self.beta.betavec, self.model, self.obs data,\",\n \"+ self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores = np.array([(alpha*betavec[k] +\",\n \"< A.stop or B.start <= t < B.stop: return slice(A.start,B.stop),\",\n \"our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece from the\",\n \"# special constant indicating a potentially new label ABIGNUMBER =\",\n \"def _new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa betavec, model, o\",\n \"self.model self.stateseq = np.array([]) ks = list(model._occupied()) + [None] firststateidx\",\n \"firststate = self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur =\",\n \"can get the indicator sequence # TODO if i write\",\n \"state labels are sampled uniformly from 0 to abignumber exclusive\",\n \"stateseq[t+1] == k) else 0 score += np.log( (alpha*betavec[stateseq[t+1]] +\",\n \"is None: self.data = data self._generate(data.shape[0]) else: assert data.shape[0] ==\",\n \"else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.data =\",\n \"assert np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1] ==\",\n \"< self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score +=\",\n \"SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) # sample\",\n \"in # counts (since we are scoring exchangeably, not independently)\",\n \"numpy as np na = np.newaxis import collections, itertools import\",\n \"t < A.stop or B.start <= t < B.stop: return\",\n \"ks = self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) # sample a\",\n \"0: stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep == k] else:\",\n \"just a # definition choice that isn't specified in the\",\n \"= np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T idx = np.where(startindices\",\n \"# left transition score if t > 0: score +=\",\n \"can make no censoring by adding to score of last\",\n \"_durs_withlabel(self,k): assert k != SAMPLING if len(self.stateseq) > 0: stateseq_norep,\",\n \"score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k == stateseq[t+1]\",\n \"assert np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:] ==\",\n \"= beta self.obs = obs self.data = data if (data,stateseq)\",\n \"ft if k != self.stateseq[t-1] else 0) for k,ft in\",\n \"[self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t] =\",\n \"sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import rle as rle #\",\n \"t > 0: score += np.log( (alpha*betavec[k] + (kappa if\",\n \"label: we assume the initial state # distribution is a\",\n \"T idx = np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq):\",\n \"and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp -= 1\",\n \"model = self.model self.stateseq = np.array([]) ks = list(model._occupied()) +\",\n \"right transition score if t < self.T-1: score += np.log(betavec[stateseq[t+1]])\",\n \"transition score if t > 0: betarest = 1-sum(betavec[k] for\",\n \"model._counts_fromto(k,stateseq[t+1])) \\\\ - np.log(alpha * (1-beta[k]) + model._counts_from(k)) # predictive\",\n \"# also sets self.stateseq_norep and self.durations # it should also\",\n \"resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass\",\n \"self.beta = beta self.obs = obs self.data = data if\",\n \"= self.alpha_0, self.kappa betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model\",\n \"None: self.data = data # self._generate(data.shape[0]) # initialized from the\",\n \"canondict[s] reversedict = {} for k,v in canondict.iteritems(): reversedict[v] =\",\n \"SAMPLING in self.stateseq[:-1] and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k:\",\n \"of statistics localgroup = [] self.stateseq[wholegroup] = SAMPLING for piece,\",\n \"and k2 != SAMPLING if k1 not in self.stateseq or\",\n \"def _local_slices(cls,stateseq,t): ''' returns slices: wholegroup, (piece1, ...) ''' A,B\",\n \"independently) another_from = 1 if t > 0 and stateseq[t-1]\",\n \"to sample from beta. Note that if this is the\",\n \"score of last # segment SAMPLING = -1 # special\",\n \"ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1:\",\n \"if t < self.T-1 and stateseq[t+1] != k: score +=\",\n \"k] else: return [] def _counts_fromto(self,k1,k2): assert k1 != SAMPLING\",\n \"stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k: temp -= 1 return temp\",\n \"also override setters # for now, i'll just make sure\",\n \"is None: self.T = stateseq.shape[0] self.stateseq = stateseq elif stateseq\",\n \"nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate = ks[nextstateidx]\",\n \"if t > 0: score += np.log( (alpha*betavec[k] + (kappa\",\n \"self.beta.betavec model = self.model self.stateseq = np.array([]) ks = list(model._occupied())\",\n \"> 0 score = 0. # unpack model = self.model\",\n \"== k: temp -= 1 return temp ### label sampler\",\n \"TODO an array class that maintains its own rle #\",\n \"(np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks =\",\n \"return slice(0,0) elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices,\",\n \"pyhsmm.util.general import rle as rle # NOTE: assumes censoring. can\",\n \"np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T idx = np.where(startindices <=\",\n \"factor if t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *=\",\n \"import pyplot as plt stateseq_norep, durations = rle(self.stateseq) X,Y =\",\n \"(alpha+kappa+model._counts_from(k) + another_from) ) # observation score score += o.log_predictive(data[t],model._data_withlabel(k))\",\n \"!= SAMPLING return self.data[self.stateseq == k] def _occupied(self): return set(self.stateseq)\",\n \"(alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score if t < self.T\",\n \"x.stop - x.start > 0] else: It = slice(t,t+1) return\",\n \"self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur\",\n \"= 10000 # state labels are sampled uniformly from 0\",\n \"score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in\",\n \"return temp def _counts_to(self,k): assert k != SAMPLING assert np.sum(self.stateseq\",\n \"stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp -= 1 return temp\",\n \"weights beta forwards for t in range(1,T): self.stateseq = stateseq[:t]\",\n \"(data,stateseq) == (None,None): # generating assert T is not None,\",\n \"where each sequence element is ((data,otherdata), (dur,otherdurs)) ''' # temporarily\",\n \"should also call beta updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta\",\n \"set stateseq to hypothetical stateseq # so that we can\",\n \"== (None,None): # generating assert T is not None, 'must\",\n \"1 and 3, where each sequence element is ((data,otherdata), (dur,otherdurs))\",\n \"@abc.abstractmethod def resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def\",\n \"####################### def fill(seq,t): if t < 0: return slice(0,0) elif\",\n \"states plus a new one, sample proportional to scores =\",\n \"there is one) if stateseq[t-1] != k: score += np.log(alpha\",\n \"SAMPLING)[0]+1] == k: temp -= 1 return temp ### label\",\n \"else 0 score += np.log( (alpha*betavec[stateseq[t+1]] + (kappa if k\",\n \"return temp def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and k2\",\n \"slices: wholegroup, (piece1, ...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if\",\n \"# right transition score if t < self.T-1: score +=\",\n \"delta at that label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] =\",\n \"to score of last # segment SAMPLING = -1 #\",\n \"score += np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\\\ - np.log(alpha\",\n \"has members norep and lens (or something) # that are\",\n \"np.sum(self.stateseq[:-1] == k) if SAMPLING in self.stateseq[1:] and \\\\ self.stateseq[np.where(self.stateseq\",\n \"k in ks]) # for those states plus a new\",\n \"self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert t > 0 score\",\n \"in canondict.iteritems(): reversedict[v] = k return seq, canondict, reversedict class\",\n \"> 0: score += np.log( (alpha*betavec[k] + (kappa if k\",\n \"def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model = model self.beta =\",\n \"k) if SAMPLING in stateseq_norep[:-1] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1]\",\n \"stateseq[0] = self._new_label(ks) else: stateseq[0] = ks[firststate] # runs a\",\n \"sets self.stateseq # also sets self.stateseq_norep and self.durations # it\",\n \"np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set\",\n \"self.T = data.shape[0] else: assert data.shape[0] == stateseq.shape[0] self.stateseq =\",\n \"forwards for t in range(1,T): self.stateseq = stateseq[:t] ks =\",\n \"sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1: firststate = self._new_label(ks) else: firststate\",\n \"= np.newaxis import collections, itertools import abc from pyhsmm.util.stats import\",\n \"# left transition score if t > 0: betarest =\",\n \"= k return seq, canondict, reversedict class dummytrans(object): def __init__(self,A):\",\n \"np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[1:] == k)\",\n \"is a delta at that label for t in (np.random.permutation(self.T-1)+1):\",\n \"durations = rle(self.stateseq) return durations[stateseq_norep == k] else: return []\",\n \"incl 0 and T idx = np.where(startindices <= t)[0][-1] return\",\n \"stateseq[t-1] == k and stateseq[t+1] == k) else 0 score\",\n \"model = self.model alpha = self.alpha_0 beta = self.beta.betavec stateseq\",\n \"x in (A,B) if x.stop - x.start > 0] else:\",\n \"pass @abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks): assert SAMPLING not\",\n \"k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states):\",\n \"is None: self.data = data # self._generate(data.shape[0]) # initialized from\",\n \"score if t < self.T-1: score += np.log(betavec[stateseq[t+1]]) # observation\",\n \"in sum over k factor if t < self.T-1: betas\",\n \"self.beta.betavec[newlabel] # instantiate, needed if new state at beginning of\",\n \"for k in ks]) scores = np.array([(alpha*betavec[k] + ft if\",\n \"self.T - 1: # indicators since we may need to\",\n \"< 0: return slice(0,0) elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0])\",\n \"NOTE: assumes censoring. can make no censoring by adding to\",\n \"= stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data = data self.T\",\n \"self.dur # left transition (if there is one) if stateseq[t-1]\",\n \"def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa = kappa self.model =\",\n \"def resample_label_version(self): # NOTE never changes first label: we assume\",\n \"len(self.stateseq) > 0: stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep ==\",\n \"segment SAMPLING = -1 # special constant for indicating a\",\n \"= self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert t\",\n \"class, this will need fixing self.stateseq[t] = k wholegroup, pieces\",\n \"nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks)\",\n \"1-sum(betavec[k] for k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right\",\n \"= alpha_0 self.model = model self.beta = beta self.obs =\",\n \"score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if t <\",\n \"> seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) != 0)\",\n \"coming out of our current state # going to all\",\n \"k else 0 another_fromto = 1 if (t > 0\",\n \"stateseq[0] = ks[firststate] # runs a CRF with fixed weights\",\n \"= stateseq elif stateseq is None: self.data = data #\",\n \"= self.obs, self.dur # left transition (if there is one)\",\n \"a new one, sample proportional to scores = np.array([(alpha*betavec[k] +\",\n \"counts, no to counts) score += np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) +\",\n \"left transition (only from counts, no to counts) score +=\",\n \"> 0] else: It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for\",\n \"_generate(self,T): self.T = T alpha, kappa = self.alpha_0, self.kappa betavec\",\n \"= np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores =\",\n \"stateseq[t-1] == k else 0 another_fromto = 1 if (t\",\n \"for piece, val in pieces: # get all the other\",\n \"= list(model._occupied()) self.beta.housekeeping(ks) # form the scores and sample from\",\n \"k1 not in self.stateseq or k2 not in self.stateseq: return\",\n \"if t > 0 and stateseq[t-1] == k else 0\",\n \"elif A.start <= t < A.stop or B.start <= t\",\n \"and stateseq[t+1] == k) else 0 score += np.log( (alpha*betavec[stateseq[t+1]]\",\n \"or k1 == k2: return 0 else: stateseq_norep, _ =\",\n \"the indicator sequence # TODO if i write the special\",\n \"_generate(self,T): alpha = self.alpha_0 betavec = self.beta.betavec model = self.model\",\n \"# definition choice that isn't specified in the HDP-HMM #\",\n \"SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k)\",\n \"pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) +\",\n \"(A,It,B) if x.stop - x.start > 0] ####################### # Utility\",\n \"state # distribution is a delta at that label for\",\n \"last return np.sum(self.stateseq[from_indices+1] == k2) class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0\",\n \"reversedict = {} for k,v in canondict.iteritems(): reversedict[v] = k\",\n \"!= k: score += np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\\\\",\n \"localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece from the exclusion self.stateseq[piece]\",\n \"# add in obs/dur scores of local pieces for (data,otherdata),\",\n \"members, like self.stateseq and maybe self.data assert self.stateseq[t] == SAMPLING\",\n \"pass in T when generating' self._generate(T) elif data is None:\",\n \"abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import\",\n \"SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1] == k) if SAMPLING\",\n \"else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states):\",\n \"resampled NEW = -2 # special constant indicating a potentially\",\n \"+= np.log(alpha * beta[stateseq[t+1]] + model._counts_fromto(k,stateseq[t+1])) \\\\ - np.log(alpha *\",\n \"this model, this will always sample # zero, since no\",\n \"return 0 else: from_indices, = np.where(self.stateseq[:-1] == k1) # EXCEPT\",\n \"in obs/dur scores of local pieces for (data,otherdata), (dur,otherdurs) in\",\n \"score def _counts_from(self,k): assert k != SAMPLING assert np.sum(self.stateseq ==\",\n \"return durations[stateseq_norep == k] else: return [] def _counts_fromto(self,k1,k2): assert\",\n \"= data.shape[0] def _generate(self,T): self.T = T alpha, kappa =\",\n \"stateseq elif stateseq is None: self.data = data # self._generate(data.shape[0])\",\n \"in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if\",\n \"beta self.obs = obs self.data = data if (data,stateseq) ==\",\n \"k: temp -= 1 return temp def _counts_to(self,k): assert k\",\n \"Here, we choose just to sample from beta. Note that\",\n \"self.alpha_0, self.kappa betavec = self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model =\",\n \"self.T-1: score += np.log(beta[stateseq[t+1]]) # add in sum over k\",\n \"if this is the # first chain being sampled in\",\n \"def _counts_to(self,k): assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING)\",\n \"= model self.beta = beta self.obs = obs self.data =\",\n \"t < self.T-1: score += np.log(beta[stateseq[t+1]]) # add in sum\",\n \"stateseq class, this will need fixing self.stateseq[t] = k wholegroup,\",\n \"unpack variables model = self.model alpha = self.alpha_0 beta =\",\n \"if t < self.T-1: score += np.log(beta[stateseq[t+1]]) # add in\",\n \"= fill(stateseq,t-1), fill(stateseq,t+1) if A == B: return A, ((A,stateseq[A.start]),)\",\n \"in stateseq_norep[:-1] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]+1] == k: temp\",\n \"out of our current state # going to all other\",\n \"[(x,stateseq[x.start]) for x in (A,It,B) if x.stop - x.start >\",\n \"np.array([(alpha*betavec[k] + (kappa if k == stateseq[t+1] else 0) +\",\n \"np.where(startindices <= t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy()\",\n \"value self.stateseq[t] = SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks) # form\",\n \"end indices (not incl -1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],)))\",\n \"for those states plus a new one, sample proportional to\",\n \"also call beta updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod\",\n \"= self._new_label(ks) else: stateseq[0] = ks[firststate] # runs a CRF\",\n \"initialized from the prior # self.stateseq = self.stateseq[:self.T] self.stateseq =\",\n \"elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq)\",\n \"# predictive likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score +=\",\n \"temp ### label sampler stuff def resample_label_version(self): # NOTE never\",\n \"model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score if t\",\n \"assume the initial state # distribution is a delta at\",\n \"durs = self.obs, self.dur # left transition (only from counts,\",\n \"run a family-CRF (CRF with durations) forwards while t <\",\n \"= self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run\",\n \"self.T = stateseq.shape[0] self.stateseq = stateseq elif stateseq is None:\",\n \"@abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass def _new_label(self,ks):\",\n \"elif stateseq is None: self.data = data self._generate(data.shape[0]) else: assert\",\n \"assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.data = data\",\n \"return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) != 0) # internal\",\n \"0: score += np.log( (alpha*betavec[k] + (kappa if k ==\",\n \"self.alpha_0 beta = self.beta.betavec stateseq = self.stateseq obs, durs =\",\n \"if k == stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto)\",\n \"new one, sample proportional to scores = np.array([(alpha*betavec[k] + (kappa\",\n \"+= np.log(betavec[stateseq[t+1]]) # observation score score += o.log_marginal_likelihood(data[t]) return score\",\n \"self.stateseq = np.array([]) ks = list(model._occupied()) + [None] firststateidx =\",\n \"the left transition in # counts (since we are scoring\",\n \"Utility Functions # ####################### def fill(seq,t): if t < 0:\",\n \"# observation score score += o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k):\",\n \"data, stateseq = self.data, self.stateseq score = 0 # left\",\n \"+ model._counts_from(k)) # predictive likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k):\",\n \"stateseq = self.data, self.stateseq score = 0 # left transition\",\n \"# Utility Functions # ####################### def fill(seq,t): if t <\",\n \"that isn't specified in the HDP-HMM # Here, we choose\",\n \"abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod\",\n \"if len(self.stateseq) > 0: stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep\",\n \"special stateseq class, this will need fixing self.stateseq[t] = k\",\n \"+= nextstate_dur self.T = len(self.stateseq) def resample(self): self.resample_label_version() def _durs_withlabel(self,k):\",\n \"* (1-beta[k]) + model._counts_from(k)) # predictive likelihoods for (data,otherdata), (dur,otherdurs)\",\n \"== k) if SAMPLING in self.stateseq[:-1] and \\\\ self.stateseq[np.where(self.stateseq ==\",\n \"is being resampled NEW = -2 # special constant indicating\",\n \"ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in ks])\",\n \"# sample a new value scores = np.array([self._label_score(t,k) for k\",\n \"sample # zero, since no states will be occupied. ks\",\n \"= self.alpha_0 beta = self.beta.betavec stateseq = self.stateseq obs, durs\",\n \"a choice of what state to start in; it's just\",\n \"stateseq.shape[0] self.stateseq = stateseq self.data = data self.T = data.shape[0]\",\n \"return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy() canondict = collections.defaultdict(itertools.count().next)\",\n \"np.newaxis import collections, itertools import abc from pyhsmm.util.stats import sample_discrete,\",\n \"np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert data.shape[0] == stateseq.shape[0] self.stateseq\",\n \"list(model._occupied()) self.beta.housekeeping(ks) # form the scores and sample from them\",\n \"= 0 # left transition score if t > 0:\",\n \"+ ft) for k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx =\",\n \"== stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) / (alpha+kappa+model._counts_from(k)\",\n \"np.log( (alpha*betavec[k] + (kappa if k == stateseq[t-1] else 0)\",\n \"self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert t >\",\n \"betarest = 1-sum(betavec[k] for k in ks) # get the\",\n \"for k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition\",\n \"variables model = self.model alpha = self.alpha_0 beta = self.beta.betavec\",\n \"scoring exchangeably, not independently) another_from = 1 if t >\",\n \"self.beta.betavec, self.model, self.obs data, stateseq = self.data, self.stateseq score =\",\n \"so that we can get the indicator sequence # TODO\",\n \"data self.T = data.shape[0] def _generate(self,T): alpha = self.alpha_0 betavec\",\n \"self.stateseq = stateseq elif stateseq is None: self.data = data\",\n \"+ durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): ''' returns a sequence\",\n \"== scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def\",\n \"resample(self): model = self.model for t in np.random.permutation(self.T): # throw\",\n \"# remove the used piece from the exclusion self.stateseq[piece] =\",\n \"we may need to include the left transition in #\",\n \"def fill(seq,t): if t < 0: return slice(0,0) elif t\",\n \"self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp -= 1 return temp\",\n \"restore original views self.stateseq = orig_stateseq # return return localgroup\",\n \"beginning of seq return newlabel def _data_withlabel(self,k): assert k !=\",\n \"counts of new states coming out of our current state\",\n \"1 return temp def _counts_to(self,k): assert k != SAMPLING stateseq_norep,\",\n \"sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t]\",\n \"temporarily modifies members, like self.stateseq and maybe self.data assert self.stateseq[t]\",\n \"state to start in; it's just a # definition choice\",\n \"seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, = np.where(np.diff(seq) != 0) #\",\n \"self.obs data, stateseq = self.data, self.stateseq score = 0 #\",\n \"anything that sets self.stateseq # also sets self.stateseq_norep and self.durations\",\n \"that label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks\",\n \"sample from them scores = np.array([self._score(k,t) for k in ks]+[self._new_score(ks,t)])\",\n \"NOTE never changes first label: we assume the initial state\",\n \"make no censoring by adding to score of last #\",\n \"__init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model = model self.beta = beta\",\n \"k2: return 0 else: stateseq_norep, _ = rle(self.stateseq) from_indices, =\",\n \"alpha, kappa = self.alpha_0, self.kappa betavec, model, o = self.beta.betavec,\",\n \"# NOTE never changes first label: we assume the initial\",\n \"model = self.model self.stateseq = stateseq[:0] # NOTE: we have\",\n \"in ks) # get the counts of new states coming\",\n \"np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in right transition\",\n \"= orig_stateseq[piece] # restore original views self.stateseq = orig_stateseq #\",\n \"== B: return A, ((A,stateseq[A.start]),) elif A.start <= t <\",\n \"np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for k in ks]) # for those\",\n \"self._new_label(ks) else: stateseq[t] = ks[nextstateidx] self.stateseq = stateseq def resample(self):\",\n \"from_indices, = np.where(stateseq_norep[:-1] == k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1]\",\n \"self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t = firststate_dur # run a\",\n \"newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx]\",\n \"np.where(stateseq_norep[:-1] == k1) # EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2)\",\n \"self.stateseq: return 0 else: from_indices, = np.where(self.stateseq[:-1] == k1) #\",\n \"# right transition score if t < self.T - 1:\",\n \"# EXCEPT last return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert\",\n \"> 0 score = 0. # unpack variables model =\",\n \"rle(self.stateseq) return durations[stateseq_norep == k] else: return [] def _counts_fromto(self,k1,k2):\",\n \"= {} for k,v in canondict.iteritems(): reversedict[v] = k return\",\n \"= self.model for t in np.random.permutation(self.T): # throw out old\",\n \"data.shape[0] def _generate(self,T): self.T = T alpha, kappa = self.alpha_0,\",\n \"k != SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:]\",\n \"set methods # type(x).__setitem__(x,i) classmethod # also has members norep\",\n \"alpha, kappa = self.alpha_0, self.kappa betavec = self.beta.betavec stateseq =\",\n \"scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[idx] def _score(self,k,t):\",\n \"self.dur # left transition (only from counts, no to counts)\",\n \"def _label_score(self,t,k): assert t > 0 score = 0. #\",\n \"# counts (since we are scoring exchangeably, not independently) another_from\",\n \"canondict.iteritems(): reversedict[v] = k return seq, canondict, reversedict class dummytrans(object):\",\n \"0 to abignumber exclusive #################### # States Classes # ####################\",\n \"- x.start > 0] ####################### # Utility Functions # #######################\",\n \"def plot(self,colors_dict): from matplotlib import pyplot as plt stateseq_norep, durations\",\n \"canondict = collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq): seq[idx] = canondict[s]\",\n \"- set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import pyplot as plt\",\n \"durations = rle(self.stateseq) X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not\",\n \"-1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and\",\n \"= alpha_0 self.kappa = kappa self.model = model self.beta =\",\n \"labels are sampled uniformly from 0 to abignumber exclusive ####################\",\n \"self._counts_fromto(stateseq[t-1],k) for k in ks]) # for those states plus\",\n \"left transition (if there is one) if stateseq[t-1] != k:\",\n \"== stateseq[t+1] else 0) + ft) for k,ft in zip(ks,fromto_counts)]\",\n \"else: self.stateseq[t] = ks[idx] def _score(self,k,t): alpha, kappa = self.alpha_0,\",\n \"assert t > 0 score = 0. # unpack variables\",\n \"/ (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score if t <\",\n \"import rle as rle # NOTE: assumes censoring. can make\",\n \"0: return slice(0,0) elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else:\",\n \"classmethod # also has members norep and lens (or something)\",\n \"ks]+[self._new_score(ks,t)]) idx = sample_discrete_from_log(scores) # set the state if idx\",\n \"assert T is not None, 'must pass in T when\",\n \"<reponame>mattjj/pyhsmm-collapsedinfinite from __future__ import division import numpy as np na\",\n \"score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): '''\",\n \"+ model._counts_fromto(stateseq[t-1],k)) \\\\ - np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) #\",\n \"wholegroup, pieces = self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build local\",\n \"obs, durs = self.obs, self.dur # left transition (if there\",\n \"sum over k factor if t < self.T-1: betas =\",\n \"> 0] ####################### # Utility Functions # ####################### def fill(seq,t):\",\n \"self.stateseq or k1 == k2: return 0 else: stateseq_norep, _\",\n \"(since we are scoring exchangeably, not independently) another_from = 1\",\n \"import numpy as np na = np.newaxis import collections, itertools\",\n \"score if t > 0: score += np.log( (alpha*betavec[k] +\",\n \"< T: ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k]\",\n \"- np.log(alpha * (1-beta[k]) + model._counts_from(k)) # predictive likelihoods for\",\n \"is not None: C = np.array([[colors_dict[state] for state in stateseq_norep]])\",\n \"self.alpha_0 = alpha_0 self.kappa = kappa self.model = model self.beta\",\n \"k in ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx\",\n \"None, 'must pass in T when generating' self._generate(T) elif data\",\n \"obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert t >\",\n \"in ks: newlabel = np.random.randint(ABIGNUMBER) newweight = self.beta.betavec[newlabel] # instantiate,\",\n \"t < self.T-1 and stateseq[t+1] != k: score += np.log(alpha\",\n \"# NOTE: we have a choice of what state to\",\n \"# generating assert T is not None, 'must pass in\",\n \"k1 != SAMPLING and k2 != SAMPLING if k1 not\",\n \"self.durations # it should also call beta updates... class collapsed_states(object):\",\n \"ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs() self.stateseq = np.ones(firststate_dur,dtype=int)*firststate t =\",\n \"type(x).__setitem__(x,i) classmethod # also has members norep and lens (or\",\n \"self.model = model self.beta = beta self.obs = obs self.dur\",\n \"score = 0. # unpack variables model = self.model alpha\",\n \"to all other states fromto_counts = np.array([model._counts_fromto(stateseq[t-1],k) + self._counts_fromto(stateseq[t-1],k) for\",\n \"t in range(1,T): self.stateseq = stateseq[:t] ks = list(model._occupied() |\",\n \"in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx ==\",\n \"state if idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t]\",\n \"a sequence of length between 1 and 3, where each\",\n \"states coming out of our current state # going to\",\n \"== k) if SAMPLING in stateseq_norep[:-1] and \\\\ stateseq_norep[np.where(stateseq_norep ==\",\n \"def resample(self): pass @abc.abstractmethod def _counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k):\",\n \"self.stateseq or k2 not in self.stateseq: return 0 else: from_indices,\",\n \"stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data = data self.T =\",\n \"= self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else: assert\",\n \"self._generate(data.shape[0]) # initialized from the prior # self.stateseq = self.stateseq[:self.T]\",\n \"!= SAMPLING if k1 not in self.stateseq or k2 not\",\n \"+ another_fromto) / (alpha+kappa+model._counts_from(k) + another_from) ) # observation score\",\n \"data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.data = data self.T\",\n \"model = self.model for t in np.random.permutation(self.T): # throw out\",\n \"fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k in ks]) scores\",\n \"transition (if there is one) if stateseq[t-1] != k: score\",\n \"self._new_label(ks) else: stateseq[0] = ks[firststate] # runs a CRF with\",\n \"pieces: # get all the other data otherdata, otherdurs =\",\n \"its own rle # must override set methods # type(x).__setitem__(x,i)\",\n \"np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None: C = np.array([[colors_dict[state] for\",\n \"uniformly from 0 to abignumber exclusive #################### # States Classes\",\n \"a CRF with fixed weights beta forwards for t in\",\n \"SAMPLING)[0]+1] == k: temp -= 1 return temp def _counts_fromto(self,k1,k2):\",\n \"score += o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha, kappa =\",\n \"score def _local_group(self,t,k): ''' returns a sequence of length between\",\n \"(or something) # that are either read-only or also override\",\n \"updates... class collapsed_states(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self): pass\",\n \"= SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks) ks = list(ks) #\",\n \"+= obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert t\",\n \"(data,otherdata), (dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return\",\n \"list(ks) # sample a new value scores = np.array([self._label_score(t,k) for\",\n \"we choose just to sample from beta. Note that if\",\n \"(dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score\",\n \"special constant indicating a potentially new label ABIGNUMBER = 10000\",\n \"plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0\",\n \"alpha = self.alpha_0 beta = self.beta.betavec stateseq = self.stateseq obs,\",\n \"(kappa if k == stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) +\",\n \"temp def _counts_to(self,k): assert k != SAMPLING stateseq_norep, _ =\",\n \"SAMPLING not in ks newlabel = np.random.randint(ABIGNUMBER) while newlabel in\",\n \"not in self.stateseq: return 0 else: from_indices, = np.where(self.stateseq[:-1] ==\",\n \"over k factor if t < self.T-1: betas = np.random.beta(1,self.beta.gamma_0,size=200)\",\n \"from beta. Note that if this is the # first\",\n \"def _occupied(self): return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from matplotlib\",\n \"t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks = self.model._occupied() self.beta.housekeeping(ks)\",\n \"self.obs = obs self.data = data if (data,stateseq) == (None,None):\",\n \"np.random.permutation(self.T): # throw out old value self.stateseq[t] = SAMPLING ks\",\n \"(kappa if k == stateseq[t-1] else 0) + model._counts_fromto(stateseq[t-1],k)) /\",\n \"piece, val in pieces: # get all the other data\",\n \"kappa self.model = model self.beta = beta self.obs = obs\",\n \"observation score score += o.log_marginal_likelihood(data[t]) return score def _counts_from(self,k): assert\",\n \"!= k: score += np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k)) \\\\\",\n \"group of statistics localgroup = [] self.stateseq[wholegroup] = SAMPLING for\",\n \"0] ####################### # Utility Functions # ####################### def fill(seq,t): if\",\n \"k == stateseq[t+1] else 0) + model._counts_fromto(k,stateseq[t+1]) + another_fromto) /\",\n \"k] def _occupied(self): return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from\",\n \"0 and stateseq[t-1] == k else 0 another_fromto = 1\",\n \"zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1:\",\n \"left transition score if t > 0: betarest = 1-sum(betavec[k]\",\n \"ks]) scores = np.array([(alpha*betavec[k] + ft if k != self.stateseq[t-1]\",\n \"+ model._counts_fromto(stateseq[t-1],k)) / (alpha+kappa+model._counts_from(stateseq[t-1])) ) # right transition score if\",\n \"_counts_from(self,k): pass @abc.abstractmethod def _counts_to(self,k): pass @abc.abstractmethod def _counts_fromto(self,k): pass\",\n \"obs self.dur = dur self.data = data if (data,stateseq) ==\",\n \"t)[0][-1] return slice(startindices[idx],startindices[idx+1]) def canonize(seq): seq = seq.copy() canondict =\",\n \"np.log(alpha * (1-beta[k]) + model._counts_from(k)) # predictive likelihoods for (data,otherdata),\",\n \"# special constant for indicating a state or state range\",\n \"= np.array([]) ks = list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks)))\",\n \"for t in range(1,T): self.stateseq = stateseq[:t] ks = list(model._occupied()\",\n \"else: return [] def _counts_fromto(self,k1,k2): assert k1 != SAMPLING and\",\n \"not in self.stateseq or k1 == k2: return 0 else:\",\n \"== scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate = ks[nextstateidx] #\",\n \"= sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks) else:\",\n \"# segment SAMPLING = -1 # special constant for indicating\",\n \"for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs)\",\n \"the state if idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else:\",\n \"SAMPLING # build local group of statistics localgroup = []\",\n \"self.stateseq[t] = ks[idx] def _score(self,k,t): alpha, kappa = self.alpha_0, self.kappa\",\n \"self.obs, self.dur # left transition (only from counts, no to\",\n \"= ks[idx] def _score(self,k,t): alpha, kappa = self.alpha_0, self.kappa betavec,\",\n \"import collections, itertools import abc from pyhsmm.util.stats import sample_discrete, sample_discrete_from_log,\",\n \"predictive likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata)\",\n \"a new value scores = np.array([self._label_score(t,k) for k in ks]\",\n \"+= o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha, kappa = self.alpha_0,\",\n \"0) # internal end indices (not incl -1 and T-1)\",\n \"with fixed weights beta forwards for t in range(1,T): self.stateseq\",\n \"= sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else:\",\n \"stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations = rle(stateseq) self.data =\",\n \"self._local_slices(self.stateseq,t) self.stateseq[t] = SAMPLING # build local group of statistics\",\n \"if k == stateseq[t+1] else 0) + ft) for k,ft\",\n \"o = self.beta.betavec, self.model, self.obs data, stateseq = self.data, self.stateseq\",\n \"np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition (if there\",\n \"*= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) #\",\n \"Functions # ####################### def fill(seq,t): if t < 0: return\",\n \"''' returns slices: wholegroup, (piece1, ...) ''' A,B = fill(stateseq,t-1),\",\n \"0 # left transition score if t > 0: betarest\",\n \"# run a family-CRF (CRF with durations) forwards while t\",\n \"assert self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy() # temporarily set\",\n \"# first chain being sampled in this model, this will\",\n \"+ [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores) if newlabelidx == scores.shape[0]-1: self.stateseq[t]\",\n \"reversedict[v] = k return seq, canondict, reversedict class dummytrans(object): def\",\n \"sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks) else: stateseq[t]\",\n \"in self._local_group(t,NEW): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def\",\n \"incl -1 and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0\",\n \"= self.beta.betavec stateseq = np.zeros(T,dtype=np.int) model = self.model self.stateseq =\",\n \"+= obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _local_group(self,t,k): ''' returns\",\n \"self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks):\",\n \"score score += o.log_predictive(data[t],model._data_withlabel(k)) return score def _new_score(self,ks,t): alpha, kappa\",\n \"other data otherdata, otherdurs = self.model._data_withlabel(val), self.model._durs_withlabel(val) # add a\",\n \"self.stateseq = self.stateseq[:self.T] self.stateseq = np.random.randint(25,size=data.shape[0]) self.T = data.shape[0] else:\",\n \"if (data,stateseq) == (None,None): # generating assert T is not\",\n \"score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def _new_label_score(self,t,ks): assert\",\n \"nextstateidx = sample_discrete(scores) if nextstateidx == scores.shape[0]-1: stateseq[t] = self._new_label(ks)\",\n \"state in stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq)))\",\n \"# States Classes # #################### # TODO an array class\",\n \"scores = np.array([self._label_score(t,k) for k in ks] + [self._new_label_score(t,ks)]) newlabelidx\",\n \"and stateseq[t+1] != k: score += np.log(alpha * beta[stateseq[t+1]] +\",\n \"in range(1,T): self.stateseq = stateseq[:t] ks = list(model._occupied() | self._occupied())\",\n \"in np.random.permutation(self.T): # throw out old value self.stateseq[t] = SAMPLING\",\n \"B.start <= t < B.stop: return slice(A.start,B.stop), [(x,stateseq[x.start]) for x\",\n \"= self._new_label(ks) else: firststate = ks[firststateidx] self.dur.resample(combinedata((model._durs_withlabel(firststate),self._durs_withlabel(firststate)))) firststate_dur = self.dur.rvs()\",\n \"stateseq = self.stateseq obs, durs = self.obs, self.dur # left\",\n \"betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining)\",\n \"k != SAMPLING if len(self.stateseq) > 0: stateseq_norep, durations =\",\n \"fill(stateseq,t+1) if A == B: return A, ((A,stateseq[A.start]),) elif A.start\",\n \"distribution is a delta at that label for t in\",\n \"< self.T - 1: # indicators since we may need\",\n \"piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove the used piece\",\n \"B: return A, ((A,stateseq[A.start]),) elif A.start <= t < A.stop\",\n \"in (A,B) if x.stop - x.start > 0] else: It\",\n \"model self.beta = beta self.obs = obs self.dur = dur\",\n \"[None] firststate = sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0] =\",\n \"= self.model alpha = self.alpha_0 beta = self.beta.betavec stateseq =\",\n \"must override set methods # type(x).__setitem__(x,i) classmethod # also has\",\n \"def resample(self): self.resample_label_version() def _durs_withlabel(self,k): assert k != SAMPLING if\",\n \"def _counts_from(self,k): assert k != SAMPLING stateseq_norep, _ = rle(self.stateseq)\",\n \"((data,otherdata), (dur,otherdurs)) ''' # temporarily modifies members, like self.stateseq and\",\n \"out old value self.stateseq[t] = SAMPLING ks = list(model._occupied()) self.beta.housekeeping(ks)\",\n \"A == B: return A, ((A,stateseq[A.start]),) elif A.start <= t\",\n \"canondict, reversedict class dummytrans(object): def __init__(self,A): self.A = A def\",\n \"X,Y = np.meshgrid(np.hstack((0,durations.cumsum())),(0,1)) if colors_dict is not None: C =\",\n \"= T alpha, kappa = self.alpha_0, self.kappa betavec = self.beta.betavec\",\n \"== len(ks)-1: stateseq[0] = self._new_label(ks) else: stateseq[0] = ks[firststate] #\",\n \"data self.T = data.shape[0] def _generate(self,T): self.T = T alpha,\",\n \"seq = seq.copy() canondict = collections.defaultdict(itertools.count().next) for idx,s in enumerate(seq):\",\n \"we are scoring exchangeably, not independently) another_from = 1 if\",\n \"self.stateseq[t] == SAMPLING orig_stateseq = self.stateseq.copy() # temporarily set stateseq\",\n \"__future__ import division import numpy as np na = np.newaxis\",\n \"x.start > 0] else: It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start])\",\n \"self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[newlabelidx] def _label_score(self,t,k): assert\",\n \"right transition score if t < self.T - 1: #\",\n \"== SAMPLING)[0]-1] == k: temp -= 1 return temp def\",\n \"data.shape[0] else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep,\",\n \"a state or state range that is being resampled NEW\",\n \"+= np.log(alpha) - np.log(alpha*(1.-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # add in right\",\n \"label for t in (np.random.permutation(self.T-1)+1): self.stateseq[t] = SAMPLING ks =\",\n \"localgroup = [] self.stateseq[wholegroup] = SAMPLING for piece, val in\",\n \"rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k) if SAMPLING in stateseq_norep[1:]\",\n \"from 0 to abignumber exclusive #################### # States Classes #\",\n \"model, this will always sample # zero, since no states\",\n \"# it should also call beta updates... class collapsed_states(object): __metaclass__\",\n \"and \\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]+1] == k: temp -= 1\",\n \"return score def _local_group(self,t,k): ''' returns a sequence of length\",\n \"array class that maintains its own rle # must override\",\n \"i write the special stateseq class, this will need fixing\",\n \"np.array([]) ks = list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks))) if\",\n \"rle(stateseq) self.data = data self.T = data.shape[0] def _generate(self,T): alpha\",\n \"self.stateseq[t] = SAMPLING # build local group of statistics localgroup\",\n \"from_indices, = np.where(self.stateseq[:-1] == k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1]\",\n \"or state range that is being resampled NEW = -2\",\n \"return 0 else: stateseq_norep, _ = rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1]\",\n \"else: score += np.log(self.beta.remaining) # add in obs/dur scores of\",\n \"self.data = data # self._generate(data.shape[0]) # initialized from the prior\",\n \"data.shape[0] def _generate(self,T): alpha = self.alpha_0 betavec = self.beta.betavec model\",\n \"sample from beta. Note that if this is the #\",\n \"set the state if idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks)\",\n \"= np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score\",\n \"_new_score(self,ks,t): alpha, kappa = self.alpha_0, self.kappa betavec, model, o =\",\n \"# distribution is a delta at that label for t\",\n \"self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.data\",\n \"k in ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score\",\n \"being sampled in this model, this will always sample #\",\n \"transition in # counts (since we are scoring exchangeably, not\",\n \"self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[idx] def _score(self,k,t): alpha,\",\n \"model._counts_from(k)) # predictive likelihoods for (data,otherdata), (dur,otherdurs) in self._local_group(t,k): score\",\n \"sample_discrete_from_log, combinedata from pyhsmm.util.general import rle as rle # NOTE:\",\n \"= np.array([(alpha*betavec[k] + ft if k != self.stateseq[t-1] else 0)\",\n \"_occupied(self): return set(self.stateseq) - set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import\",\n \"obs/dur scores of local pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW):\",\n \"...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A == B:\",\n \"np.where(self.stateseq[:-1] == k1) # EXCEPT last return np.sum(self.stateseq[from_indices+1] == k2)\",\n \"in stateseq_norep]]) else: C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([])\",\n \"states will be occupied. ks = list(model._occupied()) + [None] firststate\",\n \"np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel = np.random.randint(ABIGNUMBER) newweight =\",\n \"SAMPLING)[0]-1] == k: temp -= 1 return temp def _counts_to(self,k):\",\n \"set((SAMPLING,)) def plot(self,colors_dict): from matplotlib import pyplot as plt stateseq_norep,\",\n \"not in self.stateseq or k2 not in self.stateseq: return 0\",\n \"= ks[nextstateidx] self.stateseq = stateseq def resample(self): model = self.model\",\n \"(if there is one) if stateseq[t-1] != k: score +=\",\n \"np.log(self.beta.remaining) # add in obs/dur scores of local pieces for\",\n \"from matplotlib import pyplot as plt stateseq_norep, durations = rle(self.stateseq)\",\n \"(t > 0 and stateseq[t-1] == k and stateseq[t+1] ==\",\n \"wholegroup, (piece1, ...) ''' A,B = fill(stateseq,t-1), fill(stateseq,t+1) if A\",\n \"# throw out old value self.stateseq[t] = SAMPLING ks =\",\n \"ks) score += np.log(alpha*betarest/(alpha+kappa+model._counts_from(stateseq[t-1]))) # right transition score if t\",\n \"plus a new one, sample proportional to scores = np.array([(alpha*betavec[k]\",\n \"of length between 1 and 3, where each sequence element\",\n \"if k1 not in self.stateseq or k2 not in self.stateseq\",\n \"will always sample # zero, since no states will be\",\n \"k) if SAMPLING in stateseq_norep[1:] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1]\",\n \"== stateseq.shape[0] self.stateseq = stateseq self.data = data self.T =\",\n \"self.alpha_0 = alpha_0 self.model = model self.beta = beta self.obs\",\n \"0 # left transition score if t > 0: score\",\n \"== scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] = ks[idx] def\",\n \"> 0: stateseq_norep, durations = rle(self.stateseq) return durations[stateseq_norep == k]\",\n \"-= 1 return temp def _counts_fromto(self,k1,k2): assert k1 != SAMPLING\",\n \"NOTE: we have a choice of what state to start\",\n \"since we may need to include the left transition in\",\n \"for x in (A,It,B) if x.stop - x.start > 0]\",\n \"since no states will be occupied. ks = list(model._occupied()) +\",\n \"TODO if i write the special stateseq class, this will\",\n \"and T-1) startindices = np.concatenate(((0,),endindices+1,(seq.shape[0],))) # incl 0 and T\",\n \"data.shape[0] == stateseq.shape[0] self.stateseq = stateseq self.stateseq_norep, self.durations = rle(stateseq)\",\n \"betas = np.random.beta(1,self.beta.gamma_0,size=200) betas[1:] *= (1-betas[:-1]).cumprod() score += np.log(self.beta.remaining*(betas/(1-betas)).sum()) else:\",\n \"the special stateseq class, this will need fixing self.stateseq[t] =\",\n \"self.stateseq[wholegroup] = SAMPLING for piece, val in pieces: # get\",\n \"SAMPLING = -1 # special constant for indicating a state\",\n \"= 0. # unpack model = self.model alpha = self.alpha_0\",\n \"methods # type(x).__setitem__(x,i) classmethod # also has members norep and\",\n \"= ks[firststate] # runs a CRF with fixed weights beta\",\n \"None: self.data = data self._generate(data.shape[0]) else: assert data.shape[0] == stateseq.shape[0]\",\n \"in enumerate(seq): seq[idx] = canondict[s] reversedict = {} for k,v\",\n \"!= SAMPLING assert np.sum(self.stateseq == SAMPLING) in (0,1) temp =\",\n \"if k1 not in self.stateseq or k2 not in self.stateseq:\",\n \"T alpha, kappa = self.alpha_0, self.kappa betavec = self.beta.betavec stateseq\",\n \"0 else: from_indices, = np.where(self.stateseq[:-1] == k1) # EXCEPT last\",\n \"initial state # distribution is a delta at that label\",\n \"stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[:-1] == k) if\",\n \"if idx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] =\",\n \"[] self.stateseq[wholegroup] = SAMPLING for piece, val in pieces: #\",\n \"= stateseq[:0] # NOTE: we have a choice of what\",\n \"# for those states plus a new one, sample proportional\",\n \"def _counts_from(self,k): assert k != SAMPLING assert np.sum(self.stateseq == SAMPLING)\",\n \"state at beginning of seq return newlabel def _data_withlabel(self,k): assert\",\n \"score if t > 0: betarest = 1-sum(betavec[k] for k\",\n \"self.beta = beta self.obs = obs self.dur = dur self.data\",\n \"scores of local pieces for (data,otherdata), (dur,otherdurs) in self._local_group(t,NEW): score\",\n \"self.stateseq = orig_stateseq # return return localgroup @classmethod def _local_slices(cls,stateseq,t):\",\n \"if nextstateidx == scores.shape[0]-1: nextstate = self._new_label(ks) else: nextstate =\",\n \"stateseq[t-1] != k: score += np.log(alpha * beta[k] + model._counts_fromto(stateseq[t-1],k))\",\n \"_local_group(self,t,k): ''' returns a sequence of length between 1 and\",\n \"firststate = sample_discrete(np.arange(len(ks))) if firststate == len(ks)-1: stateseq[0] = self._new_label(ks)\",\n \"model._counts_from(stateseq[t-1])) # right transition (if there is one) if t\",\n \"# add a piece to our localgroup localgroup.append(((self.data[piece],otherdata),(piece.stop-piece.start,otherdurs))) # remove\",\n \"np.array([self._label_score(t,k) for k in ks] + [self._new_label_score(t,ks)]) newlabelidx = sample_discrete_from_log(scores)\",\n \"proportional to scores = np.array([(alpha*betavec[k] + (kappa if k ==\",\n \"= stateseq[:t] ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k]\",\n \"ks]) # for those states plus a new one, sample\",\n \"nextstate_dur = self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T\",\n \"-= 1 return temp def _counts_to(self,k): assert k != SAMPLING\",\n \"# for now, i'll just make sure outside that anything\",\n \"return self.data[self.stateseq == k] def _occupied(self): return set(self.stateseq) - set((SAMPLING,))\",\n \"scores = np.array([(alpha*betavec[k] + ft if k != self.stateseq[t-1] else\",\n \"C = stateseq_norep[na,:] plt.pcolor(X,Y,C,vmin=0,vmax=1) plt.ylim((0,1)) plt.xlim((0,len(self.stateseq))) plt.yticks([]) class collapsed_stickyhdphmm_states(collapsed_states): def\",\n \"rle(self.stateseq) from_indices, = np.where(stateseq_norep[:-1] == k1) # EXCEPT last return\",\n \"we can get the indicator sequence # TODO if i\",\n \"generating' self._generate(T) elif data is None: self.T = stateseq.shape[0] self.stateseq\",\n \"durations) forwards while t < T: ks = list(model._occupied() |\",\n \"stateseq elif stateseq is None: self.data = data self._generate(data.shape[0]) else:\",\n \"0. # unpack variables model = self.model alpha = self.alpha_0\",\n \"remove the used piece from the exclusion self.stateseq[piece] = orig_stateseq[piece]\",\n \"length between 1 and 3, where each sequence element is\",\n \"!= SAMPLING stateseq_norep, _ = rle(self.stateseq) temp = np.sum(stateseq_norep[1:] ==\",\n \"to hypothetical stateseq # so that we can get the\",\n \"np.log(betavec[stateseq[t+1]]) # observation score score += o.log_marginal_likelihood(data[t]) return score def\",\n \"class collapsed_hdphsmm_states(collapsed_states): def __init__(self,model,beta,alpha_0,obs,dur,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.model = model\",\n \"rle(self.stateseq) temp = np.sum(stateseq_norep[1:] == k) if SAMPLING in stateseq_norep[:-1]\",\n \"a potentially new label ABIGNUMBER = 10000 # state labels\",\n \"if newlabelidx == scores.shape[0]-1: self.stateseq[t] = self._new_label(ks) else: self.stateseq[t] =\",\n \"= SAMPLING # build local group of statistics localgroup =\",\n \"in (0,1) temp = np.sum(self.stateseq[1:] == k) if SAMPLING in\",\n \"SAMPLING return self.data[self.stateseq == k] def _occupied(self): return set(self.stateseq) -\",\n \"in self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score def\",\n \"(dur,otherdurs)) ''' # temporarily modifies members, like self.stateseq and maybe\",\n \"original views self.stateseq = orig_stateseq # return return localgroup @classmethod\",\n \"(dur,otherdurs) in self._local_group(t,k): score += obs.log_predictive(data,otherdata) + durs.log_predictive(dur,otherdurs) return score\",\n \"= canondict[s] reversedict = {} for k,v in canondict.iteritems(): reversedict[v]\",\n \"will need fixing self.stateseq[t] = k wholegroup, pieces = self._local_slices(self.stateseq,t)\",\n \"(0,1) temp = np.sum(self.stateseq[:-1] == k) if SAMPLING in self.stateseq[1:]\",\n \"= kappa self.model = model self.beta = beta self.obs =\",\n \"It = slice(t,t+1) return slice(A.start,B.stop), [(x,stateseq[x.start]) for x in (A,It,B)\",\n \"__metaclass__ = abc.ABCMeta @abc.abstractmethod def resample(self): pass @abc.abstractmethod def _counts_from(self,k):\",\n \"SAMPLING in stateseq_norep[1:] and \\\\ stateseq_norep[np.where(stateseq_norep == SAMPLING)[0]-1] == k:\",\n \"t > 0 score = 0. # unpack variables model\",\n \"= np.random.randint(ABIGNUMBER) while newlabel in ks: newlabel = np.random.randint(ABIGNUMBER) newweight\",\n \"temp = np.sum(self.stateseq[:-1] == k) if SAMPLING in self.stateseq[1:] and\",\n \"k: temp -= 1 return temp def _counts_fromto(self,k1,k2): assert k1\",\n \"import sample_discrete, sample_discrete_from_log, combinedata from pyhsmm.util.general import rle as rle\",\n \"t in np.random.permutation(self.T): # throw out old value self.stateseq[t] =\",\n \"__init__(self,model,beta,alpha_0,kappa,obs,data=None,T=None,stateseq=None): self.alpha_0 = alpha_0 self.kappa = kappa self.model = model\",\n \"list(model._occupied()) + [None] firststateidx = sample_discrete(np.arange(len(ks))) if firststateidx == len(ks)-1:\",\n \"definition choice that isn't specified in the HDP-HMM # Here,\",\n \"\\\\ self.stateseq[np.where(self.stateseq == SAMPLING)[0]-1] == k: temp -= 1 return\",\n \"_label_score(self,t,k): assert t > 0 score = 0. # unpack\",\n \"as rle # NOTE: assumes censoring. can make no censoring\",\n \"in pieces: # get all the other data otherdata, otherdurs\",\n \"if stateseq[t-1] != k: score += np.log(alpha * beta[k] +\",\n \"SAMPLING if len(self.stateseq) > 0: stateseq_norep, durations = rle(self.stateseq) return\",\n \"# set the state if idx == scores.shape[0]-1: self.stateseq[t] =\",\n \"k2 not in self.stateseq: return 0 else: from_indices, = np.where(self.stateseq[:-1]\",\n \"self.durations = rle(stateseq) self.data = data self.T = data.shape[0] def\",\n \"for k,ft in zip(ks,fromto_counts)] + [alpha*betarest]) nextstateidx = sample_discrete(scores) if\",\n \"np.sum(self.stateseq == SAMPLING) in (0,1) temp = np.sum(self.stateseq[:-1] == k)\",\n \"= self._new_label(ks) else: nextstate = ks[nextstateidx] # now get the\",\n \"- np.log(alpha * (1-beta[stateseq[t-1]]) + model._counts_from(stateseq[t-1])) # right transition (if\",\n \"get the counts of new states coming out of our\",\n \"return newlabel def _data_withlabel(self,k): assert k != SAMPLING return self.data[self.stateseq\",\n \"slice(0,0) elif t > seq.shape[0]-1: return slice(seq.shape[0],seq.shape[0]) else: endindices, =\",\n \"sample a new value scores = np.array([self._label_score(t,k) for k in\",\n \"np.log(self.beta.remaining*(betas/(1-betas)).sum()) else: score += np.log(self.beta.remaining) # add in obs/dur scores\",\n \"= self.dur.rvs() self.stateseq = np.concatenate((self.stateseq,np.ones(nextstate_dur,dtype=int)*nextstate)) t += nextstate_dur self.T =\",\n \"T: ks = list(model._occupied() | self._occupied()) betarest = 1-sum(betavec[k] for\",\n \"fill(seq,t): if t < 0: return slice(0,0) elif t >\",\n \"return np.sum(stateseq_norep[from_indices+1] == k2) def _counts_from(self,k): assert k != SAMPLING\"\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":22,"numItemsPerPage":100,"numTotalItems":12866649,"offset":2200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NjMwOTY1OSwic3ViIjoiL2RhdGFzZXRzL3RlcnJ5eXovc3RhcmNvZGVyZGF0YV9uZ3JhbV8xMCIsImV4cCI6MTc3NjMxMzI1OSwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.z39MQse6IkGCkAKqf3Qc0eKxWEDrV9r8OdMzPvwMJvMOVftbio9pETpxaCw6PClNIcy1BxEVI2-9jrLA9BgdCw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":12866649,"numBytesParquet":126831957853}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
ngram listlengths 0 82k |
|---|
[] |
[
"SubmitField('Sign Up') def validate_username(self, username): existing_username = User.query.filter_by(username=username.data).first() if existing_username:",
"import StringField, PasswordField, SubmitField from wtforms.validators import InputRequired, Email, ValidationError",
"from wtforms.validators import I... |
[
"EDIT import komand import json class Component: DESCRIPTION = \"Creates",
"a security policy with the default values\" class Input: NAME",
"}, \"required\": [ \"name\" ] } \"\"\") def __init__(self): super(self.__class__,",
"\"name\" class Output: ID = \"id\" class CreateSecurityPolicyInput(komand.Input): sc... |
[
"\"lt\", \"value\": 2100} condition2 = {\"column\": \"city\", \"operator\": \"eq\", \"value\":",
"= rule(conditions) condition1 = {\"column\": \"salary\", \"operator\": \"lt\", \"value\": 2100}",
"\"value\": 2100} condition2 = {\"column\": \"city\", \"operator\": \"eq\", \"value\": \"London\"}",
"[condition1,... |
[
"messages based on data from party service\"\"\" if not messages:",
"message.update({'@msg_to': [msg_to_details]}) else: logger.info(\"No details found for the message recipient\",",
"the to actor is set to 'GROUP' all_conversation_types If set",
"are a named tuple, but allow the conversation type only",
"I... |
[
"icons[self.value] if len(value) == 1: value = value[0] else: #",
"rend_j = j + self.side_width if not col: col =",
"= ' ' def __init__(self, icon=None): self.icon = icon or",
"\"\"\" return cell.ascii_icon() def render(self): for row in self.cells: res",
"%sx%s', self.full_width, self.full_width) self.cell... |
[
"% expr.__class__.__name__) # blacklist all Matrix printing _print_SparseMatrix = \\",
": 'where', 'complex' : 'complex', 'contains' : 'contains', } def",
"didn't define it, we could use StrPrinter's # version of",
"_print_ImmutableDenseMatrix = \\ _print_MatrixBase def _print_Piecewise(self, expr): result = ... |
[
"'business_id': 0, 'user_id': 0, 'postal_code': 0}: df_col = df[col].values na",
"import datetime import re from collections import Counter from statistics",
"\"\"\" import numpy as np import pandas as pd import",
"if pd.isna(element): return np.nan elif isinstance(element, np.double): array = np.array(elemen... |
[
"import Tk from tkinter import Entry from tkinter import Button",
"b2.configure(command=lambda:show(\"8\")) b3=Button(text=\"9\",font=(\"\",25),bg=\"gray\",fg=\"white\",activebackground=\"yellow\") b3.place(x=215,y=55,width=100,height=50) b3.configure(command=lambda:show(\"9\")) b4=Button(text=\"+\",font=(\"\",25... |
[
"return self.page.title class TourStep(Orderable): title = models.CharField(max_length=255) body = models.CharField(max_length=255)",
"existing field ) subtitles_en = models.TextField( verbose_name=_('English subtitles'), null=True, blank=True,",
"read list_page = ( ListPage.objects.ancestor_of(self) .filter(re... |
[
"class Compose(AbstractTransform): \"\"\" Do transformation on input data with corresponding",
"Default: True. Raises: TypeError: When 'transforms' is not a list.",
"i.e, if height > width, then image will be rescaled",
"``cv2.INTER_CUBIC``, bicubic interpolation \"\"\" def __init__(self, mode, size, interpol... |
[
"in serialized_deposit assert serialized_deposit['mesh_terms'] == [ { 'data': {'source': 'MeSH',",
"create_record( { 'terms': [ {'source': 'MeSH', 'value': 'Cognitive Neuroscience'}, {'source':",
"serialize_terms_for_edit_ui(deposit) assert 'terms' not in serialized_deposit assert serialized_deposit['mesh_terms... |
[
"def test_site(search: str): \"\"\"please enter site name with http information\"\"\"",
"def bing_search(search: str): webbrowser.open_new_tab(f\"https://www.bing.com/search?q={search}\") def duck_search(search: str): webbrowser.open_new_tab(f\"https://duckduckgo.com/?q={search}\") def yahoo_search(search:",
"n... |
[
"66), lambda : key_by_guess(10, 67, 'y'), lambda : key_by_space(10, 68),",
"ch_index) def key_by_guess(ct_index, ch_index, guess=' '): return strxor(MSGS_DECODED[ct_index][ch_index], guess) def",
"max_len = 0 for i1, i2, c in comb: if",
"for (x, y) in zip(a[:len(b)], b)])) #.encode('hex') else: return (\"\".j... |
[
"ValueError('arms_sampled is empty!') unsampled_arm_name_list = [name for name, sampled_arm in",
"we have three arms (arm1, arm2, and arm3) with expected",
"the optimal arms arm1 and arm2. ``{arm1: 0.5, arm2: 0.5,",
"in arms_sampled.iteritems() if sampled_arm.total == 0] return frozenset(unsampled_arm_name_li... |
[
"') if text.strip() == \"\": continue result, error = Hedge.run('<stdin>',",
"while True: text = input('Hedge > ') if text.strip() ==",
"Hedge while True: text = input('Hedge > ') if text.strip()",
"import Hedge while True: text = input('Hedge > ') if",
"Hedge.run('<stdin>', text) if (error): print(error.as... |
[
"* g.dds.prod(dtype=\"f8\") yield (ptype, field), data[mask] class IOHandlerPacked2D(IOHandlerPackedHDF5): _dataset_type =",
"ftype, fname = field fsize = size rv[field] = np.empty(fsize,",
"field): f = h5py.File(grid.filename, mode=\"r\") ds = f[\"/Grid%08i/%s\" % (grid.id,",
"None for g in chunk.objs: if g.... |
[
"= argparse.ArgumentParser(description='Enumarate CIDR ranges') parser.add_argument('ranges', metavar='range', type=str, nargs='*', help='List of",
"help='Sort CIDR ranges') args = parser.parse_args() if args.files: files =",
"files: with open(f, \"r\") as fd: for l in fd.readlines():",
"nargs='*', help='List... |
[
"depth=18, pretrained=None, pretrained2d=False, norm_eval=False, conv_cfg=dict(type='Conv3d'), norm_cfg=dict(type='SyncBN', requires_grad=True, eps=1e-3), act_cfg=dict(type='ReLU'), conv1_kernel=(3,",
"type=dataset_type_unlabeled, ann_file=ann_file_train_unlabeled, data_prefix=data_root, pipeline_weak=train_pipel... |
[
"= [0,0,0,160,240] # 2nd byte common to both channels voltages",
"voltages for display while not (channel == 1 or channel",
"%.2fV\" % voltages[i] raw_input(\"When ready hit enter.\\n\") r = spi.xfer2([16,0])",
"== \"m\": print \"jumper connecting GPIO 7 to CSB\" print",
"py-spidev as in the README.txt file... |
[
"a set of variables and redraw the status bar text.",
"all information, which might get displayed in the status bar",
"False def erase(self): \"\"\"Erase status bar text.\"\"\" self.view.erase_status('00_git_gutter') def update(self,",
"__init__(self, view, settings): \"\"\"Initialize object.\"\"\" # the subl... |
[
"-*- coding: utf-8 -*- from __future__ import unicode_literals from django.test",
"import unicode_literals from django.test import TestCase class RandomTestCase(TestCase): def test_one_plus_one1(self):",
"__future__ import unicode_literals from django.test import TestCase class RandomTestCase(TestCase): def",
... |
[
"passowrd = sso.get_login_credentials(\"WATCHER\") # Open a sample video available in",
"= cv2.VideoCapture('https://www.sample-videos.com/video/mp4/720/big_buck_bunny_720p_2mb.mp4') #if not vcap.isOpened(): # print \"File Cannot be",
"video windows before it ends if you want if cv2.waitKey(22)",
"# log = l.s... |
[
"= node_type super(NodeTypeNotFoundError, self).__init__(\"Node type '{}' does not exist.\".format(node_type)) class",
"MalformedUpdateDictionaryError(GraphAPIError): status_code = status.HTTP_400_BAD_REQUEST class InvalidPropertyError(GraphAPIError): status_code = status.HTTP_400_BAD_REQUEST class",
"GraphAPIE... |
[
"# Author: LeonardoM011<<EMAIL>> # Created on 2021-02-05 21:56 # Set",
"connect to binance with api keys.') def main(): output.print_ok('Starting kobe",
"# time.sleep(5.0) # client.futures_create_order(symbol=\"BTCUSDT\", side=\"SELL\", type=\"STOP\", quantity=0.001, price=57975.0, stopPrice=57976.0, workingTyp... |
[
"AGNs agn = ax.plot(pos_z_AGN[0], pos_z_AGN[1], '*', color='#fff717', markersize=6.5, label=r'AGN', markeredgecolor='w',",
"plotTimeSinceMergerDist(scale_merger_AGN, scale_merger_gal, z_AGN, z_gal, cosmo, bin_size, redshift_limit): \"\"\" Plot the",
"markeredgewidth=mew[i]) # DM halos j = i + 2 ax.plot(s_m_gal,... |
[
"# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law",
"import TimeReadCsvTrueFalseValues # noqa: F401 class TimeReadCsvNames: shapes = get_benchmark_shapes(\"omnisci.TimeReadCsvNames\")",
"ownership. The Modin Development Team licenses this file to you",
"for shape in self.sh... |
[
"= image_aug(tmp_data[i],angle) tmp_data[i] = tmp_ if model == \"uf\": train_x1",
"x[indx[500:600],:]), axis=0) test_y = np.concatenate((test_y, y[indx[500:600]]), axis=0) return train_x1, train_y1,",
"im_sz = int(np.floor(pic.shape[0]*scale)) pic_ = np.uint8(np.zeros((im_sz,im_sz,3),dtype=int)) pic_[:,:,0] = n... |
[
"self.types = {} self.unique_vals = {} self.minmax = {} for",
"= {} for col in X.columns: self.types[col] = X[col].dtype.name if",
"self.max_nunique: self.unique_vals[col] = unique_values else: self.unique_vals[col] = None elif self.types[col]",
"var_type = X[col].dtype.name if var_type != self.types[col]: se... |
[
"== EXPECTED_RESULT def test_fetch_incidents_limit_exceed(mocker): \"\"\" Given - a dict of",
"- Get new incidents is called during the fetch process.",
"on invalid input such as days or no units relevant",
"({'event_sources': \"\", 'abuse_disposition': \"\"}, [MOCK_INCIDENT]), ({'event_sources': \"No such so... |
[
"os.path.isfile(methname_json): raise(\"passing not exist file \" + methname_json) if output_dir",
"with different length may break the mach-o file, ori: \"",
"from enum import Enum from .mach_o import LC_SYMTAB from macholib",
"find __objc_methname section\") sect.section_data = replace_in_bytes( sect.sectio... |
[
"def sd1(rr): sdnn = np.std(rr) return math.sqrt(0.5 * sdnn *",
"import math import numpy as np def sd1(rr): sdnn =",
"import numpy as np def sd1(rr): sdnn = np.std(rr) return",
"<gh_stars>0 #!/usr/bin/env python import math import numpy as np def",
"np def sd1(rr): sdnn = np.std(rr) return math.sqrt(0.5 * ... |
[
"obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0",
"LLC # # Licensed under the Apache License, Version 2.0",
"2021 Google LLC # # Licensed under the Apache License,",
"flow = client.flow_from_clientsecrets('client_secret.json', SCOPES) creds = tools.run_flow(flow, store) servic... |
[
"x.parent = find_set(x.parent) return x.parent def find_python_set(node: Node) -> set:",
"s raise ValueError(f\"{node.data} is not in {sets}\") def test_disjoint_set() ->",
"bigger rank should be parent, so that the disjoint set",
"the disjoint set tree will be more flat. \"\"\" x,",
"x.parent = x def union... |
[
"= np.kron(Identity, sigma_y) Iz = np.kron(Identity, sigma_z) SxIx = np.kron(sigma_x,sigma_z)",
"sigma_y = 0.5*np.r_[[[0,-1j],[1j, 0]]] sigma_z = 0.5*np.r_[[[1, 0],[0, -1]]] Identity",
"omega_I/(2.*np.pi)*B0*Iz + Aiso * (np.dot(Sx,Ix) + np.dot(Sy,Iy) + np.dot(Sz,Iz)) print('Hamiltonian:')",
"E[3] E13 = E[0] -... |
[
"reader = csv.reader(f) vm_q = [vm for vm in reader]",
"spiderNest.preIntro import * path_ = os.path.dirname(os.path.dirname(__file__)) + '/dataBase/log_information.csv' def save_login_info(VMess,",
"# ['2020-08-06 04:27:59', 'link','class_', '1'] vm_q = [vm for vm",
"+ '/dataBase/log_information.csv' def sav... |
[
"as sox except: raise RuntimeError(\"Can not install soxbindings on your",
"audio segment to disk as wav file. :param filepath: WAV",
"\" \"than audio duration.\") shift_samples = int(shift_ms * self._sample_rate /",
"allow_downsampling: Whether to allow the noise signal to be downsampled",
"infinite gain t... |
[
"= tb.tb_lineno lines = [] try: with open(filename, 'rb') as",
"= template.Loader(os.path.dirname(os.path.abspath(__file__))) t = loader.load('debug.html') return t.generate( traceback=traceback, pprint=pprint, handler=self.handler,",
"None) implicit = getattr(exc_value, '__context__', None) return explicit or ... |
[
"f = self.func v = f() if v == self.stopwhen:",
"return len(self.l) def __list__(self): l = [] while True: try:",
"[] while not self.stopped: try: l.append(self.__next__()) except StopIteration: break return",
"self.i += 1 if found: return ret else: return None",
"= True raise StopIteration() ret = self.l[s... |
[
"lite_forms.components import Option class OpenGeneralExportLicences: class OpenGeneralLicence: def __init__(self, id,",
"<reponame>code-review-doctor/lite-frontend-1 from lite_content.lite_internal_frontend.open_general_licences import ( OGEL_DESCRIPTION, OGTCL_DESCRIPTION, OGTL_DESCRIPTION, ) from",
"name, de... |
[
"\"\"\"RotateMatrix.ipynb Automatically generated by Colaboratory. Original file is located at",
"temp = mat[i][j] mat[i][j] = mat[i][N - j - 1]",
"in range(N): for j in range(N // 2): temp =",
"10, 11, 12], [13, 14, 15, 16] ] rotate(mat) #printing",
"coding: utf-8 -*- \"\"\"RotateMatrix.ipynb Automatically... |
[
"for x in xs if x > pivot] res =",
"x > pivot] res = quicksort(left) res.append(pivot) res += quicksort(right)",
"return [] pivot = xs[0] xs = xs[1:] left =",
"pivot] right = [x for x in xs if x",
"[x for x in xs if x <= pivot] right",
"= [x for x in xs if x <= pivot]",
"res xs = [1, 3, 2, 4, 5, 2] sort... |
[
"devops_pb2.TransactionRequest(transactionUuid = context.transactionID) response = stub.GetTransactionResult(txRequest, 2) assert response.status ==",
"(channel, userRegistration) = getGRPCChannelAndUser(context, enrollId) stub = devops_pb2.beta_create_Devops_stub(channel) # Make",
"enrollId supplied''' assert ... |
[
"set_type == 'intersect': nofnd_l.append(k) else: raise IOError #=========================================================================== # wrap",
"logger.warning('0 common values between d(%i) and l(%i)'%(len(d), len(l))) logger.debug('returning d",
"# boolar = hp.basic.bool_list_in_list(d_big.keys(), l) # ... |
[
"green + \"]\" + white + \" Discord\") print(green +",
"\"[+] Github: https://github.com/Cyber-Dioxide/ \", \"- \" * 3) banner() def",
"[\" + white + \"15\" + green + \"]\" +",
"from Core.helper.color import green, white, blue, red, start, alert Version",
"\"- \" * 4, \" [+] Follow me on Instagram",
"prin... |
[
"2.0 (the \"License\"); # you may not use this file",
"Enter to continue.\\n\") # Validate challenges done, failed, pending =",
"{}.\\n\".format( challenge.file_name)) fs.write(challenge_file, challenge.serialize().decode()) pending_challenges.append(challenge) # Quit if nothing to",
"'dns': print(\"\\n DNS v... |
[
"learner. \"\"\" def __init__(self): # Hard initial update from Q-net(s)",
"return build_q_models(policy, obs_space, action_space, config), \\ TorchCategorical def build_q_losses(policy: Policy,",
"(Policy): The Policy to calculate the loss for. model (ModelV2):",
"`target_network_update_freq` steps by the ma... |
[
"'r', 'b', 'ɯ', 'a', 's', 'ʐ', 'η', 'ŋ', 'ɒ', 'ʂ',",
"'ʷen', 'ʷiu', 'ʷet', 'ɯəw', 'ʷɛ', 'ʷɤ', 'ɯj', 'oj', 'ăw', 'zi',",
"u'gì' : u'ji', u'gì' : u'ji', u'gĩ' : u'ji', u'gị'",
"ươ : ɯə1 xõa <-> xoã : swʷa3 ''' #Ở",
"u'ô' : u'o', u'ố' : u'o', u'ồ' : u'o', u'ổ'",
"list if str(char) in [\"ˈ\",\"ˌ\",\"*\"]: con... |
[
"def get_session_store_class(cls): return SessionStore class Meta: db_name = 'deft_adcr' db_table",
"SessionStore as DBStore class CustomSession(AbstractBaseSession): @classmethod def get_session_store_class(cls): return SessionStore",
"'<NAME>' from django.contrib.sessions.base_session import AbstractBaseSessi... |
[
"elements: # bill 23 16 19 22 def test_sum_w_23_16_19_22(self): test_list",
"#write the import for function for assignment7 sum_list_values from src.assignments.assignment7",
"assignment7 sum_list_values from src.assignments.assignment7 import sum_list_values class Test_Assign7(unittest.TestCase): def sample_te... |
[
"= ('_signing_key',) def __init__(self, skey): self._signing_key = nacl.signing.SigningKey(skey, nacl.encoding.Base64Encoder) @staticmethod",
"\"\"\" ciphertext = b64decode(ciphertext) if verifier: ciphertext = verifier.verifyb(ciphertext) data",
"b64decode(ciphertext) if verifier: ciphertext = verifier.verifyb... |
[
"(works only for web browsers).\"\"\" bl_idname = 'LNDetectMobileBrowserNode' bl_label =",
"only for web browsers).\"\"\" bl_idname = 'LNDetectMobileBrowserNode' bl_label = 'Detect",
"'LNDetectMobileBrowserNode' bl_label = 'Detect Mobile Browser' arm_version = 1 def",
"web browsers).\"\"\" bl_idname = 'LNDete... |
[
"]), ('Cape Town', [ ('Cape Town City', []), ]) ]),",
"from corehq.messaging.scheduling.models import AlertSchedule, SMSContent, AlertEvent from corehq.messaging.scheduling.scheduling_partitioned.dbaccessors import \\",
"form_id=uuid.uuid4().hex, ) self._dump_and_load(Counter({ CaseUploadFileMeta: 1, CaseUpload... |
[
"def test_softsign(): ''' Test using a reference softsign implementation '''",
"[activations.softmax(x)]) test_values = get_standard_values() result = f([test_values])[0] expected = softmax(test_values)",
"(x * 0.2) + 0.5 z = 0.0 if x",
"K.function([x], [activations.sigmoid(x)]) test_values = get_standard_val... |
[
"filename + ':/p</DataItem>'+\"\\n\") XMFfile.write (r'</Attribute>'+\"\\n\") if tmp.name == \"phid\": XMFfile.write",
"range(start,finaltime+1,stride): XMFfile = open(basename+\".\"+str(step)+\".xmf\",\"w\") XMFfile.write(r\"\"\"<?xml version=\"1.0\" ?> <!DOCTYPE Xdmf SYSTEM",
"4\" Format=\"HDF\">' + filename ... |
[
"# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law",
"# # Licensed under the Apache License, Version 2.0 (the",
"compliance with the License. # You may obtain a copy",
"an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF",
"2.0 (the \"License\"); # you may not use th... |
[
"it has a docstring \\\"\\\"\\\" pass def _skipped(self): # This",
"Config: \"\"\"Sphinx napoleon extension settings in `conf.py`. Listed below are",
"Also -------- :attr:`napoleon_use_admonition_for_examples` napoleon_use_ivar : :obj:`bool` (Defaults to False) True",
"---------- arg1 : str Description of `ar... |
[
"vector @staticmethod def _compute_similarity(left, right): return DataStructs.TanimotoSimilarity(left, right) def get_metadata(self)",
"= False self._compute_and_write_similarity(query_item, database_item) def _write_separator_if_needed(self): if not self.first_entry: self.stream.write(\",\")",
"self.counter =... |
[
"= ['https://' + item['ip'] + ':' + item['port'] for item",
"item in result: ip = item['IP'] port = str(item['Port']) url",
"= global_config.s_proxy_dict[username] url = 'https://' + proxy['ip'] + ':' +",
"global_config.s_proxy_dict[username] def get_static_proxy(self, username): if not global_config.static_p... |
[
"datetime import unittest import tempfile class WeatherTestCase(unittest.TestCase): def setUp(self): self.db_fd,",
"no entries.\"\"\" rv = self.app.get('/') assert 'Nothing logged yet.' in",
"import tempfile class WeatherTestCase(unittest.TestCase): def setUp(self): self.db_fd, weather.app.config['DATABASE'] = ... |
[
"class Activator: def __init__(self, name, packet_stream=None): self.ps = None self.name",
"and self.future and pkt[0] == 0: self.future.set_result(1) def set_packet_stream(self, ps):",
"0 self.state = '' if packet_stream: self.set_packet_stream(packet_stream) @_core.module_cmd def wait_activator(self):",
"pr... |
[
"<NAME>, <NAME>, (https://github.com/AdeDZY/DeepCT) model_url = \"http://boston.lti.cs.cmu.edu/appendices/arXiv2019-DeepCT-Zhuyun-Dai/outputs/marco.zip\" out_dir = os.path.join(pathlib.Path(__file__).parent.absolute(), \"models\")",
"350 # Provide Max Sequence Length used for consideration. (Max:",
"more detail... |
[
"# Because the members in this example are nearly rigid,",
"this example are nearly rigid, there will be virtually no",
"100, 100, 100, 100, 100) truss.AddMember('BC', 'B', 'C', E, 100,",
"Mechanics: Statics, 4th Edition # <NAME> # Problem 6.64 #",
"False, True, True) truss.DefineReleases('BD', False, False... |
[
"import yagmail receiver = \"<EMAIL>\" #Receiver's gmail address body =",
"= \"<EMAIL>\" #Receiver's gmail address body = \"Hello there from",
"gmail address body = \"Hello there from Yagmail\" filename =",
"= yagmail.SMTP(\"<EMAIL>\")#Your gmail address yag.send( to=receiver, subject=\"Yagmail test (attachme... |
[
"a translation *x->x+b*. \"\"\" def __init__(self,b=numpy.zeros((3,),dtype=_TYPE)): \"\"\" Creates the linear",
"linear transformation *x->x+b*. \"\"\" super(Translation, self).__init__() self.__b=numpy.array(b,_TYPE) def __call__(self,x=numpy.zeros((3,))): \"\"\"",
"self.__b=numpy.array(b,_TYPE) def __call__(s... |
[
"Cosmological constant # Solver definitions Rstart = 3 Rend =",
"<gh_stars>1-10 from bosonstar.ComplexBosonStar import Complex_Boson_Star # ===================== # All imporntnat",
"50.00 deltaR = 1 N = 100000 e_pow_minus_delta_guess = 0.4999",
"5.0 # Dimension (total not only spacial) Lambda = -0.2",
"pewp... |
[
"as f: license = f.read() with open('requirements.txt', encoding='utf-8') as f:",
"with open('requirements.txt', encoding='utf-8') as f: reqs = f.read() pkgs =",
"for p in find_packages() if p.startswith('fastNLP')] print(pkgs) setup( name='FastNLP', version='0.7.0',",
"p.startswith('fastNLP')] print(pkgs) se... |
[
"Access Token. Public APIs are mostly used in browsers. #",
"ApiAttributeError from ory_client.exceptions import ApiTypeError from ory_client.exceptions import ApiValueError from",
"ory_client.exceptions import ApiValueError from ory_client.exceptions import ApiKeyError from ory_client.exceptions import",
"# ... |
[
"the corresponding response. Provide the prediction response and extra information",
"the bias attribute configs, these decide which attributes may be",
"compute the reward\"\"\" @abstractmethod def get_module_version(self) -> str: \"\"\"Return the",
"def compute_reward(self, outcome_request: dict) -> Compute... |
[
"String type, which should be unicode type(my_str) #declare string: ip_addr",
"#check it with boolean:(True) ip_addr == '192.168.1.1' #(false) ip_addr ==",
"ip_addr '1.1' in ip_addr '15.1' not in ip_addr #Strings also",
"the first character ip_addr[0] #we can also get the last",
"for all strings. my_str = '... |
[
"buffer pp_kbddriver_plus.inputs['previous-line'] = pp_kbddriver_plus.inputs['current-line'] pp_kbddriver_plus.inputs['current-line']='' pp_kbddriver_plus.inputs['current-character']='' if name !='': #",
"self.event_callback('pp-key-'+ char,pp_kbddriver_plus.title) else: if name != '': # print 'bound",
"a new l... |
[
"on 2021-09-03 15:48 from django.db import migrations, models class Migration(migrations.Migration):",
"[ migrations.AlterField( model_name='item', name='comments', field=models.CharField(blank=True, default='null', max_length=200), preserve_default=False, ), ]",
"dependencies = [ ('grocery', '0002_alter_item_c... |
[
"0.75), '800080': (0.5, 0.4, 0.5), 'FF00FF': (0.9, 0.75, 0.85), 'F5DEB3':",
"create an image per color for colorString, color in colors.iteritems():",
"2.0 (the \"License\"); # you may not use this file",
"\"\"\"Generate textures prepared for OSM, based on image templates.\"\"\" import",
"the effect, found ... |
[
"import os for k, v in os.environ.iteritems(): print k, '=',",
"os for k, v in os.environ.iteritems(): print k, '=', v",
"env \"\"\" import os for k, v in os.environ.iteritems(): print",
"\"\"\" import os for k, v in os.environ.iteritems(): print k,",
"\"\"\" test local env \"\"\" import os for k, v",
"te... |
[
"# then join the cycles into one big sample sample",
"= (df.marend01==4) df['widowed'] = (df.marend01==1) df['stillma'] = (df.timesmar== 1) &",
"df.cmstphsbx.replace(invalid, np.nan, inplace=True) df.timesmar.replace([98, 99], np.nan, inplace=True) df['evrmarry'] = (df.timesmar",
"df.firstcm df.cmmarrhx.filln... |
[
"'intensity.sum.variance', 'miller_index', 'miller_index_asymmetric', 'exp_id', 'odd_frame', 's1']: if not key in",
"merged_reflections.append( {'miller_index' : hkl, 'intensity' : weighted_mean_intensity, 'sigma' : standard_error_of_weighted_mean_intensity,",
"continue else: yield reflections[i_begin:i] i_begi... |
[
"self.GC_CAN_MOVE def define_shrink_array(cls): from rpython.rtyper.lltypesystem.rstr import STR def f(): ptr",
"def define_nongc_static_root_minor_collect(cls): T1 = lltype.GcStruct(\"C\", ('x', lltype.Signed)) T2 = lltype.Struct(\"C\",",
"ourselves, otherwise this test takes ages llop.gc__collect(lltype.Void)... |
[
"utils from . import display from . import save from",
"from . import save from . import FFTW from .",
". import display from . import save from . import",
"import display from . import save from . import FFTW",
"save from . import FFTW from . import stackregistration __version__=\"0.2.1\"",
"display from... |
[
"considers them all) compute_on_step: Forward only calls ``update()`` and return",
">>> indexes = tensor([0, 0, 0, 1, 1, 1, 1])",
"only float tensors res.append(self._metric(mini_preds, mini_target)) return B.stack([x.to(preds) for x in",
"1, 1, 1]) >>> preds = tensor([0.2, 0.3, 0.5, 0.1,",
"with binary tar... |
[
"= builder() dlm.add(seasonality(period=2, discount=1, w=1.0)) dlm.initialize() self.kf11.forwardFilter(dlm.model, 1) self.assertAlmostEqual(dlm.model.state[0][0, 0],",
"dlm = builder() dlm.add(self.trend0) dlm.initialize() self.kf1.predict(dlm.model) self.assertAlmostEqual(dlm.model.prediction.obs, 0) # the",
... |
[
"migrate rule for 'sata1' r = MigrateRule(source='sata1', threshold=(90, 50)) #",
"to start of the policy policy.rules.insert(r, 0) # save changes",
"arcapix.fs.gpfs.policy import PlacementPolicy from arcapix.fs.gpfs.rule import MigrateRule # load placement",
"placement policy for mmfs1 policy = PlacementPoli... |
[
"= [a > b for (a, b) in zip(depths[1:], depths[:-1])]",
"= list(map(int, sys.stdin)) increased = [a > b for (a,",
"#!/usr/bin/env python3 import sys depths = list(map(int, sys.stdin)) increased =",
"<reponame>tjol/advent-of-code-2021<gh_stars>1-10 #!/usr/bin/env python3 import sys depths = list(map(int, sys.s... |
[
"== url).first() if Paste.query.filter(Paste.url == url).first() != None: if is_active(paste):",
"== url).first() user = User.query.filter(paste.user_id == User.id).first() if is_active(paste): return",
"methods=['POST']) @requires_auth def get_all_pastes_object(): user_id = session['user_id'] user = User.query... |
[
"if COMMANDS[command_id] == \"move_forward\": anafi.move_relative(dx=1, dy=0, dz=0, dradians=0) if COMMANDS[command_id]",
"image, format: MinWidth,MaxWidth,MinHeight,MaxHeight.\\ Set -1 for the unchanged ones\" )",
"imgs = [] while True: ret, frame = cam.read() if",
"required=False, default=7, type=int, help=... |
[
"image and labels from previous labelling session \"\"\" fname =",
"mode='thick')) plt.title('segmented image') plt.subplot(1,2,2) plt.imshow(image) plt.imshow(labels, alpha=0.75) cb = plt.colorbar(orientation='horizontal',",
"== -1] = 0 truth[truth == 0] = 5 truth[truth",
"or directory (classify_directory())... |
[
"str) -> JsonDict: return self.predict_json({\"sentence\": sentence}) @overrides def _json_to_instance(self, json_dict:",
"import overrides @Predictor.register(\"sentence_classifier\") class SentenceClassifierPredictor(Predictor): def predict(self, sentence: str) ->",
"JsonDict from allennlp.data import Dataset... |
[
"[y[P[i]] for i in range(16)] # Generate MixColumn relations for",
"5, 6, 10, 11, 8, 9, 13, 14, 15, 12]",
"eqs = '#%s %d Rounds\\n' % (cipher_name, R) eqs +=",
"# 2 rounds # recommended_mg = 16 # recommended_ms =",
"Tweakey temp1 = tk1.copy() temp2 = tk2.copy() tk1 = [temp1[TKP[i]]",
"i in range(16)] y = ... |
[
"pass def get_grid_face_edges(self, grid, face_edges): pass def get_grid_node_count(self, grid): pass",
"pass def initialize(self, config_file): pass def update(self): pass def update_until(self,",
"def get_var_nbytes(self, var_name): pass def get_var_itemsize(self, name): pass def get_var_location(self,",
"E... |
[
"selector = None, **kwargs ): #unify value format if isinstance(",
"format if isinstance( value, str ): value = { \"_type\":",
".field import FuncField as BaseField class StringField( BaseField ): process_timing",
"None, selector = None, **kwargs ): #unify value format if",
"key = key, value = value, select... |
[
"movie base url base_url = None def configure_request(app): global api_key,base_url",
"print(get_news_source_response) source_result = None if get_news_source_response['articles']: source_result_list = get_news_source_response['articles'] source_result",
"function processes the results and converts them into a ... |
[
"'X': M = [spTh.specie.X * spTh.specie.M for spTh in self.spTh.values()]",
"# [J/kg] dcpvdT = [ spTh.specie.Y * spTh.thermo.dcpvdT for spTh",
"return np.sum(np.concatenate(n)) # Enthalpy/Energy def he_(self): # [J/kg] he =",
"[spTh.specie.Y * spTh.specie.R for spTh in self.spTh.values()] return np.sum(np.conc... |
[
"1.1 - Add user as ForeignKey (URL mapping, we use",
"def __str__(self): return self.name def get_absolute_url(self): return reverse('toys_detail', kwargs={'pk': self.id})",
"Field.choice return f\"{self.get_meal_display()} on {self.date}\" # change the default sort",
"models.TextField(max_length=250) age = m... |
[
"Kedro plugin for running a project with Airflow \"\"\" __version__",
"for running a project with Airflow \"\"\" __version__ = \"0.5.0\"",
"plugin for running a project with Airflow \"\"\" __version__ =",
"<gh_stars>1-10 \"\"\" Kedro plugin for running a project with Airflow",
"\"\"\" Kedro plugin for runni... |
[
"import constants import time import math ## This isn't a",
"class DebugWindowEvaluator(play.Play): def __init__(self): super().__init__(continuous=True) self.add_transition(behavior.Behavior.State.start, behavior.Behavior.State.running, lambda: True, 'immediately')",
"__init__(self): super().__init__(continuou... |
[
"a metallicity into a PHOENIX-style string. Parameters ---------- Z :",
"\"\"\" Convert a metallicity into a PHOENIX-style string. Parameters ----------",
"for solar) \"\"\" if Z <= 0: return \"-{:03.1f}\".format(np.abs(Z)) else:",
": float [Fe/H]-style metallicity (= 0.0 for solar) \"\"\" if",
"solar) \"\"... |
[
"__init__(self, **kwargs): self._completed_at = kwargs.get('completed_at') self._type = kwargs.get('type') self._symbol =",
"return False if self.amount != other.amount: return False return True",
"def __init__(self, **kwargs): self._completed_at = kwargs.get('completed_at') self._type = kwargs.get('type') self... |
[
"= tf.constant(0.0, name='scale') with self.assertRaisesOpError('Argument `scale` must be positive.'): laplace",
"2.0 scale_v = 3.0 x = np.array([2.5, 2.5, 4.0, 0.1,",
"= sp_stats.laplace.cdf(x, loc_v, scale=scale_v) self.assertAllClose(self.evaluate(cdf), expected_cdf) def testLaplaceLogCDF(self): batch_size =... |
[
"dash from flask import Flask from flask.helpers import get_root_path from",
"title, base_pathname, layout, register_callbacks_fun): # Meta tags for viewport responsiveness",
"from pytz import timezone from config import BaseConfig csrf =",
"app.dashapp2.callbacks import register_callbacks as register_callbac... |
[
"= soln[group_mask] / norm(soln[group_mask]) ordered_opt.append(norm(soln[group_mask])) else: overall[group_mask] = False self.selection_variable",
"proposed_value = objective(proposal) if proposed_value <= current_value: break step *=",
"use_lasso=True, # should lasso solver be used when applicable -",
"= bl... |
[
"k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.stateseq[t-1],k) for k",
"self._occupied()) betarest = 1-sum(betavec[k] for k in ks) # get",
"for k in ks) fromto_counts = np.array([model._counts_fromto(self.stateseq[t-1],k) + self._counts_fromto(self.sta... |