d = pd.Series([self.lookup[val] for val in x]).astype(int) d.index = x.index return (d) else: return np.array([self.lookup[val] for val in x]) def len(self): return len(self.ids) def decode_df(self): df = pd.DataFrame({'id': self.ids, 'value': self.values}) df.dropna(inplace=True) return df as_id = patsy.stateful_transform(Id) class SurvData(pd.DataFrame): ''' patsy.DesignMatrix representing survival data output ''' survival_type = 'UNK' def __init__(self, *args, **kwargs): if 'stan_data' in kwargs.keys(): stan_data = kwargs['stan_data'] del kwargs['stan_data'] else: stan_data = dict() if 'meta_data' in kwargs.keys(): meta_data = kwargs['meta_data'] del kwargs['meta_data']
class Harmonic(object): """ Transform `x` into seasonal harmonics with a given frequency Args: x (np.ndarray): array of ordinal dates freq (int or float): frequency of harmonics """ def __init__(self): self.w = 2 * np.pi / 365.25 def memorize_chunk(self, x, freq): pass def memorize_finish(self): pass def transform(self, x, freq): x = np.asarray(x) if x.shape == (): x = x[np.newaxis] return np.array([ np.cos(freq * self.w * x), np.sin(freq * self.w * x) ]).T harm = stateful_transform(Harmonic)
pass if vals is None: vals=[1]*10 xb = [] for k, v in zip(np.arange(0., 1, 0.1), vals): if dur<0: idx = x*0+default idx[np.argmin(abs(x-k))]=v else: index = ((k<= x) & (x<k+dur)) idx = x*0+default idx[index] = v xb.append(idx.astype(float)) return np.vstack(xb).T Cc = patsy.stateful_transform(Cc_t) box = patsy.stateful_transform(boxcar_t) ramp = patsy.stateful_transform(ramp_t) BS = patsy.stateful_transform(spline_convolution) SE = patsy.stateful_transform(spline_event) FE = patsy.stateful_transform(flat_event) CO = patsy.stateful_transform(contrast_onsets) F = patsy.stateful_transform(convolution) MF = patsy.stateful_transform(multi_convolution) Z = patsy.stateful_transform(Zscore) evramp = patsy.stateful_transform(event_ramp) dt = patsy.stateful_transform(DT)
d = pd.Series([self.lookup[val] for val in x]).astype(int) d.index = x.index return(d) else: return np.array([self.lookup[val] for val in x]) def len(self): return len(self.ids) def decode_df(self): df = pd.DataFrame({'id': self.ids, 'value': self.values}) df.dropna(inplace=True) return df as_id = patsy.stateful_transform(Id) class SurvData(pd.DataFrame): ''' patsy.DesignMatrix representing survival data output ''' survival_type = 'UNK' def __init__(self, *args, **kwargs): if 'stan_data' in kwargs.keys(): stan_data = kwargs['stan_data'] del kwargs['stan_data'] else: stan_data = dict() if 'meta_data' in kwargs.keys(): meta_data = kwargs['meta_data'] del kwargs['meta_data']
def memorize_chunk(self, x, thresh=0, factor=2): chunk_min = x[x > thresh].min() if self.minimum_measured is None: self.minimum_measured = chunk_min else: self.minimum_measured = min(self.minimum_measured, chunk_min) def memorize_finish(self, thresh=0, factor=2): assert self.minimum_measured > thresh self.replace_value = self.minimum_measured / factor def transform(self, x, thresh=0, factor=2): return np.where(x > thresh, x, np.full(x.shape, self.replace_value)) raise_low = patsy.stateful_transform(RaiseLowTransform) def mannwhitneyu(x, y, data): levels = data[x].unique() assert len(levels) == 2 return sp.stats.mannwhitneyu(data[data[x] == levels[0]][y], data[data[x] == levels[1]][y]) def phreg_aic(f): return 2 * len(f.params) - 2 * f.llf def lrt_phreg(fit1, fit0): delta_params = fit1.df_model - fit0.df_model
print(d) data_chunked = [{"x": data["x"][:2]}, {"x": data["x"][2:]}] dinfo = incr_dbuilder("center(x)", lambda: iter(data_chunked)) # Correct! d = np.row_stack([build_design_matrices([dinfo], chunk)[0] for chunk in data_chunked]) print(d) d = build_design_matrices([dinfo], new_data)[0] print(d) class MyExampleCenter(object): def __init__(self): self._total = 0 self._count = 0 self._mean = None def memorize_chunk(self, x): self._total += np.sum(x) self._count += len(x) def memorize_finish(self): self._mean = self._total * 1. / self._count def transform(self, x): return x - self._mean my_example_center = patsy.stateful_transform(MyExampleCenter) print(my_example_center(np.array([1, 2, 3])))
def memorize_chunk(self, x, **kwargs): pass def memorize_finish(self, **kwargs): pass def transform(self, x, degree=2, df=5, length=100): try: x = x.values except AttributeError: pass knots = [0, 0] + linspace(0,1,df-1).tolist() + [1,1] basis = patsy.splines._eval_bspline_basis(linspace(0,1,length), knots, degree) basis /= basis.sum(0) if len(x.shape) > 1: return r_[[self.conv_base(t, basis, length) for t in x]] else: return self.conv_base(x, basis, length) def conv_base(self, x, basis, length): out = empty((len(x), basis.shape[1])) for i, base in enumerate(basis.T): out[:,i] = convolve(x, pad(base, [length, 0], mode='constant'), mode='same') return out Cc = patsy.stateful_transform(Cc_t) box = patsy.stateful_transform(boxcar_t) ramp = patsy.stateful_transform(ramp_t) bsconv = patsy.stateful_transform(spline_convolution)