def test_RNG_getter(self):
# basically the same as the _init test, just performed another way
# set seed to ensure known sequence
np.random.seed(100)
# initialize empty list for distributions
valid = list()
invalid = list()
# The commented tests evaluate the additional functionality in my Distribution
# class not required by the assignment.
valid.append(Distribution('normal(100, 20)'))
valid.append(Distribution('poisson(5)'))
valid.append(Distribution('triangular(10, 20, 40)'))
valid.append(Distribution('uniform(10,20)'))
# valid.append(Distribution('lambda: np.random.normal(100,20)'))
# valid.append(Distribution('lambda: 1'))
# valid.append(Distribution(lambda: np.random.normal(100, 20)))
# valid.append(Distribution(foo1))
invalid.append(Distribution('nrml(100,20)'))
# invalid.append(Distribution('lamda: np.random.normal(100,20'))
# invalid.append(Distribution(foo2))
for i in range(len(valid)):
with self.subTest(i=i):
self.assertFalse(valid[i].RNG is None)
for i in range(len(invalid)):
with self.subTest(i=i):
self.assertTrue(invalid[i].RNG is None)
def test_init(self):
# check a valid SourcePopulation instance
self.assertTrue(isinstance(self.sp, SourcePopulation))
self.assertTrue(isinstance(self.sp, SimulationStage))
self.assertTrue(isinstance(self.sp._destination, dict))
self.assertFalse(self.sp._arrivalTimeDistribution is None)
self.assertFalse(self.sp._assignDestination is None)
# now try where the arrivalTimeDistribution is invalid
dist = Distribution('nrml(100, 20)')
sp = SourcePopulation("Source1", dist, Assigner().assignInSequence)
self.assertTrue(sp._arrivalTimeDistribution is None)
self.assertFalse(sp._assignDestination is None)
# now try where the assignDestination function is invalid
dist = Distribution('normal(100, 20)')
# invalid assignDestination function, no arguments
sp = SourcePopulation("Source1", dist, lambda: 5)
self.assertFalse(sp._arrivalTimeDistribution is None)
self.assertTrue(sp._assignDestination is None)
# invalid assignDestination function, too many arguments
sp = SourcePopulation("Source1", dist, lambda x, y: 5)
self.assertFalse(sp._arrivalTimeDistribution is None)
self.assertTrue(sp._assignDestination is None)
# invalid assignDestination function, not callable
sp = SourcePopulation("Source1", dist, 5)
self.assertFalse(sp._arrivalTimeDistribution is None)
self.assertTrue(sp._assignDestination is None)
def test_isValid(self):
# set seed to ensure known sequence
np.random.seed(100)
# initialize empty list for distributions
valid = list()
invalid = list()
# The commented tests evaluate additional functionality in my Distribution
# class that is not required for the assignment.
valid.append(Distribution('normal(100, 20)'))
valid.append(Distribution('poisson(5)'))
valid.append(Distribution('triangular(10, 20, 40)'))
valid.append(Distribution('uniform(10,20)'))
# valid.append(Distribution('lambda: np.random.normal(100,20)'))
# valid.append(Distribution('lambda: 1'))
# valid.append(Distribution(lambda: np.random.normal(100, 20)))
# valid.append(Distribution(foo1))
invalid.append(Distribution('nrml(100,20)'))
# invalid.append(Distribution('lamda: np.random.normal(100,20'))
# invalid.append(Distribution(foo2))
for i in range(len(valid)):
with self.subTest(i=i):
self.assertTrue(valid[i].isValid())
for i in range(len(invalid)):
with self.subTest(i=i):
self.assertFalse(invalid[i].isValid())
def test_isValid(self):
# check SourcePopulation instance, invalid because it has no destinations
self.assertFalse(self.sp.isValid())
# now force it to be valid - make sure it has a destination
dest = CustomerDestination('test_dest')
self.sp._destination[dest.id] = dest
self.assertTrue(self.sp.isValid())
# now try where the arrivalTimeDistribution is invalid
dist = Distribution('nrml(100, 20)')
sp = SourcePopulation("Source1", dist, Assigner().assignInSequence)
sp._destination[dest.id] = dest
self.assertFalse(sp.isValid())
# now try where the assignDestination function is invalid
dist = Distribution('normal(100, 20)')
# invalid assignDestination function, no arguments
sp = SourcePopulation("Source1", dist, lambda: 5)
sp._destination[dest.id] = dest
self.assertFalse(sp.isValid())
# invalid assignDestination function, too many arguments
sp = SourcePopulation("Source1", dist, lambda x, y: 5)
sp._destination[dest.id] = dest
self.assertFalse(sp.isValid())
# invalid assignDestination function, not callable
sp = SourcePopulation("Source1", dist, 5)
sp._destination[dest.id] = dest
self.assertFalse(sp.isValid())
def setUp(self) -> None:
np.random.seed(100)
# first setup a queue
self.testq = SimQueue('Q1', Assigner().assignInSequence)
# then setup servers
self.dist = {}
self.dist['dt'] = Distribution("triangular(14400, 14400, 18000)")
self.dist['oos'] = Distribution("triangular(300, 600, 1200)")
self.dist['st'] = Distribution("exponential(1/300)")
# uncomment to test validity of server construction
# for k, v in self.dist.items():
# with self.subTest(dist=k):
# self.assertTrue(v.isValid())
self.dist['invalid'] = Customer('teddy', 0)
self.servers = [
Server(f'Server{i}', 100 * i, self.dist['dt'], self.dist['oos'],
self.dist['st']) for i in range(1, 4)
]
self.dest = [
SimQueue(f'Queue{i}',
Assigner().assignInSequence) for i in range(1, 4)
]
self.dest.append(SystemExit('Exit1'))
self.cust = [Customer(f'Cust{i}', i * 100) for i in range(1, 11)]
def __init__(self, s, m, h):
#init simulations
self.mainArrDist = Distribution(stats.expon(scale=1/m))
self.sideArrDist = Distribution(stats.expon(scale=1/s))
self.s = s
self.m = m
self.h = h
def setup_Figure2(self):
np.random.seed(self.seed)
assigner = Assigner()
dist = dict()
dist['ar'] = Distribution("exponential(180)")
dist['dt'] = Distribution("triangular(14400, 14400, 18000)")
dist['oos'] = Distribution("triangular(300, 600, 1200)")
dist['st'] = Distribution("exponential(144)")
# define 2 valid system exits
for i in range(2):
self._stages[f'SE{i}'] = SystemExit(f'SE{i}')
# define one valid source populations
self._stages['SP-PRE'] = SourcePopulation('SP-PRE', dist['ar'],
assigner.assignToShortest)
# define the other valid source populations
self._stages['SP-REG'] = SourcePopulation('SP-REG', dist['ar'],
assigner.assignToShortest)
# define a valid one server per one queue for SP-PRE
for i in range(3):
self._stages[f'Q{i}'] = SimQueue(f'Q{i}',
assigner.assignInSequence)
self._stages[f'Q{i}'].addCustomerDestination(self._stages['SE0'])
self._stages[f'Q{i}'].assignServer = assigner.assignByAvailableTime
server = Server(f'Server{i}', 0, dist['dt'], dist['oos'],
dist['st'])
self._stages[f'Q{i}'].addServer(server)
self._stages['SP-PRE'].addCustomerDestination(
self._stages[f'Q{i}'])
# define a valid one server per one queue for SP-REG
for i in range(3, 7):
self._stages[f'Q{i}'] = SimQueue(f'Q{i}',
assigner.assignInSequence)
self._stages[f'Q{i}'].addCustomerDestination(self._stages['SE1'])
self._stages[f'Q{i}'].assignServer = assigner.assignByAvailableTime
server = Server(f'Server{i}', 0, dist['dt'], dist['oos'],
dist['st'])
self._stages[f'Q{i}'].addServer(server)
self._stages['SP-REG'].addCustomerDestination(
self._stages[f'Q{i}'])
def perform_eval(eid, data):
global word_classifiers
global relation_word_classifiers
global results_outfile
target_dist = Distribution(data['objects'])
landmark_dist = Distribution(data['objects'])
target = data['target']
increment_data = []
relation = None
relation_is_negated = False
inc = 1
prev_rank = len(data['objects'])
for w,tags in [(w['word'],w['tags']) for w in data['speech']]:
utt = {}
word = None
c_rank = None
relation_dist = None
prepare_word(utt, w, tags)
objects = data['objects']
if 't' in utt:
word = utt['t'][0]
target_dist.update(logreg.classify(word, word_classifiers, objects))
if 'l' in utt:
word = utt['l'][0]
landmark_dist.update(logreg.classify(word, word_classifiers, objects))
if 'r' in utt:
word = utt['r'][0]
if relation is not None: relation += '_' + word
else: relation = word
if 'r-' in utt:
word = utt['r-'][0]
if relation is not None: relation += '_' + word
else: relation = word
relation_is_negated = True
if relation is not None: # indent this with above for loop to make it incremental
tdist = target_dist.copy()
ldist = landmark_dist.copy()
relation_dist = apply_relation(tdist, ldist, relation, relation_is_negated, objects)
if relation_dist is not None:
return relation_dist.rank(target)
else:
target_dist.normalise()
return target_dist.rank(target)
def setup_posterior_and_pf(self):
# Sample the posterior
post_samples, post_pf_samples = self.generate_posterior_samples()
# Create a posterior distribution
self.p_post = Distribution(samples=post_samples,
rv_name=self.p_prior.rv_name,
rv_transform=self.p_prior.rv_transform,
label='Updated',
kde=False)
# Create the posterior push-forward distribution
self.p_post_pf = Distribution(samples=post_pf_samples,
rv_name=self.p_obs.rv_name,
rv_transform=self.p_obs.rv_transform,
label='PF Updated')
def __init__(self, p, network):
self.p = p
self.network = network
self.network_dicts = nx.convert.to_dict_of_dicts(
self.network) #convert to dictionaryform
self.N = len(set(self.network_dicts.keys()))
self.distr = Distribution(stats.bernoulli(self.p))
print("transmission-probability: {}, populationsize: {}".format(
self.p, self.N))
def setUp(self):
dist = Distribution('triangular(10, 20, 40)')
# SourcePopulation generates the first arrival time on construction
# so we have to set the random number before creating the source population
np.random.seed(100)
self.sp = SourcePopulation("Source1", dist,
Assigner().assignInSequence)
def setUp(self) -> None:
self.dist = {}
self.dist['dt'] = Distribution("triangular(14400, 14400, 18000)")
self.dist['oos'] = Distribution("triangular(300, 600, 1200)")
self.dist['st'] = Distribution("exponential(1/300)")
# uncomment to test validity of server construction
# for k, v in self.dist.items():
# with self.subTest(dist=k):
# self.assertTrue(v.isValid())
self.dist['invalid'] = Customer('teddy', 0)
self.server = Server('S1', 100,
self.dist['dt'],
self.dist['oos'],
self.dist['st']
)
def setUp(self) -> None:
self.gen_setup = False
self.sim = Simulation(100)
rstate = np.random.get_state()
self.assigner = Assigner()
self.dist = {}
self.dist['ar'] = Distribution("exponential(180)")
self.dist['dt'] = Distribution("triangular(14400, 14400, 18000)")
self.dist['oos'] = Distribution("triangular(300, 600, 1200)")
# 144 second service time corresponds to 25 service completions per hour
self.dist['st'] = Distribution("exponential(144)")
np.random.set_state(rstate)
self.stages = {}
# define 2 valid system exits
for i in range(2):
self.stages[f'SE{i}'] = SystemExit(f'SE{i}')
# define 2 valid source populations - destinations not yet assigned
for i in range(2):
# 180 second average inter-arrival time corresponds to 20 arrivals per hour
self.stages[f'SP{i}'] = SourcePopulation(
f'SP{i}', self.dist['ar'], self.assigner.assignToShortest)
self.stages[f'SP{i}'].addCustomerDestination(self.stages[f'SE{i}'])
# print(f"SP{i} arrival: {self.stages[f'SP{i}'].getNextEventTime()}")
rstate = np.random.get_state()
# define 4 valid queues (alternating system exits)
for i in range(5):
tqueue = SimQueue(f'Q{i}', self.assigner.assignInSequence)
self.stages[f'Q{i}'] = tqueue
server = self.server = Server(f'Server{i}', 0, self.dist['dt'],
self.dist['oos'], self.dist['st'])
tqueue.addServer(server)
tqueue.addCustomerDestination(self.stages[f'SE{i % 2}'])
tqueue.assignServer = self.assigner.assignByAvailableTime
np.random.set_state(rstate)
def test_init(self):
# set seed to ensure known sequence
np.random.seed(100)
# initialize empty list for distributions
valid = list()
invalid = list()
# test construction.
# I made my Distribution class more flexible than the assignment requires.
# This provides additional flexibility on how I can create distributions.
# The commented tests evaluate the additional functionality in my Distribution
# class.
valid.append(Distribution('normal(100, 20)'))
valid.append(Distribution('poisson(5)'))
valid.append(Distribution('triangular(10, 20, 40)'))
valid.append(Distribution('uniform(10,20)'))
# valid.append(Distribution('lambda: np.random.normal(100,20)'))
# valid.append(Distribution('lambda: 1'))
# valid.append(Distribution(lambda: np.random.normal(100, 20)))
# valid.append(Distribution(foo1))
# I also wrote my Distribution class to cleanly handle erroneous
# distribution specifications and produce an "invalid" Distribution
# instance rather than crashing with an exception. However, I did
# not require this level of advanced functionality in your class.
# The commented tests below relate to testing this additional functionality.
invalid.append(Distribution('nrml(100,20)'))
# invalid.append(Distribution('lamda: np.random.normal(100,20'))
# invalid.append(Distribution(foo2))
# test construction of VALID Distributions
for i in range(len(valid)):
with self.subTest(i=i):
self.assertFalse(valid[i]._RNG is None)
self.assertTrue(isinstance(valid[i].__repr__(), str))
self.assertTrue(isinstance(valid[i].__str__(), str))
# test construction of INVALID Distributions
for i in range(len(invalid)):
with self.subTest(i=i):
self.assertTrue(invalid[i]._RNG is None)
async def load(cls, descriptor, content):
descriptor.icon = content[0][0]
descriptor.datea = content[0][1]
for i in range(1,len(content)):
distributionid = content[i][0].split(" ")
if len(distributionid) > 1:
distribution = Distribution(distributionid[1])
descriptor.distributions[content[i][0][0]] = distribution
await Distribution.load(distribution, content[i][1:])
def dataset(self):
dl = Distribution([1, 0], [
self.probiablity,
])
v = dl.generator(len(self.dset))
m = []
for i in range(len(self.dset)):
if v[i] == 1:
m.append(self.dset)
return m
def set_mortality(self, data):
print("Fitting mortality distribution")
mortality_data = list(data.values())
r = []
for i in range(len(mortality_data)):
deaths = mortality_data[i]
for _ in range(deaths):
r.append(i)
dist = Distribution()
dist.Fit(r)
self.mortality_distribution = dist
def create_from_bucket(col_name, buckets):
b = {}
for val in buckets:
if 'grades' not in buckets[val]:
b[val] = buckets[val]
continue
grades = []
for g in buckets[val]['grades']:
a = np.array([])
for split in g['split_count']:
a = np.append(a, split)
grades.append(Distribution(a))
salaries = []
for s in buckets[val]['salaries']:
a = np.array([])
for split in s['split_count']:
a = np.append(a, split)
salaries.append(Distribution(a))
b[val] = Bucket(col_name, val, grades, salaries)
return b
def set_migrations(self, data):
print("Fitting migration distribution")
r = []
for i in range(len(data)):
num = data[i]
for _ in range(num):
r.append(i)
dist = Distribution()
dist.min_val = 0
dist.max_val = len(data) - 1
dist.Fit(r)
self.migrations_distribution = dist
def set_natality(self, data):
print("Fitting natality distribution")
data.pop('total_births', None)
r = []
for i in range(len(data)):
key = list(data.keys())[i]
num = int(data[key])
for _ in range(num):
r.append(i)
dist = Distribution()
dist.Fit(r)
self.natality_distribution = dist
def test_oosDistribution(self):
np.random.seed(100)
expected = self.dist['oos'].getEvent()
np.random.seed(100)
actual = self.server._oosDistribution.getEvent()
self.assertAlmostEqual(expected, actual)
# replace the downtime distribution and check
np.random.seed(200)
expected = np.random.normal(100, 30)
np.random.seed(200)
self.server.oosDistribution = Distribution("normal(100,30)")
actual = self.server._oosDistribution.getEvent()
self.assertAlmostEqual(expected, actual)
def readDistributions(iFilename):
"""Read JSON file *iFileName* and return its list of distributions."""
try:
file = open(iFilename)
except IOError:
print('Cannot open file : ', iFilename)
exit()
n = 1
lDistList = []
for lDist in json.load(file):
lDistList.append(Distribution(lDist, n))
n += 1
if gAbort: exit()
return lDistList
async def appendfrom(self, content, i):
distribution = None
while i < len(content):
if await is_emoji(content[i][0]):
if distribution:
await Distribution.load(distribution, content[start:i])
if content[i][0] in self.distributions:
distribution = self.distributions[content[i][0]]
else:
distributionid = content[i].split(" ")
if len(distributionid) > 1:
distribution = Distribution(distributionid[1])
self.distributions[content[i][0]] = distribution
start = i+1
i += 1
if distribution:
await Distribution.load(distribution, content[start:i])
def init(self):
self.cfg = RebuilddConfig()
# Init log system
RebuilddLog()
self._sqlconnection = sqlobject.connectionForURI(
self.cfg.get('build', 'database_uri'))
sqlobject.sqlhub.processConnection = self._sqlconnection
# Create distributions
for dist in self.cfg.get('build', 'dists').split(' '):
for arch in self.cfg.arch:
Dists().add_dist(Distribution(dist, arch))
self.do_quit = threading.Event()
self.jobs_locker = threading.Lock()
self.job_finished = threading.Event()
def test_setArrivalTimeDistribution(self):
# save the state, Distribution will have generated it's first RV
rstate = np.random.get_state()
# add a valid destination to the SourcePopulation
dest = SimQueue('test_dest', Assigner().assignInSequence)
self.sp.addCustomerDestination(dest)
# set seed and generate expected results
np.random.seed(100)
expected = list(np.cumsum(np.random.triangular(10, 20, 40, 10)))
print(f'expected near line {sys._getframe().f_lineno}: {expected}')
# reset state and generate test values
np.random.set_state(rstate)
actual = list()
for i in range(10):
with self.subTest(i=i):
actual.append(self.sp.getNextEventTime())
self.sp.processEvent(self.sp.getNextEventTime())
self.assertAlmostEqual(expected[i], actual[i])
# capture seed state
rstate = np.random.get_state()
temp = np.zeros(10)
temp[1:10] = np.random.uniform(10, 20, 9)
expected = self.sp.getNextEventTime() + np.cumsum(temp)
print(f'expected near line {sys._getframe().f_lineno}: {expected}')
# restore the random state
np.random.set_state(rstate)
self.sp.setArrivalTimeDistribution(Distribution("uniform(10, 20)"))
# reset state and generate test values
np.random.set_state(rstate)
actual = list()
for i in range(10):
with self.subTest(i=i):
actual.append(self.sp.getNextEventTime())
self.sp.processEvent(self.sp.getNextEventTime())
self.assertAlmostEqual(expected[i], actual[i])
def test_getEvent(self):
# create distribution instance, normal distribution with mean 100, std 20
dist1 = Distribution('normal(100, 20, 1)')
# the seed must be set AFTER creating the Distribution instances, because
# the constructor invokes the RNG function one time to validate that it
# can be called.
np.random.seed(100)
expected = [
65.00469054, 106.85360807, 123.06071605, 94.95127927, 119.62641574,
110.28437683, 104.42359338, 78.59913339, 96.21008338, 105.10002889
]
for i in range(0, 10):
with self.subTest(i=i):
actual = dist1.getEvent()
self.assertAlmostEqual(expected[i], actual)
def apply_relation(target_dist, landmark_dist, relation, negated, objects):
global relation_word_classifiers
if relation not in relation_word_classifiers:
relation = "UNK_REL"
negated = False
combined = Distribution()
for t in objects:
for l in objects:
if t == l: continue
if negated:
features = get_relational_features(objects[l], objects[t])
else:
features = get_relational_features(objects[t], objects[l])
p = logreg.classify_obj(relation, relation_word_classifiers, features.values())
combined.add(make_id(t,l), target_dist.get(t) * landmark_dist.get(l) * p)
combined.marginalise()
return combined
def __init__(self, samples_x_y: SamplesXY,
shared_combined_sample: CombinedSample):
self.shared_combined_sample = shared_combined_sample
self.shared_combined_sample_size = self.shared_combined_sample.combined_sample_size
self.sample_size_y = samples_x_y.sample_size_y
self.sample_size_x = self.shared_combined_sample_size - self.sample_size_y
self.sample_size_x_y_gcd = gcd(self.sample_size_x, self.sample_size_y)
self.test_statistic_factor = self.sample_size_x * self.sample_size_y / self.sample_size_x_y_gcd
self.test_statistic_factor_approximate = self.sample_size_x_y_gcd / \
sqrt(self.sample_size_x * self.sample_size_y * self.shared_combined_sample_size)
self.algorithm = CountAlgorithm()
self.combined_sample_counts = []
self.x_meshing_cdf = []
self.y_meshing_cdf = []
self.max_cumulative_difference = 0
self.meshing_test_statistic = 0
self.y_item_positions = []
self.number_of_y_item_positions = 0
self.combined_sample_attributions_cache = []
self.distribution = Distribution()
def __getdistributions(self):
distributions = self.__doc.getElementsByTagName("distributions")
distribution = distributions[0].getElementsByTagName("distribution")
output = []
retester = re.compile('\(([^)]+)\)')
for x in distribution:
completestring = x.getAttribute("type")
auxiliarstring = retester.search(completestring)
params = None
if (auxiliarstring != None):
params = auxiliarstring.group(0)[1:-1]
firstbrack = auxiliarstring.regs[0][0]
name = completestring[0:firstbrack]
else:
name = completestring
classesids = []
for classaux in x.getElementsByTagName("class"):
classesids.append(int(classaux.getAttribute("id"), 10))
reqpen = x.getAttribute("required")
if (reqpen == ''):
reqpen = int(x.getAttribute("penalty"), 10)
output.append(Distribution(name, params, classesids, reqpen))
return output
def set_simulation_distributions(self):
"""
Método de clase
Se inicializan cada una de las simulaciones y sus respectivos parámetros
"""
# Se crea un diccionario para manejar los identificadores de cada distribución
distribution_dictionary = {
1: "Direct",
2: "TLC",
3: "Uniform",
4: "Exponential",
5: "Density"
}
# Se realiza la solicitud de los datos de cada una de las 6 distribuciones
for i in range(6):
dist = Distribution()
# Se pregunta cual distribución desa asignar a la distribución de la simulación: D_i
option = self.interface.ask_distribution("D" + str(i + 1))
# Según la distribución señalada entonces se asígna el identificador
dist.id = distribution_dictionary[option]
# Se piden los parámetros que necesita la distribución elegida
self.set_dist_parameters(dist)
# Agrega la distribución al diccionario de distribuciones en su ubicación asociada
self.distribution_list["D" + str(i + 1)] = dist
