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)
