def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
regime = self.lookup_quadrant(
inputs[self.inputs[0]],
inputs[self.inputs[1]],
)
x = gu.pflip(self.probabilities[regime], rng=self.rng)
return {self.outputs[0]: x}
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
if self.N == 0:
raise ValueError('KDE requires at least one observation.')
if inputs:
raise ValueError('Prohibited inputs: %s' % (inputs, ))
if not targets:
raise ValueError('No targets: %s' % (targets, ))
if any(q not in self.outputs for q in targets):
raise ValueError('Unknown targets: %s' % (targets, ))
if constraints and any(q in constraints for q in targets):
raise ValueError('Duplicate variable: %s, %s' % (
targets,
constraints,
))
constraints = self.populate_constraints(rowid, targets, constraints)
if constraints:
full_members = self._dataset(targets + constraints.keys())
weights = _kernel_base.gpke(
self._bw(constraints),
full_members[:, len(targets):],
constraints.values(),
self._stattypes(constraints),
tosum=False,
)
targets_members = full_members[:, :len(targets)]
else:
targets_members = self._dataset(targets)
weights = [1] * len(targets_members)
assert len(weights) == len(targets_members)
index = gu.pflip(weights, size=N, rng=self.rng)
if N is None:
return self._simulate_member(targets_members[index], targets)
return [
self._simulate_member(targets_members[i], targets) for i in index
]
def gen_partition(N, weights, rng):
assert all(w != 0 for w in weights)
assert np.allclose(sum(weights), 1)
K = len(weights)
assert K <= N # XXX FIXME
Z = range(K)
Z.extend(int(gu.pflip(weights, rng=rng)) for _ in xrange(N-K))
rng.shuffle(Z)
return Z
def _gen_categorical_data(Z, rng, separation=.9, distargs=None):
k = int(distargs['k'])
n_rows = len(Z)
if separation > .95:
separation = .95
Tc = np.zeros(n_rows, dtype=int)
C = max(Z)+1
theta_arrays = [rng.dirichlet(np.ones(k)*(1.-separation), 1)
for _ in range(C)]
for r in xrange(n_rows):
cluster = Z[r]
thetas = theta_arrays[cluster][0]
x = gu.pflip(thetas, rng=rng)
Tc[r] = int(x)
return Tc
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
y = inputs[self.inputs[0]]
assert int(y) == float(y)
assert y in [0, 1]
x = gu.pflip(self.probabilities[y], rng=self.rng)
return {self.outputs[0]: x}
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
x = gu.pflip(self.counts + self.alpha, rng=self.rng)
return {self.outputs[0]: x}
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionCGPM.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data and not isnan(self.data[rowid]):
return {self.outputs[0]: self.data[rowid]}
x = pflip(self.counts + self.alpha, rng=self.rng)
return {self.outputs[0]: x}