def convert_renamer(renamer): if renamer is None: def renamer(*_): return A.common._fresh() return fn.memoize(renamer)
def from_threshold(func, dim: int, *, memoize_nodes=True) -> BiPartition: bounding_box = mbpr.bounding_box(rectangles.unit_rec(dim), func) diagsearch = partial(mdts.binsearch, oracle=func) refine = partial(mbpr.refine, diagsearch=diagsearch) if memoize_nodes: refine = fn.memoize()(refine) return BiPartition(LazyTree(root=bounding_box, child_map=refine), func)
def annotate(tree, root, dyn, trcs): for node in tree.nodes: tree.nodes[node]['visits'] = 0 def advance(node, sym): for node2 in tree.neighbors(node): if sym == tree.nodes[node2]['source']: return node2 raise RuntimeError for trc in trcs: node, prev_sym, state = root, None, None for i, sym in enumerate(trc): data = tree.nodes[node] data['visits'] += 1 data['decision'] = (i % 2) == 0 data['time'] = i // 2 node = advance(node, sym) if data['decision']: state = data['state'] = data['source'] else: data['state'] = state data = tree.nodes[node] data['visits'] += 1 i += 1 data['decision'] = (i % 2) == 0 data['time'] = i // 2 data['state'] = data['source'] # Reuse precomputed coin flips find_env_input = fn.memoize(dyn.find_env_input) for edge in tree.edges: tnode1, tnode2 = edge if tree.nodes[tnode1]['decision']: payload = tree.nodes[tnode2]['source'] else: action = pmap(tree.nodes[tnode1]['source']) start = pmap(tree.nodes[tnode1]['state']) end = pmap(tree.nodes[tnode2]['state']) payload = find_env_input(start, action, end) tree.edges[edge]['action'] = payload
set_user(user) yield if clear: previous_user = AnonymousUser set_user(previous_user) def _get_robot_user(): """ :returns User: a specific user for celery actions """ robot = get_user_model().objects.get_or_create(username='******', password=UNUSABLE_PASSWORD_PREFIX) return robot[0] get_robot_user = memoize(_get_robot_user) @contextmanager def as_robot_user(): with as_user(get_robot_user()): yield class AddRequestToThreadLocals(object): """ Make the request available to library functions that do not normally have access. The post_save hook is a good example where this information is not available. """
def memoized_property(f): return property(memoize(f))
class MetaAnalyser: def isquared(self, H): """ Calculate I-Squared. Higgins & Thompson (2002), Statistics in Medicine, 21, 1539-58. """ if H.TE: t = lambda x: (x**2 - 1) / x**2 return EasyDict(TE=t(H.TE), lower=t(H.lower), upper=t(H.upper)) else: return EasyDict(TE=None, lower=None, upper=None) def calcH(self, Q, df, level): """ Calculate H. Higgins & Thompson (2002), Statistics in Medicine, 21, 1539-58. """ k = df + 1 H = np.sqrt(Q / (k - 1)) result = EasyDict(TE=None, lower=None, upper=None) if k > 2: if Q <= k: selogH = np.sqrt(1 / (2 * (k - 2)) * (1 - 1 / (3 * (k - 2)**2))) else: selogH = 0.5 * (np.log(Q) - np.log(k - 1)) / ( np.sqrt(2 * Q) - np.sqrt(2 * k - 3)) tres = self.getConfidenceIntervals(np.log(H), selogH, level) result = EasyDict( TE=1 if np.exp(tres.TE) < 1 else np.exp(tres.TE), lower=1 if np.exp(tres.lower) < 1 else np.exp(tres.lower), upper=1 if np.exp(tres.upper) < 1 else np.exp(tres.upper)) return result norm_ppf = staticmethod(memoize(stats.norm.ppf)) t_ppf = staticmethod(memoize(stats.t.ppf)) def getConfidenceIntervals(self, TE, TE_se, level=.95, df=None): alpha = 1 - level zscore = TE / TE_se if not df: delta = self.norm_ppf(1 - alpha / 2) * TE_se lower = TE - delta upper = TE + delta pval = 2 * (1 - stats.norm.cdf(abs(zscore))) else: delta = self.t_ppf(1 - alpha / 2, df=df) * TE_se lower = TE - delta upper = TE + delta pval = 2 * (1 - stats.t.cdf(abs(zscore), df=df)) result = EasyDict(TE=TE, se=TE_se, level=level, df=df, pval=pval, zscore=zscore, upper=upper, lower=lower) return result @staticmethod def get_TE_se(gene_stats): # Convert to numpy arrays for speed caseSigma = gene_stats['caseDataSigma'].values caseCount = gene_stats['caseDataCount'].values controlSigma = gene_stats['controlDataSigma'].values controlCount = gene_stats['controlDataCount'].values # MD method na = np.sqrt(caseSigma**2 / caseCount + controlSigma**2 / controlCount) # Studies with non-positive variance get zero weight in meta-analysis for i in range(len(na)): if caseSigma[i] <= 0 or controlSigma[i] <= 0: na[i] = float('nan') return pd.Series(na, index=gene_stats.index) def __init__(self, gene_stats): TE = gene_stats.caseDataMu.values - gene_stats.controlDataMu.values # (7) Calculate results for individual studies TE_se = self.get_TE_se(gene_stats) w_fixed = (1 / TE_se**2).fillna(0) TE_fixed = np.average(TE, weights=w_fixed) TE_fixed_se = np.sqrt(1 / sum(w_fixed)) self.fixed = self.getConfidenceIntervals(TE_fixed, TE_fixed_se) self.Q = sum(w_fixed * (TE - TE_fixed)**2) self.Q_df = TE_se.dropna().count() - 1 self.cVal = sum(w_fixed) - sum(w_fixed**2) / sum(w_fixed) if self.Q <= self.Q_df: self.tau2 = 0 else: self.tau2 = (self.Q - self.Q_df) / self.cVal self.tau = np.sqrt(self.tau2) self.tau2_se = None w_random = (1 / (TE_se**2 + self.tau2)).fillna(0) TE_random = np.average(TE, weights=w_random) TE_random_se = np.sqrt(1 / sum(w_random)) self.random = self.getConfidenceIntervals(TE_random, TE_random_se) # Prediction interval self.level_predict = 0.95 self.k = TE_se.count() self.predict = EasyDict(TE=None, se=None, level=None, df=None, pval=None, zscore=None, upper=None, lower=None) if self.k >= 3: TE_predict_se = np.sqrt(TE_random_se**2 + self.tau2) self.predict = self.getConfidenceIntervals(TE_random, TE_predict_se, self.level_predict, self.k - 2) # Calculate H and I-Squared self.level_comb = 0.95 self.H = self.calcH(self.Q, self.Q_df, self.level_comb) self.I2 = self.isquared(self.H) def get_results(self): return dict( k=self.k, fixed_TE=self.fixed.TE, fixed_se=self.fixed.se, fixed_lower=self.fixed.lower, fixed_upper=self.fixed.upper, fixed_pval=self.fixed.pval, fixed_zscore=self.fixed.zscore, random_TE=self.random.TE, random_se=self.random.se, random_lower=self.random.lower, random_upper=self.random.upper, random_pval=self.random.pval, random_zscore=self.random.zscore, predict_TE=self.predict.TE, predict_se=self.predict.se, predict_lower=self.predict.lower, predict_upper=self.predict.upper, predict_pval=self.predict.pval, predict_zscore=self.predict.zscore, tau2=self.tau2, tau2_se=self.tau2_se, C=self.cVal, H=self.H.TE, H_lower=self.H.lower, H_upper=self.H.upper, I2=self.I2.TE, I2_lower=self.I2.lower, I2_upper=self.I2.upper, Q=self.Q, Q_df=self.Q_df, )
def uuid(run_id, uuids): uuid_by_param = memoize(lambda *a: next(uuids)) return partial(uuid_by_param, run_id)