def create_datasets():
rs = RandomState(0)
data_a = np.sort(rs.normal(0, 10, 500)).astype(int).reshape(100, 5)
gene_names_a = list("ABCDE")
cell_types_a = ["alpha", "beta", "gamma", "delta"]
labels_a = rs.choice(np.arange(len(cell_types_a)), data_a.shape[0])
batch_indices_a = np.random.choice(np.arange(5), size=data_a.shape[0])
data_b = np.sort(rs.normal(100, 10, 300)).astype(int).reshape(100, 3)
gene_names_b = list("BFA")
cell_types_b = ["alpha", "epsilon", "rho"]
labels_b = rs.choice(np.arange(len(cell_types_b)), data_b.shape[0])
batch_indices_b = rs.choice(np.arange(5), size=data_b.shape[0])
dataset_a = GeneExpressionDataset()
dataset_b = GeneExpressionDataset()
dataset_a.populate_from_data(X=data_a,
labels=labels_a,
gene_names=gene_names_a,
cell_types=cell_types_a,
batch_indices=batch_indices_a)
dataset_a.name = "test_a"
dataset_b.populate_from_data(X=data_b,
labels=labels_b,
gene_names=gene_names_b,
cell_types=cell_types_b,
batch_indices=batch_indices_b)
dataset_b.name = "test_b"
return dataset_a, dataset_b
def test_mutual_information(seed):
num_data_points = 500
rs = RandomState(seed)
mi_random_uniform = compute_mutual_information(
rs.uniform(-1, 1, size=(2, num_data_points)))
rs = RandomState(seed)
mi_random_gaussian = compute_mutual_information(
rs.normal(size=(2, num_data_points)))
rs = RandomState(seed)
mi_random_gaussian = compute_mutual_information(
rs.normal(size=(2, num_data_points)))
rs = RandomState(seed)
mi_constant = compute_mutual_information(
np.ones((2, num_data_points)) +
rs.normal(0, 1e-15, size=(2, num_data_points)))
rs = RandomState(seed)
mi_correlated = compute_mutual_information(
generate_correlated_data(num_data_points, cov=0.9, rs=rs))
print('MI random uniform:', mi_random_uniform)
print('MI random gaussian:', mi_random_gaussian)
print('MI constant:', mi_constant)
print('MI correlated:', mi_correlated)
class WeightGenerationRegime:
def __init__(self, nStates, nBivariateFeat, prng=None, seed=None, stationaryWeights=None, bivariateWeights=None):
self.nStates = nStates
self.nBivariateFeat = nBivariateFeat
if prng is not None:
self.prng = prng
else:
if seed is not None:
self.prng = RandomState(seed)
else:
self.defaultRandomSeed = defaultSeed
prng = RandomState(1234567890)
if prng is not None and seed is not None:
warnings.warn("both prng and seed are provided but we use the provided prng", DeprecationWarning)
self.stationaryWeights = stationaryWeights
self.bivariateWeights = bivariateWeights
def generateStationaryWeightsFromNormal(self):
self.stationaryWeights = self.prng.normal(0, 1, self.nStates)
return self.stationaryWeights
def generateBivariateWeightsFromNormal(self):
self.bivariateWeights = self.prng.normal(0, 1, self.nBivariateFeat)
return self.bivariateWeights
def generateStationaryWeightsFromUniform(self):
self.stationaryWeights = self.prng.uniform(0, 1, self.nStates)
return self.stationaryWeights
def generateBivariateWeightsFromUniform(self):
self.bivariateWeights = self.prng.uniform(0, 1, self.nBivariateFeat)
return self.bivariateWeights
def test_two_sample():
prng = RandomState(42)
x = prng.normal(1, size=20)
y = prng.normal(4, size=20)
res = two_sample(x, y, seed=42)
expected = (1.0, -2.90532344604777)
np.testing.assert_almost_equal(res, expected)
y = prng.normal(1.4, size=20)
res = two_sample(x, y, seed=42)
res2 = two_sample(x, y, seed=42, keep_dist=True)
expected = (0.96975, -0.54460818906623765)
np.testing.assert_equal(res, expected)
np.testing.assert_equal(res2[:2], expected)
y = prng.normal(1, size=20)
res = two_sample(x, y, seed=42)
expected = (0.66505000000000003, -0.13990200413154097)
np.testing.assert_equal(res, expected)
res = two_sample(x, y, seed=42, interval="upper")
expected_pv = 0.66505000000000003
expected_ts = -0.13990200413154097
expected_ci = (0.0, 0.6675064023707297)
np.testing.assert_equal(res[0], expected_pv)
np.testing.assert_equal(res[1], expected_ts)
np.testing.assert_almost_equal(res[2], expected_ci)
res = two_sample(x, y, seed=42, interval="lower")
expected_ci = (0.6625865251964975, 1.0)
np.testing.assert_almost_equal(res[2], expected_ci)
res = two_sample(x, y, seed=42, interval="two-sided")
expected_ci = (0.6621149803107692, 0.6679754440683887)
np.testing.assert_almost_equal(res[2], expected_ci)
res = two_sample(x, y, seed=42, keep_dist=True)
exp_dist_firstfive = [0.089396492796047111,
0.17390295863272254,
-0.034211921065956274,
0.29103960535095719,
-0.76420778601368644]
np.testing.assert_equal(res[0], expected_pv)
np.testing.assert_equal(res[1], expected_ts)
np.testing.assert_equal(len(res[2]), 100000)
np.testing.assert_almost_equal(res[2][:5], exp_dist_firstfive)
res = two_sample(x, y, seed=42, interval="two-sided", keep_dist=True)
np.testing.assert_equal(res[0], expected_pv)
np.testing.assert_equal(res[1], expected_ts)
np.testing.assert_almost_equal(res[2], expected_ci)
np.testing.assert_equal(len(res[3]), 100000)
np.testing.assert_almost_equal(res[3][:5], exp_dist_firstfive)
def test_two_sample():
prng = RandomState(42)
x = prng.normal(1, size=20)
y = prng.normal(4, size=20)
res = two_sample(x, y, seed=42)
expected = (1.0, -2.90532344604777)
np.testing.assert_almost_equal(res, expected)
y = prng.normal(1.4, size=20)
res = two_sample(x, y, seed=42)
res2 = two_sample(x, y, seed=42, keep_dist=True)
expected = (0.96975, -0.54460818906623765)
np.testing.assert_equal(res, expected)
np.testing.assert_equal(res2[:2], expected)
y = prng.normal(1, size=20)
res = two_sample(x, y, seed=42)
expected = (0.66505000000000003, -0.13990200413154097)
np.testing.assert_equal(res, expected)
res = two_sample(x, y, seed=42, interval="upper")
expected_pv = 0.66505000000000003
expected_ts = -0.13990200413154097
expected_ci = (0.0, 0.6675064023707297)
np.testing.assert_equal(res[0], expected_pv)
np.testing.assert_equal(res[1], expected_ts)
np.testing.assert_almost_equal(res[2], expected_ci)
res = two_sample(x, y, seed=42, interval="lower")
expected_ci = (0.6625865251964975, 1.0)
np.testing.assert_almost_equal(res[2], expected_ci)
res = two_sample(x, y, seed=42, interval="two-sided")
expected_ci = (0.6621149803107692, 0.6679754440683887)
np.testing.assert_almost_equal(res[2], expected_ci)
res = two_sample(x, y, seed=42, keep_dist=True)
exp_dist_firstfive = [
0.089396492796047111, 0.17390295863272254, -0.034211921065956274,
0.29103960535095719, -0.76420778601368644
]
np.testing.assert_equal(res[0], expected_pv)
np.testing.assert_equal(res[1], expected_ts)
np.testing.assert_equal(len(res[2]), 100000)
np.testing.assert_almost_equal(res[2][:5], exp_dist_firstfive)
res = two_sample(x, y, seed=42, interval="two-sided", keep_dist=True)
np.testing.assert_equal(res[0], expected_pv)
np.testing.assert_equal(res[1], expected_ts)
np.testing.assert_almost_equal(res[2], expected_ci)
np.testing.assert_equal(len(res[3]), 100000)
np.testing.assert_almost_equal(res[3][:5], exp_dist_firstfive)
def setUpClass(self):
self._N = 10
self._D = 2
from numpy.random import RandomState
randomstate = RandomState(621360)
self._X = randomstate.normal(0, 1, (self._N, self._D))
self._G0 = randomstate.normal(0, 1, (self._N, 5))
self._G1 = randomstate.normal(0, 1, (self._N, 6))
y = randomstate.rand(self._N)
y[y<=0.5] = -1.0
y[y>0.5] = 1.0
self._y = y
def setUpClass(self):
self._N = 10
self._D = 2
from numpy.random import RandomState
randomstate = RandomState(621360)
self._X = randomstate.normal(0, 1, (self._N, self._D))
self._G0 = randomstate.normal(0, 1, (self._N, 5))
self._G1 = randomstate.normal(0, 1, (self._N, 6))
y = randomstate.rand(self._N)
y[y <= 0.5] = -1.0
y[y > 0.5] = 1.0
self._y = y
def test_two_sample():
prng = RandomState(42)
# Normal-normal, different means examples
x = prng.normal(1, size=20)
y = prng.normal(4, size=20)
res = two_sample(x, y, seed=42)
expected = (1.0, -2.90532344604777)
assert_almost_equal(res, expected, 5)
res = two_sample(x, y, seed=42, plus1=False)
assert_almost_equal(res, expected)
# This one has keep_dist = True
y = prng.normal(1.4, size=20)
res = two_sample(x, y, seed=42)
res2 = two_sample(x, y, seed=42, keep_dist=True)
expected = (0.96975, -0.54460818906623765)
assert_almost_equal(res[0], expected[0], 2)
assert_equal(res[1], expected[1])
assert_almost_equal(res2[0], expected[0], 2)
assert_equal(res2[1], expected[1])
# Normal-normal, same means
y = prng.normal(1, size=20)
res = two_sample(x, y, seed=42)
expected = (0.66505000000000003, -0.13990200413154097)
assert_almost_equal(res[0], expected[0], 2)
assert_equal(res[1], expected[1])
# Check the permutation distribution
res = two_sample(x, y, seed=42, keep_dist=True)
expected_pv = 0.66505000000000003
expected_ts = -0.13990200413154097
exp_dist_firstfive = [
-0.1312181, 0.1289127, -0.3936627, -0.1439892, 0.7477683
]
assert_almost_equal(res[0], expected_pv, 2)
assert_equal(res[1], expected_ts)
assert_equal(len(res[2]), 100000)
assert_almost_equal(res[2][:5], exp_dist_firstfive)
# Define a lambda function (K-S test)
f = lambda u, v: np.max([
abs(sum(u <= val) / len(u) - sum(v <= val) / len(v))
for val in np.concatenate([u, v])
])
res = two_sample(x, y, seed=42, stat=f, reps=100, plus1=False)
expected = (0.62, 0.20000000000000007)
assert_equal(res[0], expected[0])
assert_equal(res[1], expected[1])
def test_two_sample():
prng = RandomState(42)
# Normal-normal, different means examples
x = prng.normal(1, size=20)
y = prng.normal(4, size=20)
res = two_sample(x, y, seed=42)
expected = (1.0, -2.90532344604777)
np.testing.assert_almost_equal(res, expected)
# This one has keep_dist = True
y = prng.normal(1.4, size=20)
res = two_sample(x, y, seed=42)
res2 = two_sample(x, y, seed=42, keep_dist=True)
expected = (0.96975, -0.54460818906623765)
np.testing.assert_approx_equal(res[0], expected[0], 2)
np.testing.assert_equal(res[1], expected[1])
np.testing.assert_approx_equal(res2[0], expected[0], 2)
np.testing.assert_equal(res2[1], expected[1])
# Normal-normal, same means
y = prng.normal(1, size=20)
res = two_sample(x, y, seed=42)
expected = (0.66505000000000003, -0.13990200413154097)
np.testing.assert_approx_equal(res[0], expected[0], 2)
np.testing.assert_equal(res[1], expected[1])
# Check the permutation distribution
res = two_sample(x, y, seed=42, keep_dist=True)
expected_pv = 0.66505000000000003
expected_ts = -0.13990200413154097
exp_dist_firstfive = [0.08939649,
-0.26323896,
0.15428355,
-0.0294264,
0.03318078]
np.testing.assert_approx_equal(res[0], expected_pv, 2)
np.testing.assert_equal(res[1], expected_ts)
np.testing.assert_equal(len(res[2]), 100000)
np.testing.assert_almost_equal(res[2][:5], exp_dist_firstfive)
# Define a lambda function (K-S test)
f = lambda u,v: np.max( \
[abs(sum(u<=val)/len(u)-sum(v<=val)/len(v)) \
for val in np.concatenate([u,v])])
res = two_sample(x, y, seed=42, stat=f, reps=100)
expected = (0.68, 0.20000000000000007)
np.testing.assert_equal(res[0], expected[0])
np.testing.assert_equal(res[1], expected[1])
def test_two_sample():
prng = RandomState(42)
# Normal-normal, different means examples
x = prng.normal(1, size=20)
y = prng.normal(4, size=20)
res = two_sample(x, y, seed=42)
expected = (1.0, -2.90532344604777)
np.testing.assert_almost_equal(res, expected)
# This one has keep_dist = True
y = prng.normal(1.4, size=20)
res = two_sample(x, y, seed=42)
res2 = two_sample(x, y, seed=42, keep_dist=True)
expected = (0.96975, -0.54460818906623765)
np.testing.assert_approx_equal(res[0], expected[0], 2)
np.testing.assert_equal(res[1], expected[1])
np.testing.assert_approx_equal(res2[0], expected[0], 2)
np.testing.assert_equal(res2[1], expected[1])
# Normal-normal, same means
y = prng.normal(1, size=20)
res = two_sample(x, y, seed=42)
expected = (0.66505000000000003, -0.13990200413154097)
np.testing.assert_approx_equal(res[0], expected[0], 2)
np.testing.assert_equal(res[1], expected[1])
# Check the permutation distribution
res = two_sample(x, y, seed=42, keep_dist=True)
expected_pv = 0.66505000000000003
expected_ts = -0.13990200413154097
exp_dist_firstfive = [
0.08939649, -0.26323896, 0.15428355, -0.0294264, 0.03318078
]
np.testing.assert_approx_equal(res[0], expected_pv, 2)
np.testing.assert_equal(res[1], expected_ts)
np.testing.assert_equal(len(res[2]), 100000)
np.testing.assert_almost_equal(res[2][:5], exp_dist_firstfive)
# Define a lambda function (K-S test)
f = lambda u, v: np.max([
abs(sum(u <= val) / len(u) - sum(v <= val) / len(v))
for val in np.concatenate([u, v])
])
res = two_sample(x, y, seed=42, stat=f, reps=100)
expected = (0.68, 0.20000000000000007)
np.testing.assert_equal(res[0], expected[0])
np.testing.assert_equal(res[1], expected[1])
def fake_particle_ds(
fields=("particle_position_x", "particle_position_y",
"particle_position_z", "particle_mass", "particle_velocity_x",
"particle_velocity_y", "particle_velocity_z"),
units=('cm', 'cm', 'cm', 'g', 'cm/s', 'cm/s', 'cm/s'),
negative=(False, False, False, False, True, True, True),
npart=16**3,
length_unit=1.0,
data=None):
from yt.frontends.stream.api import load_particles
prng = RandomState(0x4d3d3d3)
if not iterable(negative):
negative = [negative for f in fields]
assert (len(fields) == len(negative))
offsets = []
for n in negative:
if n:
offsets.append(0.5)
else:
offsets.append(0.0)
data = {}
for field, offset, u in zip(fields, offsets, units):
if field in data:
v = data[field]
continue
if "position" in field:
v = prng.normal(loc=0.5, scale=0.25, size=npart)
np.clip(v, 0.0, 1.0, v)
v = (prng.random_sample(npart) - offset)
data[field] = (v, u)
bbox = np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0]])
ds = load_particles(data, 1.0, bbox=bbox)
return ds
def setupSeed(hoursBetweenTimestepInROMSFiles,startTime,endTime,startSpawningTime,endSpawningTime,releaseParticles):
##################################################
# Create seed variation as function of day
##################################################
# Make datetime array from start to end at 3 hour interval
difference=endTime-startTime
hoursOfSimulation=divmod(difference.total_seconds(), 3600)
difference=endSpawningTime-startSpawningTime
hoursOfSpawning=divmod(difference.total_seconds(), 3600)
timeStepsSimulation=int(int(hoursOfSimulation[0])/hoursBetweenTimestepInROMSFiles)
print "\nKINO TIME EVOLUTION:"
print "=>SIMULATION: Drift simulation will run for %s simulation hours" %(timeStepsSimulation)
print "=>SPAWNING: Simulated spawning will run for %s simulation hours\n initiated on %s and ending on %s"%(timeStepsSimulation,startSpawningTime,endSpawningTime)
interval = timedelta(hours=24)
hoursPerSpawning=divmod(interval.total_seconds(), 3600) #hours per spawning event
timeStepsSpawning=int(int(hoursOfSpawning[0])/int(hoursPerSpawning[0])) #number of spawning timesteps
spawningTimes = [startSpawningTime + interval*n for n in range(timeStepsSpawning)] #times of spawning
# Normal distribution around 0.5
mu, sigma = 0.5, 0.1 # mean and standard deviation
prng = RandomState(1) # random number generator (specify number to ensure the same sequence each time)
s = prng.normal(mu, sigma, len(spawningTimes)) # random distribution
num=(s*releaseParticles).astype(int) # number of particles released per spawning event
print num #timeStepsSpawning * releaseParticles * mu gives approx. number of particles released
num=np.sort(num) #sort particles in increasing order
num=np.concatenate((num[len(num)%2::2],num[::-2]),axis=0) #release the highest number of particles at the midpoint of the spawning period
print "SPAWNING: Simulated spawning will release %s eggs"%(np.sum(num))
return num, spawningTimes
def fit(self, X, y):
""" Fit training data.
Parameters
----------
X : {array-like}, shape = [n_samples, n_features]
Training vectors, where n_samples is the number of samples and
n_features is the number of features.
y : array-like, shape = [n_samples]
Target values.
Returns
-------
self : object
"""
rgen = RandomState(self.random_state)
self.w_ = rgen.normal(loc=0.0, scale=0.01, size=1 + X.shape[1])
self.cost_ = []
for i in range(self.n_iter):
net_input = self.net_input(X)
# Please note that the "activation" method has no effect
# in the code since it is simply an identity function. We
# could write `output = self.net_input(X)` directly instead.
# The purpose of the activation is more conceptual, i.e.,
# in the case of logistic regression (as we will see later),
# we could change it to
# a sigmoid function to implement a logistic regression classifier.
output = self.activation(net_input)
errors = (y - output)
self.w_[1:] += self.eta * X.T.dot(errors)
self.w_[0] += self.eta * errors.sum()
cost = (errors**2).sum() / 2.0
self.cost_.append(cost)
return self
def shared_normal(shape, scale=1, rng=None, name=None):
"""Initialize a matrix shared variable with normally distributed elements."""
if rng is None:
rng = RandomState(seed=np.random.randint(1 << 30))
return theano.shared(rng.normal(
scale=scale, size=shape).astype(theano.config.floatX),
name=name)
def generate_rand_obs(nExp, nObs, domainBounds, sigvar=None, rng=None):
# create random sets of observations for each experiment
if not sigvar: sigvar = 1.
if not rng: rng = RandomState()
domainBounds = npa(domainBounds)
dimX = domainBounds.shape[0]
minX = domainBounds[:, 0]
maxX = domainBounds[:, 1]
rangeX = maxX - minX
xObs = rng.uniform(size=(nExp, nObs, dimX))
xObs *= rangeX
xObs += minX
yObs = empty(shape=(nExp, nObs))
for iexp in xrange(nExp):
good = False
while not good:
yObs0 = rng.normal(size=(nObs))
if yObs0.max() > 0: good = True
yObs[iexp, :] = yObs0
# yObs = rng.normal(size=(nExp, nObs, 1))
yObs *= sigvar
return {'x': xObs,
'y': yObs}
class ParticleSource(SerializableH5):
def __init__(self, name, shape, initial_number_of_particles, particles_to_generate_each_step, mean_momentum,
temperature, charge, mass):
if initial_number_of_particles <= 0:
raise ValueError("initial_number_of_particles <= 0")
if particles_to_generate_each_step < 0:
raise ValueError("particles_to_generate_each_step < 0")
if temperature < 0:
raise ValueError("temperature < 0")
if mass < 0:
raise ValueError("mass < 0")
self.name = name
self.shape = shape
self.initial_number_of_particles = initial_number_of_particles
self.particles_to_generate_each_step = particles_to_generate_each_step
self.mean_momentum = mean_momentum
self.temperature = temperature
self.charge = charge
self.mass = mass
self._generator = RandomState()
def generate_initial_particles(self):
return self.generate_num_of_particles(self.initial_number_of_particles)
def generate_each_step(self):
return self.generate_num_of_particles(self.particles_to_generate_each_step)
def generate_num_of_particles(self, num_of_particles):
pos = self.shape.generate_uniform_random_posititons(self._generator, num_of_particles)
mom = self._generator.normal(self.mean_momentum, sqrt(self.mass * self.temperature), (num_of_particles, 3))
return ParticleArray(range(num_of_particles), self.charge, self.mass, pos, mom)
def test_one_sample():
prng = RandomState(42)
x = np.array(range(5))
y = x - 1
# case 1: one sample only
res = one_sample(x, seed=42, reps=100)
np.testing.assert_almost_equal(res[0], 0.05999999)
np.testing.assert_equal(res[1], 2)
# case 2: paired sample
res = one_sample(x, y, seed=42, reps=100)
np.testing.assert_equal(res[0], 0.02)
np.testing.assert_equal(res[1], 1)
# case 3: break it - supply x and y, but not paired
y = np.append(y, 10)
assert_raises(ValueError, one_sample, x, y)
# case 4: say keep_dist=True
res = one_sample(x, seed=42, reps=100, keep_dist=True)
np.testing.assert_almost_equal(res[0], 0.05999999)
np.testing.assert_equal(res[1], 2)
np.testing.assert_equal(min(res[2]), -2)
np.testing.assert_equal(max(res[2]), 2)
np.testing.assert_equal(np.median(res[2]), 0)
# case 5: use t as test statistic
y = x + prng.normal(size=5)
res = one_sample(x, y, seed=42, reps=100, stat="t", alternative="less")
np.testing.assert_almost_equal(res[0], 0.05)
np.testing.assert_almost_equal(res[1], -1.4491883)
def _randomize_sim(self, random_state: RandomState):
values = self._randomizer_param_values
assert isinstance(values, np.ndarray)
timeconst_mean, timeconst_std, dampratio_mean, dampratio_std = values
assert timeconst_std >= 0.0
assert dampratio_std >= 0.0
self.sim.model.geom_solref[:, 0] = self._initial_value[:, 0] * np.exp(
random_state.normal(timeconst_mean,
scale=timeconst_std,
size=self._initial_value.shape[0]))
self.sim.model.geom_solref[:, 1] = self._initial_value[:, 1] * np.exp(
random_state.normal(dampratio_mean,
scale=dampratio_std,
size=self._initial_value.shape[0]))
def six_node_graph():
Path('data').mkdir(exist_ok=True)
rng = RandomState(1)
graph = GraphModel()
rv_dim = 2
# init varnode
for _ in range(6):
potential = np.ones([rv_dim])
varnode = VarNode(rv_dim, potential)
graph.add_varnode(varnode)
# init factornode
edges = [
[0, 1],
[1, 2],
[1, 3],
[3, 4],
[3, 5]
]
for item in edges:
potential = rng.normal(size=[rv_dim, rv_dim])
factorname = [f"VarNode_{data:03d}" for data in item]
factornode = FactorNode(factorname, np.exp(potential))
graph.add_factornode(factornode)
graph.plot(f"data/six_node_graph.png")
return graph
def test_one_sample():
prng = RandomState(42)
x = np.array(range(5))
y = x-1
# case 1: one sample only
res = one_sample(x, seed = 42, reps = 100)
np.testing.assert_almost_equal(res[0], 0.05999999)
np.testing.assert_equal(res[1], 2)
# case 2: paired sample
res = one_sample(x, y, seed = 42, reps = 100)
np.testing.assert_equal(res[0], 0.02)
np.testing.assert_equal(res[1], 1)
# case 3: break it - supply x and y, but not paired
y = np.append(y, 10)
assert_raises(ValueError, one_sample, x, y)
# case 4: say keep_dist=True
res = one_sample(x, seed = 42, reps = 100, keep_dist=True)
np.testing.assert_almost_equal(res[0], 0.05999999)
np.testing.assert_equal(res[1], 2)
np.testing.assert_equal(min(res[2]), -2)
np.testing.assert_equal(max(res[2]), 2)
np.testing.assert_equal(np.median(res[2]), 0)
# case 5: use t as test statistic
y = x + prng.normal(size=5)
res = one_sample(x, y, seed = 42, reps = 100, stat = "t", alternative = "less")
np.testing.assert_equal(res[0], 0.07)
np.testing.assert_almost_equal(res[1], 1.4491883)
def fit(self, X, y):
"""Fit training data.
Parameters
----------
X : {array-like}, shape = [n_samples, n_features]
Training vectors, where n_samples is the number of samples and
n_features is the number of features.
y : array-like, shape = [n_samples]
Target values.
Returns
-------
self : object
"""
rgen = RandomState(self.random_state)
self.w_ = rgen.normal(loc=0.0, scale=0.01, size=1 + X.shape[1])
self.errors_ = []
for _ in range(self.n_iter):
errors = 0
for xi, target in zip(X, y):
update = self.eta * (target - self.predict(xi))
self.w_[1:] += update * xi
self.w_[0] += update
errors += int(update != 0.0)
self.errors_.append(errors)
return self
def test_01(self):
n = 64
k = 4
random_instance = RandomState()
challenges = [random_instance.choice((-1, +1), n)
for i in range(1000)]
challenges = array(challenges, dtype=int8)
weights = random_instance.normal(loc=0, scale=1, size=(k, n))
transformed_challenges = ph.transform_id(challenges, k)
ph_solution = ph.eval_sign(transformed_challenges, weights)
numpy_solution = sign(
transpose(
array([
dot(
transformed_challenges[:,l],
weights[l]
)
for l in range(k)
])
)).astype(int)
numpy_solution = array(numpy_solution, dtype=int8, copy=True)
assert_array_equal(
ph_solution,
numpy_solution,
"Comparison of eval_sign with numpy fails."
)
def rand_zern(randker):
N = 48
N_zern = 10
rho_max = 0.9
eps_rho = 1.4
randgen = RandomState(randker)
extents = [-1, 1, -1, 1]
# Construct the coordinates
x = np.linspace(-rho_max, rho_max, N)
rho_spacing = x[1] - x[0]
xx, yy = np.meshgrid(x, x)
rho = np.sqrt(xx ** 2 + yy ** 2)
theta = np.arctan2(xx, yy)
aperture_mask = rho <= eps_rho * rho_max
rho, theta = rho[aperture_mask], theta[aperture_mask]
rho_max = np.max(rho)
extends = [-rho_max, rho_max, -rho_max, rho_max]
# Compute the Zernike series
coef = randgen.normal(size=N_zern)
z = zern.ZernikeNaive(mask=aperture_mask)
phase_map = z(coef=coef, rho=rho, theta=theta, normalize_noll=False, mode='Jacobi', print_option='Silent')
phase_map = zern.rescale_phase_map(phase_map, peak=1)
phase_2d = zern.invert_mask(phase_map, aperture_mask)
return phase_2d
def get_weight(self, date_time, how, error_magnitude=0., error_type=None):
if self.tv_type == 'day:hour':
if how == 'linear':
day = date_time.date()
m = (self.data[day][date_time.hour + 1] -
self.data[day][date_time.hour])
w = self.data[day][date_time.hour] + m * (date_time.minutes /
60)
elif how == 'last':
w = self.data[date_time.day()][date_time.hour]
elif how == 'next':
w = self.data[date_time.day()][date_time.hour + 1]
else:
raise AttributeError("Invalid input for argument 'how'.")
elif self.tv_type == 'day:schedule':
w = min([
t - date_time.time() for t in self.data[date_time.isoweekday()]
if t > date_time.time()
])
elif self.tv_type is None:
w = self.data
else:
raise TypeError("Time variance type corrupted.")
if error_type.lower() in ['normal', 'gaussian']:
w += RandomState.normal(loc=error_magnitude[0],
scale=error_magnitude[1])
elif error_type.lower() == 'uniform':
w += RandomState.uniform(low=error_magnitude[0],
high=error_magnitude[1])
else:
pass
return w
def transform(X_input):
"""Calculate the random fourier features for an Gaussian kernel
Keyword arguments:
X_input - the input matrix X_input which will be transformed
"""
# Parameters
m = 3000
gamma = 60
# Copy
X = X_input
# Get the dimensions
d = 0
if len(X.shape)<=1:
d = len(X)
else:
d = X.shape[1]
# Draw iid m samples omega from p and b from [0,2pi]
random_state = RandomState(124)
omega = np.sqrt(2.0 * gamma) * random_state.normal(size=(d, m))
b = random_state.uniform(0, 2 * np.pi, size=m)
# Transform the input
projection = np.dot(X, omega) + b
Z = np.sqrt(2.0/m) * np.cos(projection)
return Z
def fun_rand_problems(N=10, S=100, K=10, d=6, noise_level=1, seed=None):
rng = RandomState(seed)
t = np.arange(S)/S
D = [[10*rng.rand()*np.sin(2*np.pi*K*rng.rand()*t +
(0.5-rng.rand())*np.pi)
for _ in range(d)]
for _ in range(K)]
D = np.array(D)
nD = np.sqrt((D*D).sum(axis=-1))[:, :, np.newaxis]
D /= nD + (nD == 0)
rho = .1*K/(d*S)
pbs = []
for n in range(N):
out.write("\rProblem construction: {:7.2%}".format(n/N))
out.flush()
T = rng.randint(50, 70)
Z = (rng.rand(K, (T-1)*S+1) < rho)*rng.rand(K, (T-1)*S+1)*10
X = np.array([[np.convolve(zk, dk, 'full') for dk in Dk]
for Dk, zk in zip(D, Z)]).sum(axis=0)
X += noise_level*rng.normal(size=X.shape)
pbs += [MultivariateConvolutionalCodingProblem(
D, X, lmbd=.1)]
return pbs, D
def test_two_sample():
prng = RandomState(42)
# Normal-normal, different means examples
x = prng.normal(1, size=20)
y = prng.normal(4, size=20)
res = two_sample(x, y, seed=42)
expected = (1.0, -2.90532344604777)
assert_almost_equal(res, expected, 5)
res = two_sample(x, y, seed=42, plus1=False)
assert_almost_equal(res, expected)
# This one has keep_dist = True
y = prng.normal(1.4, size=20)
res = two_sample(x, y, seed=42)
res2 = two_sample(x, y, seed=42, keep_dist=True)
expected = (0.96975, -0.54460818906623765)
assert_almost_equal(res[0], expected[0], 2)
assert_equal(res[1], expected[1])
assert_almost_equal(res2[0], expected[0], 2)
assert_equal(res2[1], expected[1])
# Normal-normal, same means
y = prng.normal(1, size=20)
res = two_sample(x, y, seed=42)
expected = (0.66505000000000003, -0.13990200413154097)
assert_almost_equal(res[0], expected[0], 2)
assert_equal(res[1], expected[1])
# Check the permutation distribution
res = two_sample(x, y, seed=42, keep_dist=True)
expected_pv = 0.66505000000000003
expected_ts = -0.13990200413154097
exp_dist_firstfive = [-0.1312181, 0.1289127, -0.3936627, -0.1439892, 0.7477683]
assert_almost_equal(res[0], expected_pv, 2)
assert_equal(res[1], expected_ts)
assert_equal(len(res[2]), 100000)
assert_almost_equal(res[2][:5], exp_dist_firstfive)
# Define a lambda function (K-S test)
f = lambda u, v: np.max(
[abs(sum(u <= val) / len(u) - sum(v <= val) / len(v))
for val in np.concatenate([u, v])])
res = two_sample(x, y, seed=42, stat=f, reps=100, plus1=False)
expected = (0.62, 0.20000000000000007)
assert_equal(res[0], expected[0])
assert_equal(res[1], expected[1])
def test_two_sample_shift():
prng = RandomState(42)
# Normal-normal, different means examples
x = prng.normal(1, size=20)
y = prng.normal(4, size=20)
f = lambda u: u - 3
finv = lambda u: u + 3
f_err = lambda u: 2 * u
f_err_inv = lambda u: u / 2
expected_ts = -2.9053234460477784
# Test null with shift other than zero
res = two_sample_shift(x, y, seed=42, shift=2, plus1=False)
assert res[0] == 1
assert res[1] == expected_ts
print("finished test 1 in test_two_sample_shift()")
res2 = two_sample_shift(x, y, seed=42, shift=2, keep_dist=True)
np.testing.assert_almost_equal(res2[0], 1, 4)
assert res2[1] == expected_ts
np.testing.assert_almost_equal(res2[2][:3],
np.array([1.140174, 2.1491466, 2.6169429]))
print("finished test 2 in test_two_sample_shift()")
res = two_sample_shift(x, y, seed=42, shift=2, alternative="less")
np.testing.assert_almost_equal(res[0], 0, 3)
assert res[1] == expected_ts
print("finished test 3 in test_two_sample_shift()")
# Test null with shift -3
res = two_sample_shift(x, y, seed=42, shift=(f, finv))
np.testing.assert_almost_equal(res[0], 0.377, 2)
assert res[1] == expected_ts
print("finished test 4 in test_two_sample_shift()")
res = two_sample_shift(x, y, seed=42, shift=(f, finv), alternative="less")
np.testing.assert_almost_equal(res[0], 0.622, 2)
assert res[1] == expected_ts
print("finished test 5 in test_two_sample_shift()")
# Test null with multiplicative shift
res = two_sample_shift(x,
y,
seed=42,
shift=(f_err, f_err_inv),
alternative="two-sided")
np.testing.assert_almost_equal(res[0], 0, 3)
assert res[1] == expected_ts
print("finished test 6 in test_two_sample_shift()")
# Define a lambda function
f = lambda u, v: np.max(u) - np.max(v)
res = two_sample(x, y, seed=42, stat=f, reps=100)
expected = (1, -3.2730653690015465)
assert res[0] == expected[0]
assert res[1] == expected[1]
print("finished test 7 in test_two_sample_shift()")
def fun_rand_problem(T, S, K, d, lmbd, noise_level, seed=None):
rng = RandomState(seed)
rho = K / (d * S)
D = rng.normal(scale=10.0, size=(K, d, S))
D = np.array(D)
nD = np.sqrt((D * D).sum(axis=-1, keepdims=True))
D /= nD + (nD == 0)
Z = (rng.rand(K, (T - 1) * S + 1) < rho).astype(np.float64)
Z *= rng.normal(scale=10, size=(K, (T - 1) * S + 1))
X = np.array([[np.convolve(zk, dk, 'full') for dk in Dk]
for Dk, zk in zip(D, Z)]).sum(axis=0)
X += noise_level * rng.normal(size=X.shape)
z0 = np.zeros((K, (T - 1) * S + 1))
pb = MultivariateConvolutionalCodingProblem(D, X, z0=z0, lmbd=lmbd)
return pb
def synthetic(n, phi=0.9, k=3, var=1, seed=1):
"""Auto-regressive test data generator."""
prng = RandomState(seed)
P = zeros((n,))
X = zeros((n,))
# Initial values for P, X.
P[0] = prng.normal(0,var)
X[0] = prng.normal(0, var)
for i in xrange(1, n):
P[i] = P[i-1] + X[i-1] + k*prng.normal(0, var)
X[i] = phi*X[i-1] + prng.normal(0, var)
R = max(P) - min(P)
Z = exp(P/R)
return Z
def setup_class(self):
self.initial_values = [100, 5, 1]
func = lambda p, x: p[0] * np.exp(-0.5 / p[2] ** 2 * (x - p[1]) ** 2)
errf = lambda p, x, y: (func(p, x) - y)
self.xdata = np.arange(0, 10, 0.1)
sigma = 8. * np.ones_like(self.xdata)
rsn = RandomState(1234567890)
yerror = rsn.normal(0, sigma)
self.ydata = func(self.initial_values, self.xdata) + yerror
def solve(self, optimization_function):
rand = RandomState(self.seed)
X = optimization_function.X
n_dim = X.shape[1]
for i in range(self.n_mc):
hyperplane_normal = rand.normal(0, 1, n_dim)
optimization_function.compute(hyperplane_normal)
class ParticleSource(SerializableH5):
@inject.params(shape=Box)
def __init__(self,
name="particle_source",
shape=None,
initial_number_of_particles: int = 0,
particles_to_generate_each_step: int = 0,
mean_momentum: VectorInput = 0,
temperature: float = 0.,
charge: float = 0.,
mass: float = 1.):
self.name = name
self.shape = shape
self.initial_number_of_particles = initial_number_of_particles
self.particles_to_generate_each_step = particles_to_generate_each_step
self.mean_momentum = vector(mean_momentum)
self.temperature = temperature
self.charge = charge
self.mass = mass
self._generator = RandomState()
def generate_initial_particles(self) -> ParticleArray:
return self.generate_num_of_particles(self.initial_number_of_particles)
def generate_each_step(self):
return self.generate_num_of_particles(
self.particles_to_generate_each_step)
def generate_num_of_particles(self, num_of_particles):
pos = self.shape.generate_uniform_random_posititons(
self._generator, num_of_particles)
mom = self._generator.normal(self.mean_momentum,
sqrt(self.mass * self.temperature),
(num_of_particles, 3))
return ParticleArray(range(num_of_particles), self.charge, self.mass,
pos, mom)
@staticmethod
def import_h5(g):
from ef.config.components import Shape
ga = g.attrs
shape = Shape.import_h5(g, region=False)
name = g.name.split('/')[-1]
momentum = np.array([ga['mean_momentum_{}'.format(c)]
for c in 'xyz']).reshape(3)
return ParticleSource(name, shape,
int(ga['initial_number_of_particles']),
int(ga['particles_to_generate_each_step']),
momentum, float(ga['temperature']),
float(ga['charge']), float(ga['mass']))
def export_h5(self, g):
for k in 'temperature', 'charge', 'mass', 'initial_number_of_particles', 'particles_to_generate_each_step':
g.attrs[k] = [getattr(self, k)]
for i, c in enumerate('xyz'):
g.attrs['mean_momentum_{}'.format(c)] = [self.mean_momentum[i]]
self.shape.export_h5(g, region=False)
def obtainSufficientStatisticsForChainGraphRateMtx(nStates, nRep=5000, bt=5.0, nSeq=100, SDOfBiWeights=0.5, bivariateDictionary=None):
## we generate the sufficient statistics for a large number of replications first
## and then we summarize the sufficient statistics for the forward sampler and
## then we use this data to run HMC and local BPS algorithms separately to see
## if we can obtain reasonable estimates of the exchangeable parameters
seedNum = np.arange(0, nRep)
if bivariateDictionary is None:
bivariateDictionary = getHardCodedDictChainGraph(nStates)
prng = RandomState(1234567890)
stationaryWeights = prng.uniform(0, 1, nStates)
bivariateWeights = prng.normal(0, SDOfBiWeights, int((nStates) * (nStates - 1) / 2))
testRateMtx = ReversibleRateMtxPiAndBinaryWeightsWithGraphicalStructure(nStates, stationaryWeights,
bivariateWeights, bivariateDictionary)
stationaryDist = testRateMtx.getStationaryDist()
rateMatrix = testRateMtx.getRateMtx()
nInit = np.zeros(nStates)
holdTimes = np.zeros(nStates)
nTrans = np.zeros((nStates, nStates))
for i in seedNum:
seqList = generateFullPathUsingRateMtxAndStationaryDist(RandomState(i), nSeq, nStates, rateMatrix,
stationaryDist, bt)
## summarize the sufficient statistics
## extract first state from sequences
firstStates = getFirstAndLastStateOfListOfSeq(seqList)['firstLastState'][:, 0]
unique, counts = np.unique(firstStates, return_counts=True)
nInitCount = np.asarray((unique, counts)).T
nInit = nInit + nInitCount[:, 1]
for j in range(nSeq):
sequences = seqList[j]
holdTimes = holdTimes + sequences['sojourn']
nTrans = nTrans + sequences['transitCount']
print(i)
avgNTrans = nTrans / nRep
avgHoldTimes = holdTimes / nRep
avgNInit = nInit / nRep
result = {}
result['stationaryWeights'] = stationaryWeights
result['bivariateDictionary'] = bivariateDictionary
result['bivariateWeights'] = bivariateWeights
result['rateMatrix'] = rateMatrix
result['stationaryDist'] = stationaryDist
result['exchangeableCoef'] = testRateMtx.getExchangeCoef()
result['transitCount'] = avgNTrans
result['sojourn'] = avgHoldTimes
result['nInit'] = avgNInit
return result
def test_pooling_for_parameters(inputs_shape, pool_shape, pool_stride,
testname):
sys.stdout.write("{:40s} ...".format(testname))
rng = RandomState(hash('tobipuma') % 4294967295)
inputs = rng.normal(size=inputs_shape).astype(np.float32)
dnn_pool3d2d_func = create_dnnpool3d2d_func(pool_shape, pool_stride,
inputs_shape[2:])
reference_result = max_pool_3d_numpy(inputs, pool_shape, pool_stride)
test_function(dnn_pool3d2d_func, testname, reference_result, inputs)
sys.stdout.write(" Ok.\n")
def _randomize_sim(self, random_state: RandomState):
values = self._randomizer_param_values
assert isinstance(values, np.ndarray)
dmax_mean, dmax_std, delta_mean, delta_std, width_mean, width_std = values
assert dmax_std >= 0.0
assert delta_std >= 0.0
assert width_std >= 0.0
# We randomize (1-dmax) since dmax typically very close to 1 and we'd like to cover the
# range [0, 1] well. We then sample delta that is subtracted from dmax to produce dmin,
# thus ensuring that dmin <= dmax holds.
dmax = 1.0 - (1.0 - self._initial_value[:, 1]) * np.exp(
random_state.normal(
dmax_mean, scale=dmax_std, size=self._initial_value.shape[0]))
dmax = np.clip(dmax, *self._drange)
delta = (self._initial_value[:, 1] -
self._initial_value[:, 0]) * np.exp(
random_state.normal(delta_mean,
scale=delta_std,
size=self._initial_value.shape[0]))
dmin = np.clip(dmax - delta, *self._drange)
# Sample width.
width = self._initial_value[:, 2] * np.exp(
random_state.normal(width_mean,
scale=width_std,
size=self._initial_value.shape[0]))
# Validate constraints. Mujoco internally already ensures that dmin and dmax are clipped,
# if necessary (http://mujoco.org/book/modeling.html#CSolver), but we enforce slightly
# stronger constraints for additional stability.
assert dmin.shape == dmax.shape == width.shape
assert (dmin <= dmax).all()
assert (self._drange[0] <= dmin).all()
assert (dmin <= self._drange[1]).all()
assert (self._drange[0] <= dmax).all()
assert (dmax <= self._drange[1]).all()
self.sim.model.geom_solimp[:, 0] = dmin
self.sim.model.geom_solimp[:, 1] = dmax
self.sim.model.geom_solimp[:, 2] = width
def test_01(self):
N = 1000
k = 2
random_instance = RandomState()
responses = array(random_instance.normal(loc=0, scale=1, size=(N, k)))
ph_xor = ph.combiner_xor(responses)
numpy_xor = prod(responses, 1)
assert_array_equal(ph_xor, numpy_xor,
"Comparison of combiner_xor with numpy fails.")
def bimodal_demand(
number_of_flows: int, random_state: RandomState = RandomState()) -> Demand:
"""
Generates bimodal demand (probabilistic) for one time step
Args:
number_of_flows: the number of flows to create
random_state: numpy RandomState (for seeding)
Returns:
A demand array
"""
demand = np.zeros(number_of_flows, dtype=float)
for i in range(number_of_flows):
# Coin flip
if random_state.uniform() < 0.8:
# Standard flow
demand[i] = random_state.normal(150, 20)
else:
# Elephant flow
demand[i] = random_state.normal(800, 20)
return demand
def _randomize_sim(self, random_state: RandomState):
values = self._randomizer_param_values
assert isinstance(values, np.ndarray)
self.sim.model.actuator_gainprm[:, self.
_idx] = self._initial_value * np.exp(
random_state.normal(
values[0],
scale=abs(values[1]),
size=self._initial_value.shape)
)
class LSTDRP(td.LSTDLambdaJP):
"""
LSTD-l1
regularized LSTD approach adding an l1 penalty on the A * theta - b residuals.
A Danzuig Selector Approach to Temporal Difference Learning
Geist M., Scherrer B., ... (ICML 2012)
"""
def __init__(self, dim_lower, seed=None, **kwargs):
self.dim_lower = dim_lower
self.seed = seed
td.LSTDLambdaJP.__init__(self, **kwargs)
def reset(self):
td.LSTDLambdaJP.reset(self)
if self.seed is not None:
self.prng = RandomState(self.seed)
else:
self.prng = np.random
@property
def theta(self):
try:
self._tic()
D = self.C1.shape[0]
n = self.t
if self.dim_lower < 1:
dim_lower = np.sqrt(n)
dim_lower = np.maximum(1, dim_lower)
dim_lower = int(dim_lower) + 1
else:
dim_lower = self.dim_lower
proj = self.prng.normal(scale=1.0 / np.sqrt(dim_lower), size=(dim_lower, D))
# for debugging, sanity check!
# dim_lower = 6
# proj = np.eye(D)[:dim_lower,:]
A = np.dot(proj, np.dot(-self.C1 - self.C2, proj.T))
b = np.dot(proj, self.b)
# Phi = np.dot(self.Phi.finalized, proj)
# Psi = np.dot(self.Psi.finalized, proj)
# b = np.dot(Phi.T, self.R.finalized.flatten()).flatten()
# A = np.dot(Phi.T, Psi)
theta_t = np.dot(np.linalg.pinv(A), b)
return np.dot(theta_t, proj).flatten()
except np.linalg.LinAlgError, e:
print e
return np.zeros_like(self.b)
finally:
def block(seed):
""" Return block of normal random numbers
Parameters
----------
seed : {None, int}
The seed to generate the noise.sd
Returns
--------
noise : numpy.ndarray
Array of random numbers
"""
num = SAMPLE_RATE * BLOCK_SIZE
rng = RandomState(seed % 2**32)
variance = SAMPLE_RATE / 2
return rng.normal(size=num, scale=variance**0.5)
def test_two_sample_shift():
prng = RandomState(42)
# Normal-normal, different means examples
x = prng.normal(1, size=20)
y = prng.normal(4, size=20)
f = lambda u: u - 3
finv = lambda u: u + 3
f_err = lambda u: 2 * u
f_err_inv = lambda u: u / 2
expected_ts = -2.9053234460477784
# Test null with shift other than zero
res = two_sample_shift(x, y, seed=42, shift=2, plus1=False)
assert_equal(res[0], 1)
assert_equal(res[1], expected_ts)
res2 = two_sample_shift(x, y, seed=42, shift=2, keep_dist=True)
assert_almost_equal(res2[0], 1, 4)
assert_equal(res2[1], expected_ts)
assert_almost_equal(res2[2][:3], np.array(
[1.140174 , 2.1491466, 2.6169429]))
res = two_sample_shift(x, y, seed=42, shift=2, alternative="less")
assert_almost_equal(res[0], 0, 3)
assert_equal(res[1], expected_ts)
# Test null with shift -3
res = two_sample_shift(x, y, seed=42, shift=(f, finv))
assert_almost_equal(res[0], 0.377, 2)
assert_equal(res[1], expected_ts)
res = two_sample_shift(x, y, seed=42, shift=(f, finv), alternative="less")
assert_almost_equal(res[0], 0.622, 2)
assert_equal(res[1], expected_ts)
# Test null with multiplicative shift
res = two_sample_shift(x, y, seed=42,
shift=(f_err, f_err_inv), alternative="two-sided")
assert_almost_equal(res[0], 0, 3)
assert_equal(res[1], expected_ts)
# Define a lambda function
f = lambda u, v: np.max(u) - np.max(v)
res = two_sample(x, y, seed=42, stat=f, reps=100)
expected = (1, -3.2730653690015465)
assert_equal(res[0], expected[0])
assert_equal(res[1], expected[1])
def test_two_sample_shift():
prng = RandomState(42)
# Normal-normal, different means examples
x = prng.normal(1, size=20)
y = prng.normal(4, size=20)
f = lambda u: u - 3
finv = lambda u: u + 3
f_err = lambda u: 2 * u
f_err_inv = lambda u: u / 2
expected_ts = -2.9053234460477784
# Test null with shift other than zero
res = two_sample_shift(x, y, seed=42, shift=2)
np.testing.assert_equal(res[0], 1)
np.testing.assert_equal(res[1], expected_ts)
res2 = two_sample_shift(x, y, seed=42, shift=2, keep_dist=True)
np.testing.assert_equal(res2[0], 1)
np.testing.assert_equal(res2[1], expected_ts)
np.testing.assert_almost_equal(res2[2][:3], np.array(
[1.55886506, 0.87281296, 1.13611123]))
res = two_sample_shift(x, y, seed=42, shift=2, alternative="less")
np.testing.assert_equal(res[0], 0)
np.testing.assert_equal(res[1], expected_ts)
# Test null with shift -3
res = two_sample_shift(x, y, seed=42, shift=(f, finv))
np.testing.assert_equal(res[0], 0.38074999999999998)
np.testing.assert_equal(res[1], expected_ts)
res = two_sample_shift(x, y, seed=42, shift=(f, finv), alternative="less")
np.testing.assert_almost_equal(res[0], 0.61925)
np.testing.assert_equal(res[1], expected_ts)
# Test null with multiplicative shift
res = two_sample_shift(x, y, seed=42,
shift=(f_err, f_err_inv), alternative="two-sided")
np.testing.assert_equal(res[0], 0)
np.testing.assert_equal(res[1], expected_ts)
# Define a lambda function
f = lambda u, v: np.max(u) - np.max(v)
res = two_sample(x, y, seed=42, stat=f, reps=100)
expected = (1, -3.2730653690015465)
np.testing.assert_equal(res[0], expected[0])
np.testing.assert_equal(res[1], expected[1])
class BetaModelSource(object):
def __init__(self):
self.prng = RandomState(32)
self.kT = kT
self.Z = Z
self.O = O
self.Ca = Ca
nx = 128
ddims = (nx,nx,nx)
x, y, z = np.mgrid[-R:R:nx*1j,
-R:R:nx*1j,
-R:R:nx*1j]
r = np.sqrt(x**2+y**2+z**2)
dens = np.zeros(ddims)
dens[r <= R] = rho_c*(1.+(r[r <= R]/r_c)**2)**(-1.5*beta)
dens[r > R] = 0.0
pden = np.zeros(ddims)
x = r[r <= R]/r_s
pden[r <= R] = rho_s/(x*(1.+x)**2)
pden[r > R] = 0.0
temp = self.kT*K_per_keV*np.ones(ddims)
bbox = np.array([[-0.5,0.5],[-0.5,0.5],[-0.5,0.5]])
velz = self.prng.normal(loc=v_shift,scale=v_width,size=ddims)
dm_disp = 1000.*np.ones(ddims) # km/s
data = {}
data["density"] = (dens, "g/cm**3")
data["dark_matter_density"] = (pden, "g/cm**3")
data["dark_matter_dispersion"] = (dm_disp, "km/s")
data["temperature"] = (temp, "K")
data["velocity_x"] = (np.zeros(ddims), "cm/s")
data["velocity_y"] = (np.zeros(ddims), "cm/s")
data["velocity_z"] = (velz, "cm/s")
data["oxygen"] = (self.O*np.ones(ddims), "Zsun")
data["calcium"] = (self.Ca*np.ones(ddims), "Zsun")
data["metallicity"] = (self.Z*np.ones(ddims), "Zsun")
self.ds = load_uniform_grid(data, ddims, length_unit=(2*R, "Mpc"),
nprocs=64, bbox=bbox)
class ParticleBetaModelSource(object):
def __init__(self):
self.prng = RandomState(35)
self.kT = kT
self.Z = Z
num_particles = 1000000
rr = np.linspace(0.0, R, 10000)
# This formula assumes beta = 2/3
M_r = 4*np.pi*rho_c*r_c*r_c*(rr-r_c*np.arctan(rr/r_c))
M_r *= cm_per_mpc**3
pmass = M_r[-1]*np.ones(num_particles)/num_particles
M_r /= M_r[-1]
u = self.prng.uniform(size=num_particles)
radius = np.interp(u, M_r, rr, left=0.0, right=1.0)
dens = rho_c*(1.+(radius/r_c)**2)**(-1.5*beta)
radius /= (2.*R)
theta = np.arccos(self.prng.uniform(low=-1.,high=1.,size=num_particles))
phi = 2.*np.pi*self.prng.uniform(size=num_particles)
temp = self.kT*K_per_keV*np.ones(num_particles)
velz = self.prng.normal(loc=v_shift,scale=v_width,size=num_particles)
bbox = np.array([[-0.5,0.5],[-0.5,0.5],[-0.5,0.5]])
data = {}
data["io", "density"] = (dens, "g/cm**3")
data["io", "temperature"] = (temp, "K")
data["io", "particle_position_x"] = (radius*np.sin(theta)*np.cos(phi), "code_length")
data["io", "particle_position_y"] = (radius*np.sin(theta)*np.sin(phi), "code_length")
data["io", "particle_position_z"] = (radius*np.cos(theta), "code_length")
data["io", "particle_velocity_x"] = (np.zeros(num_particles), "cm/s")
data["io", "particle_velocity_y"] = (np.zeros(num_particles), "cm/s")
data["io", "particle_velocity_z"] = (velz, "cm/s")
data["io", "particle_mass"] = (pmass, "g")
self.ds = load_particles(data, length_unit=(2*R, "Mpc"), bbox=bbox)
def dsim(g, xdists, u_to_x, T, seed, maxitr, tol, ftol, eps):
"""
Directional simulation.
"""
# Seed the random number generator if required
if seed == -1:
prng = RandomState()
else:
prng = RandomState(seed)
ndims = len(xdists)
rays = prng.normal(0, 1, size=(maxitr, ndims))
unit_rays = rays/la.norm(rays)
pfs = zeros(maxitr)
for i, ray in enumerate(unit_rays):
d_ray = 1
ray0 = ray
while abs(g(u_to_x(ray, xdists, T))) > ftol and abs(d_ray) > ftol:
# Calculate gradient and directional derivative
grad = dgdu(g, ray, u_to_x, xdists, T, eps)
dderiv = dot(grad, ray/la.norm(ray))
# delta length of ray is g function / directional derivative
d_ray = g(u_to_x(ray, xdists, T))/dderiv
ray = ray - d_ray*ray/la.norm(ray)
# Only store a non-zero pf if the ray hasn't changed direction
pfs[i] = 1 - chi2.cdf(la.norm(ray)**2, ndims) if dot(ray0, ray) > 0 else 0
pfs[isnan(pfs)] = 0
mu_pf, std_pf = pfs.mean(), pfs.std()
se_pf = std_pf/sqrt(maxitr)
cv_pf = se_pf/mu_pf
beta = -norm.ppf(mu_pf) if mu_pf < 0.5 else norm.ppf(mu_pf)
msgs = []
return {'vars': xdists, 'beta': beta, 'Pf': mu_pf, 'stderr': se_pf,
'stdcv': cv_pf, 'nitr': maxitr, 'g_beta': -1, 'msgs': msgs}
rng = RandomState(int(sys.argv[1]))
params_file = open(sys.argv[2], "r")
output_file = open(sys.argv[3], "w")
params = { line.split("=")[0].strip() : eval(line.split("=")[1])
for line in open("params/default_params") }
for line in params_file :
params[line.split("=")[0].strip()] = eval(line.split("=")[1])
params_file.close()
target_features = [BinaryFeature.create_random(rng, params["NUM_INPUT_VARS"],
params["BETA"])
for _ in range(params["NUM_HIDDEN_TARGETS"])]
#make random weights, but don't use bias (this is what Mahmood paper does)
target_weights = np.concatenate((rng.normal(0,1,params["NUM_HIDDEN_TARGETS"]),
[0]))
target_functions = [Learner(target_features, target_weights)]
if params["NON_STATIONARY"] :
features_to_replace = choice_without_replacement(rng,
params["NUM_HIDDEN_TARGETS"],
params["PERCENT_TARGET_FEATURES_TO_REPLACE"] *
params["NUM_HIDDEN_TARGETS"])
target_features = [BinaryFeature(feature.weights,
feature.beta)
for feature in target_features]
target_weights = target_weights.copy()
for f in features_to_replace :
import pandas as pd
from nose.tools import (assert_almost_equal, assert_equal)
from numpy.random import RandomState
from rsmtool.analysis import (correlation_helper,
metrics_helper)
prng = RandomState(133)
df_features = pd.DataFrame({'sc1': [1, 2, 3, 4, 1, 2, 3, 4, 1, 2],
'f1': prng.normal(0, 1, 10),
'f2': prng.normal(1, 0.1, 10),
'f3': prng.normal(2, 0.1, 10),
'group': ['group1']*10},
index = range(0, 10))
df_features_same_score = df_features.copy()
df_features_same_score[['sc1']] = [3]*10
human_scores = pd.Series(prng.randint(1, 5, size=10))
system_scores = pd.Series(prng.random_sample(10)*5)
same_human_scores = pd.Series([3]*10)
def test_correlation_helper():
# test that there are no nans for data frame with 10 values
retval = correlation_helper(df_features, 'sc1', 'group')
assert_equal(retval[0].isnull().values.sum(), 0)
assert_equal(retval[1].isnull().values.sum(), 0)
def test_that_correlation_helper_works_for_data_with_one_row():
elements = list(elements)
rnd.shuffle(elements)
for i in range(len(elements)):
main = elements[i]
other = elements[i-1]
state = reference_states[atomic_numbers[main]]
if state['symmetry'] in known_states:
break
if state['symmetry'] not in known_states:
print "Cannot simulate %s, reference state '%s' not supported" % (main, state['symmetry'])
print "SKIPPING MODEL!"
continue
init_atoms = bulk(main, orthorhombic=True).repeat((7,7,7))
r = init_atoms.get_positions()
r += rnd.normal(0.0, 0.1, r.shape)
init_atoms.set_positions(r)
z = init_atoms.get_atomic_numbers()
if other:
some_atoms = rnd.randint(0, 20, len(init_atoms)) == 0
z[some_atoms] = atomic_numbers[other]
init_atoms.set_atomic_numbers(z)
z_other = atomic_numbers[other]
else:
z_other = 0
print ("Generated a %s system with %i %s-atoms and %i %s-atoms"
% (state['symmetry'],
np.equal(z, atomic_numbers[main]).sum(),
main,
np.equal(z, z_other).sum(),
other))
class TestAnalyzer:
def setUp(self):
self.prng = RandomState(133)
self.df_features = pd.DataFrame({'sc1': [1, 2, 3, 4, 1, 2, 3, 4, 1, 2],
'f1': self.prng.normal(0, 1, 10),
'f2': self.prng.normal(1, 0.1, 10),
'f3': self.prng.normal(2, 0.1, 10),
'group': ['group1'] * 10},
index=range(0, 10))
self.df_features_same_score = self.df_features.copy()
self.df_features_same_score[['sc1']] = [3] * 10
self.human_scores = pd.Series(self.prng.randint(1, 5, size=10))
self.system_scores = pd.Series(self.prng.random_sample(10) * 5)
self.same_human_scores = pd.Series([3] * 10)
# get the directory containing the tests
self.test_dir = dirname(__file__)
def test_correlation_helper(self):
# test that there are no nans for data frame with 10 values
retval = Analyzer.correlation_helper(self.df_features, 'sc1', 'group')
assert_equal(retval[0].isnull().values.sum(), 0)
assert_equal(retval[1].isnull().values.sum(), 0)
def test_that_correlation_helper_works_for_data_with_one_row(self):
# this should return two data frames with nans
# we expect a runtime warning here so let's suppress it
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=RuntimeWarning)
retval = Analyzer.correlation_helper(self.df_features[:1], 'sc1', 'group')
assert_equal(retval[0].isnull().values.sum(), 3)
assert_equal(retval[1].isnull().values.sum(), 3)
def test_that_correlation_helper_works_for_data_with_two_rows(self):
# this should return 1/-1 for marginal correlations and nans for
# partial correlations
retval = Analyzer.correlation_helper(self.df_features[:2], 'sc1', 'group')
assert_equal(abs(retval[0].values).sum(), 3)
assert_equal(retval[1].isnull().values.sum(), 3)
def test_that_correlation_helper_works_for_data_with_three_rows(self):
# this should compute marginal correlations but return Nans for
# partial correlations
retval = Analyzer.correlation_helper(self.df_features[:3], 'sc1', 'group')
assert_equal(retval[0].isnull().values.sum(), 0)
assert_equal(retval[1].isnull().values.sum(), 3)
def test_that_correlation_helper_works_for_data_with_four_rows(self):
# this should compute marginal correlations and return a unity
# matrix for partial correlations
retval = Analyzer.correlation_helper(self.df_features[:4], 'sc1', 'group')
assert_equal(retval[0].isnull().values.sum(), 0)
assert_almost_equal(abs(retval[1].values).sum(), 3)
def test_that_correlation_helper_works_for_data_with_the_same_label(self):
# this should return two data frames with nans
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=RuntimeWarning)
retval = Analyzer.correlation_helper(self.df_features_same_score, 'sc1', 'group')
assert_equal(retval[0].isnull().values.sum(), 3)
assert_equal(retval[1].isnull().values.sum(), 3)
def test_that_metrics_helper_works_for_data_with_one_row(self):
# There should be NaNs for SMD, correlations and both sds
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=RuntimeWarning)
evals = Analyzer.metrics_helper(self.human_scores[0:1],
self.system_scores[0:1])
assert_equal(evals.isnull().values.sum(), 4)
def test_that_metrics_helper_works_for_data_with_the_same_label(self):
# There should be NaNs for correlation.
# Note that for a dataset with a single response
# kappas will be 0 or 1
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=RuntimeWarning)
evals = Analyzer.metrics_helper(self.same_human_scores,
self.system_scores)
assert_equal(evals.isnull().values.sum(), 1)
def test_metrics_helper_population_sds(self):
df_new_features = pd.read_csv(join(self.test_dir, 'data', 'files', 'train.csv'))
# compute the metrics when not specifying the population SDs
computed_metrics1 = Analyzer.metrics_helper(df_new_features['score'],
df_new_features['score2'])
expected_metrics1 = pd.Series({'N': 500.0,
'R2': 0.65340566606389394,
'RMSE': 0.47958315233127197,
'SMD': 0.036736365006090885,
'adj_agr': 100.0,
'corr': 0.82789026370069529,
'exact_agr': 77.0,
'h_max': 6.0,
'h_mean': 3.4199999999999999,
'h_min': 1.0,
'h_sd': 0.81543231461565147,
'kappa': 0.6273493195074531,
'sys_max': 6.0,
'sys_mean': 3.4500000000000002,
'sys_min': 1.0,
'sys_sd': 0.81782496620652367,
'wtkappa': 0.82732732732732728})
# and now compute them specifying the population SDs
computed_metrics2 = Analyzer.metrics_helper(df_new_features['score'],
df_new_features['score2'],
population_human_score_sd=0.5,
population_system_score_sd=0.4)
# the only number that should change is the SMD
expected_metrics2 = expected_metrics1.copy()
expected_metrics2['SMD'] = 0.066259
assert_series_equal(computed_metrics1.sort_index(), expected_metrics1.sort_index())
assert_series_equal(computed_metrics2.sort_index(), expected_metrics2.sort_index())
def test_compute_pca_less_components_than_features(self):
# test pca when we have less components than features
df = pd.DataFrame({'a': range(100)})
for i in range(100):
df[i] = df['a'] * i
(components, variance) = Analyzer.compute_pca(df, df.columns)
assert_equal(len(components.columns), 100)
assert_equal(len(variance.columns), 100)
def test_compute_disattenuated_correlations_single_human(self):
hm_corr = pd.Series([0.9, 0.8, 0.6],
index=['raw', 'raw_trim', 'raw_trim_round'])
hh_corr = pd.Series([0.81], index=[''])
df_dis_corr = Analyzer.compute_disattenuated_correlations(hm_corr,
hh_corr)
assert_equal(len(df_dis_corr), 3)
assert_equal(df_dis_corr.loc['raw', 'corr_disattenuated'], 1.0)
def test_compute_disattenuated_correlations_matching_human(self):
hm_corr = pd.Series([0.9, 0.4, 0.6],
index=['All data', 'GROUP1', 'GROUP2'])
hh_corr = pd.Series([0.81, 0.64, 0.36],
index=['All data', 'GROUP1', 'GROUP2'])
df_dis_corr = Analyzer.compute_disattenuated_correlations(hm_corr,
hh_corr)
assert_equal(len(df_dis_corr), 3)
assert_array_equal(df_dis_corr['corr_disattenuated'], [1.0, 0.5, 1.0])
def test_compute_disattenuated_correlations_single_matching_human(self):
hm_corr = pd.Series([0.9, 0.4, 0.6],
index=['All data', 'GROUP1', 'GROUP2'])
hh_corr = pd.Series([0.81],
index=['All data'])
df_dis_corr = Analyzer.compute_disattenuated_correlations(hm_corr,
hh_corr)
assert_equal(len(df_dis_corr), 3)
assert_array_equal(df_dis_corr['corr_disattenuated'], [1.0, np.nan, np.nan])
def test_compute_disattenuated_correlations_mismatched_indices(self):
hm_corr = pd.Series([0.9, 0.6],
index=['All data', 'GROUP2'])
hh_corr = pd.Series([0.81, 0.64],
index=['All data', 'GROUP1'])
df_dis_corr = Analyzer.compute_disattenuated_correlations(hm_corr,
hh_corr)
assert_equal(len(df_dis_corr), 3)
assert_array_equal(df_dis_corr['corr_disattenuated'], [1.0, np.nan, np.nan])
def test_compute_disattenuated_correlations_negative_human(self):
hm_corr = pd.Series([0.9, 0.8],
index=['All data', 'GROUP1'])
hh_corr = pd.Series([-0.03, 0.64],
index=['All data', 'GROUP1'])
df_dis_corr = Analyzer.compute_disattenuated_correlations(hm_corr,
hh_corr)
assert_equal(len(df_dis_corr), 2)
assert_array_equal(df_dis_corr['corr_disattenuated'], [np.nan, 1.0])
def randomu(seed, di=None, binomial=None, double=False, gamma=False,
normal=False, poisson=False):
"""
Replicates the randomu function avaiable within IDL
(Interactive Data Language, EXELISvis).
Returns an array of uniformly distributed random numbers of the
specified dimensions.
The randomu function returns one or more pseudo-random numbers
with one or more of the following distributions:
Uniform (default)
Gaussian
binomial
gamma
poisson
:param seed:
If seed is not of type mtrand.RandomState, then a new state is
initialised. Othersise seed will be used to generate the random
values.
:param di:
A list specifying the dimensions of the resulting array. If di
is a scalar then randomu returns a scalar.
Dimensions are D1, D2, D3...D8 (x,y,z,lambda...).
The list will be inverted to suit Python's inverted dimensions
i.e. (D3,D2,D1).
:param binomial:
Set this keyword to a list of length 2, [n,p], to generate
random deviates from a binomial distribution. If an event
occurs with probablility p, with n trials, then the number of
times it occurs has a binomial distribution.
:param double:
If set to True, then randomu will return a double precision
random numbers.
:param gamma:
Set this keyword to an integer order i > 0 to generate random
deviates from a gamm distribution.
:param Long:
If set to True, then randomu will return integer uniform
random deviates in the range [0...2^31-1], using the Mersenne
Twister algorithm. All other keywords will be ignored.
:param normal:
If set to True, then random deviates will be generated from a
normal distribution.
:param poisson:
Set this keyword to the mean number of events occurring during
a unit of time. The poisson keword returns a random deviate
drawn from a poisson distribution with that mean.
:param ULong:
If set to True, then randomu will return unsigned integer
uniform deviates in the range [0..2^32-1], using the Mersenne
Twister algorithm. All other keywords will be ignored.
:return:
A NumPy array of uniformly distributed random numbers of the
specified dimensions.
Example:
>>> seed = None
>>> x, sd = randomu(seed, [10,10])
>>> x, sd = randomu(seed, [100,100], binomial=[10,0.5])
>>> x, sd = randomu(seed, [100,100], gamma=2)
>>> # 200x by 100y array of normally distributed values
>>> x, sd = randomu(seed, [200,100], normal=True)
>>> # 1000 deviates from a poisson distribution with a mean of 1.5
>>> x, sd = randomu(seed, [1000], poisson=1.5)
>>> # Return a scalar from a uniform distribution
>>> x, sd = randomu(seed)
:author:
Josh Sixsmith, [email protected], [email protected]
:copyright:
Copyright (c) 2014, Josh Sixsmith
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
"""
# Initialise the data type
if double:
dtype = 'float64'
else:
dtype = 'float32'
# Check the seed
# http://stackoverflow.com/questions/5836335/consistenly-create-same-random-numpy-array
if type(seed) != mtrand.RandomState:
seed = RandomState()
if di is not None:
if type(di) is not list:
raise TypeError("Dimensions must be a list or None.")
if len(di) > 8:
raise ValueError("Error. More than 8 dimensions specified.")
# Invert the dimensions list
dims = di[::-1]
else:
dims = 1
# Python has issues with overflow:
# OverflowError: Python int too large to convert to C long
# Occurs with Long and ULong
#if Long:
# res = seed.random_integers(0, 2**31-1, dims)
# if di is None:
# res = res[0]
# return res, seed
#if ULong:
# res = seed.random_integers(0, 2**32-1, dims)
# if di is None:
# res = res[0]
# return res, seed
# Check for other keywords
distributions = 0
kwds = [binomial, gamma, normal, poisson]
for kwd in kwds:
if kwd:
distributions += 1
if distributions > 1:
print("Conflicting keywords.")
return
if binomial:
if len(binomial) != 2:
msg = "Error. binomial must contain [n,p] trials & probability."
raise ValueError(msg)
n = binomial[0]
p = binomial[1]
res = seed.binomial(n, p, dims)
elif gamma:
res = seed.gamma(gamma, size=dims)
elif normal:
res = seed.normal(0, 1, dims)
elif poisson:
res = seed.poisson(poisson, dims)
else:
res = seed.uniform(size=dims)
res = res.astype(dtype)
if di is None:
res = res[0]
return res, seed
mu = self.get_mu(self.observed[i], w) mus = np.hstack((mus, mu)) mus = mus.reshape((self.n,2)) sig = np.dot(self.W.transpose(), self.W) sig = sig/self.sigx sig = np.linalg.inv(sig) return mus, sig if __name__ == "__main__": fa = FA(10) w = RS.normal(0,1, (3, 2)) mus, sig = fa.MLE_EP() #print fa.W #plotter.plot_approx_posterior(sig, mus, 0) #print "Truth: ", fa.W #print "" #print "init: ", w #fa.marginal_likelihood(w) #print "" #print "init: ", fa.W #print fa.W #fa.marginal_likelihood(fa.W) #fa.marginal_likelihood(w)
class Generator():
seed = None
random = None
def __init__(self, seed=1):
super(Generator, self).__init__()
self.random = RandomState(seed)
self.seed = seed
def reseed(self):
self.random = RandomState(self.seed)
def randSyllable(self):
c1_dice = ( self.random.random_sample() < 0.91 ) #Chance that a regular consonant will start the syllable
s1_dice = ( self.random.random_sample() < 0.05 ) #Chance that a special conjunction consonant is used
v1_dice = ( self.random.random_sample() < 0.85 ) #Chance that a regular vowel will be used
c2_add_dice = ( self.random.random_sample() < 0.28 ) #Chance that it has an ending consonant
c2_dice = ( self.random.random_sample() < 0.91 ) #Chance that a regular consonant will end the syllable
s2_dice = ( self.random.random_sample() < 0.03 ) #Chance that the ending has an addon consonant
c1 = self.random.choice(REGULAR_CONSONANTS) if c1_dice else self.random.choice(COMPOSITE_CONSONANTS)
s1 = self.random.choice(SPECIAL_CONSONANTS) if s1_dice else ''
v1 = self.random.choice(REGULAR_VOWELS) if v1_dice else self.random.choice(COMPOSITE_VOWELS)
c2 = ( self.random.choice(REGULAR_CONSONANTS) if c2_dice else self.random.choice(ENDING_CONSONANTS) ) if c2_add_dice else ''
s2 = self.random.choice(ADDON_ENDING_CONSONANTS) if s2_dice else ''
syllable = c1+s1+v1+c2+s2
# print(syllable)
return syllable
def randWord(self, s=2):
""" s = number of syllables in int """
word = ''
for syllable in range(0, s):
word += self.randSyllable()
return word
def randSentence(self, meter=[2, 2, 1, 2, 3, 2, 1, 2, 2]):
sentence = []
for syllable in meter:
sentence.append(self.randWord(syllable))
return ' '.join(sentence)
def randParagraph(self):
paragraph = []
rand_wordcount = [ self.random.randint(3, 6) for i in range(0, self.random.randint( 4, 5 )) ]
for words in rand_wordcount:
rand_meter = [ self.random.randint(1, 4) for i in range(0, words) ]
sentence = self.randSentence(rand_meter)
paragraph.append(sentence)
return '. '.join(paragraph)
def randDictionary(self, word_list=['apple', 'banana', 'cake', 'dog', 'elephant', 'fruit', 'guava', 'human', 'island', 'joke', 'king', 'love', 'mother', 'nature', 'ocean', 'pie', 'queen', 'random', 'start', 'tree', 'up', 'vine', 'wisdom', 'yellow', 'zoo' ]):
rand_dict_e2r = { word: self.randWord() for word in word_list }
rand_dict_r2e = { v: k for k, v in rand_dict_e2r.items() }
ordered_e2r = OrderedDict()
print("English to Random Language")
for key in sorted(rand_dict_e2r.keys()):
print(key+ ' : '+rand_dict_e2r[key])
ordered_e2r[key] = rand_dict_e2r[key]
ordered_r2e = OrderedDict()
print("\n\nRandom Language to English")
for key in sorted(rand_dict_r2e.keys()):
print(key+ ' : '+rand_dict_r2e[key])
ordered_r2e[key] = rand_dict_r2e[key]
return ( ordered_e2r, ordered_r2e )
def convertWord(self, word):
word = word.lower()
saved_state = self.random.get_state()
# Word mapping method : md5
# To make it more natural, this mapping should be updated
# to reflect natural language patterns
md5 = hashlib.md5(bytes(word, encoding='utf-8'))
wordseed = ( self.seed + int.from_bytes(md5.digest(), 'little') ) % (2**31)
# print(wordseed)
self.random.seed( wordseed )
randword = self.randWord( math.ceil( abs( self.random.normal(2, 1) ) ) )
self.random.set_state(saved_state)
return randword
def convertSentence(self, sentence):
words = sentence.split()
converted = [self.convertWord(word) for word in words]
return ' '.join(converted)
