Пример #1
0
            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']
Пример #2
0
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)
Пример #3
0
            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)
Пример #4
0
            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']
Пример #5
0
    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
Пример #6
0
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])))
Пример #7
0
    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)