def getAction(self, signal):
#using signal[-1] covers the len1/2 case uniformly
theAct = util.weighted_choice(zip(self.actions, self.strategy[signal[-1]]))
#theAct = np.random.choice(self.actions, p=util.normalize(self.strategy[signal[-1]]))
if len(signal) == 1:
self._choiceHistory.append((signal, theAct))
return theAct
else:
theFunc = util.weighted_choice(zip(range(self._numFuncs), self._funcWeights))
finalAct = self._funcs[theFunc][theAct]
self._choiceHistory.append((signal, (theFunc, finalAct)))
return finalAct
def action_given_state(self, state):
if type(state) == list:
state = tuple(state)
normed = self.q_values_normalised_for_pick(state)
action = u.weighted_choice(normed)
print "CHOOSE\t based on state", state, "q_values", self.q_table[state], "(normed to", normed, ") => action", action
return action
def breed_pop(self):
"""Breed the current population, a better score rank means probably more children."""
pop_size = len(self.goombas)
num_clones = ceil(pop_size * World.CLONE_BEST_FRACTION)
num_bred = ceil(pop_size * World.BREED_FRACTION)
num_rand = ceil(pop_size * World.NEW_RANDOM_FRACTION)
# Order the population by final score
ordered_pop = sorted([gmba for gmba in self.goombas], key=lambda g: g.score(), reverse=True)
# The top few will be cloned into the next generation unchanged
top_dogs = ordered_pop[:num_clones]
new_goombas = [Goomba.from_sequences(dog.genome.sequences()) for dog in top_dogs]
# The bottom fraction is thrown out entirely
breeders = ordered_pop[:num_bred]
# The remaining goombas breed, with a higher likelihood as they rank higher
breed_weighted = dict(zip(breeders, linspace(World.REPRO_SUCCESS_RAMP, 1, len(breeders))))
breeding_pairs = weighted_choice(breed_weighted, 2 * (pop_size - (num_clones + num_rand)))
for i in range(0, len(breeding_pairs), 2):
new_goombas.append(breed(breeding_pairs[i], breeding_pairs[i + 1]))
for i in range(num_rand):
new_goombas.append(Goomba(Genome.random_coding(self.seed_meta, randrange(*self.gen_len_range))))
starts = self.start_locations(len(new_goombas))
for gmba, pos in zip(new_goombas, starts):
gmba.pos = pos
self.goombas = new_goombas
def getAction(self, signal):
theAct = util.weighted_choice(zip(self.actions, self.strategy[sum(signal)]))
#np.random.choice requires the weights to be probabilities; is normalizing then using this slower than weighted_choice?
#theAct = np.random.choice(self.actions, p=util.normalize(self.strategy[sum(signal)]))
if self._recordChoices:
self._choiceHistory.append((signal, theAct))
return theAct
def action_given_state(self, state):
state = flatten(state)
q_values = self.sess.run(self.core_q_values, feed_dict={self.core_state: state})
normed = u.normalised(u.raised(q_values[0], self.state_normalisation_squash))
action = u.weighted_choice(normed)
print "CHOOSE\t based on state", state, "q_values", q_values, "(normed to", normed, ") => action", action
return action
def action_given_state(self, state):
state = flatten(state)
q_values = self.sess.run(self.core_q_values, feed_dict={self.core_state: state})
normed = u.normalised(u.raised(q_values[0], self.state_normalisation_squash))
action = u.weighted_choice(normed)
if random.random() < 0.1:
print ">action_given_state state %s q_values %s normed %s action %s" % (state, q_values, normed, action)
return action
def generate_age(classification):
# age distribution at last tab "17.Population by Age-Group"
# http://rural.nic.in/sites/downloads/IRDR/1.%20Demographic%20Profile.xls
# does this need to go to database? or shall we use the average
# but this needs to have the total number: pop ***!!!
# my current idea idea is to simulate age dist and bootstrap
age_range = util.weighted_choice(age_ranges, age_weights[classification])
return random.randint(age_range[0], age_range[1])
def action_given_state(self, state):
state = flatten(state)
q_values = self.sess.run(self.core_q_values, feed_dict={self.core_state: state})
normed = u.normalised(u.raised(q_values[0], self.state_normalisation_squash))
action = u.weighted_choice(normed)
if random.random() <= 0.05:
q_values_str = " ".join(map(str, ["%0.2f" % v for v in q_values[0]]))
normed_str = " ".join(map(str, ["%0.2f" % v for v in normed]))
print ">action_given_state state %s q_values %s normed %s action %s" % (state, q_values_str, normed_str, action)
return action
def getAction(self, signal):
#using signal[-1] covers the len1/2 case uniformly
theAct = util.weighted_choice(zip(self.actions, self.strategy[signal[-1]]))
#theAct = np.random.choice(self.actions, p=util.normalize(self.strategy[signal[-1]]))
if len(signal) == 1:
self._choiceHistory.append((signal, theAct))
return theAct
else:
self._choiceHistory.append((signal, self._func[theAct]))
return self._func[theAct]
def random(cls, gen_len, const_bounds, leaf_weights, parent=None):
ref_type = weighted_choice(leaf_weights)
if ref_type == RefType.Pure_Offset_Call or ref_type == RefType.Impure_Offset_Call:
val = random.randrange(gen_len) * random.choice([-1, 1])
elif ref_type == RefType.Poll_Sensor:
val = random.randrange(len(goomba.Sensor))
else:
val = (random.random() * (const_bounds[1]-const_bounds[0])) + const_bounds[0]
return cls(None, ref_type, val, parent)
def mutated_intenum(curr, enum_type, mute_prob, enum_rel):
if random.random() > mute_prob:
return curr
mute = weighted_choice(enum_rel)
if mute == EnumMutes.Increment:
return enum_type((curr + 1) % len(enum_type))
elif mute == EnumMutes.Decrement:
return enum_type((curr - 1) % len(enum_type))
else:
return random.choice(list(enum_type))
def mutated_int_in_range(val, mute_prob, rand_bounds, enum_rel):
if random.random() > mute_prob:
return val
mute = weighted_choice(enum_rel)
if mute == EnumMutes.Increment:
return val + 1
elif mute == EnumMutes.Decrement:
return val - 1
else:
return random.randint(*rand_bounds)
def charge_problem_fee(self, problem, person):
if problem.name == 'cataracts':
fee_options = [problem.cost_full, problem.cost_subsidized, 0]
fee = util.weighted_choice(fee_options,
Hospital.surgery_fee_proportions_by_state[self.state_name])
elif problem.name == 'glasses':
#FROM DATA
fee = 120
else:
print 'Warning: unrecognized problem', problem.name
person.money -= fee
def will_make_order(self, client, product, timestamp):
# type: (pd.Series, pd.Series, long) -> int
"""
Ritorna 1 se il cliente effettuarà un ordine del prodotto il giorno stabilito.
:param client: (np.Series) array che rappresenta un cliente
:param product: (np.Series) array che rappresenta un prodotto
:param timestamp: (long) timestamp del giorno dell'ordine
:return: (float) probabilità dell'ordine
"""
p = self.probability(client, product, timestamp)
choices = [(1, p), (0, 1 - p)]
return weighted_choice(choices)
def action_given_state(self, state):
state = flatten(state)
q_values = self.sess.run(self.core_q_values,
feed_dict={self.core_state: state})
normed = u.normalised(
u.raised(q_values[0], self.state_normalisation_squash))
action = u.weighted_choice(normed)
if random.random() <= 0.05:
q_values_str = " ".join(
map(str, ["%0.2f" % v for v in q_values[0]]))
normed_str = " ".join(map(str, ["%0.2f" % v for v in normed]))
print ">action_given_state state %s q_values %s normed %s action %s" % (
state, q_values_str, normed_str, action)
return action
def distance_strategy():
rects = []
for i in range(N_RECTS):
while True:
weights = [
sum(((x - e.cx) ** 2 + (y - e.cy) ** 2) ** .5 for e in rects) + 1
for x, y in grid
]
cx, cy = weighted_choice(grid, weights)
radius = random.randint(MIN_RECT_RADIUS, MAX_RECT_RADIUS)
rect = Rect(cx, cy, radius)
if any(rect.collides_with(e) for e in rects):
continue
rects.append(rect)
break
return rects
def mutated_num(num, mute_prob, genome, clamps):
if random.random() > mute_prob:
return num
mute = weighted_choice(genome.mute_rates["const_rel"])
if mute == ConstMutes.Increment:
num += random.random() * genome.incr_range
elif mute == ConstMutes.Decrement:
num -= random.random() * genome.incr_range
elif mute == ConstMutes.Incremult: # Assumes mult_range >= 1
num *= (random.random() * (genome.mult_range - 1)) + 1
elif mute == ConstMutes.Decremult:
num /= (random.random() * (genome.mult_range - 1)) + 1
if clamps[0] is not None:
num = max(clamps[0], num)
if clamps[1] is not None:
num = min(clamps[1], num)
return num
def mutated_num(num, mute_prob, genome, clamps):
if random.random() > mute_prob:
return num
mute = weighted_choice(genome.mute_rates["const_rel"])
if mute == ConstMutes.Increment:
num += random.random() * genome.incr_range
elif mute == ConstMutes.Decrement:
num -= random.random() * genome.incr_range
elif mute == ConstMutes.Incremult: # Assumes mult_range >= 1
num *= (random.random() * (genome.mult_range-1)) + 1
elif mute == ConstMutes.Decremult:
num /= (random.random() * (genome.mult_range-1)) + 1
if clamps[0] is not None:
num = max(clamps[0], num)
if clamps[1] is not None:
num = min(clamps[1], num)
return num
def mutate(self):
# 1. Iterate through genome, checking each item for mutation
i = 0
while i < len(self):
# 2. Check if the gene mutates.
rand = random.random()
mutation = None
if rand < self.mute_rates["genome"]:
mutation = weighted_choice(self.mute_rates["genome_rel"])
# 3. Apply appropriate mutations, if any.
if mutation is not None:
fuzz = -1
if mutation == GenomeMutes.Insert:
new_gene = Gene.random(round(self.fun_gen_depth),
len(self), self.const_bounds,
self.mute_rates["leaf_rel"])
self.genes.insert(i, new_gene)
fuzz = i
i += 1
elif mutation == GenomeMutes.Dupe:
self.genes.insert(i, self.genes[i].copy())
fuzz = i
i += 1
elif mutation == GenomeMutes.Delete:
del self.genes[i]
i -= 1
elif mutation == GenomeMutes.Invert:
swapindex = (i + 1) % len(self)
tmp = self.genes[i]
self.genes[i] = self.genes[swapindex]
self.genes[swapindex] = tmp
elif mutation == GenomeMutes.MuteGene:
self.genes[i].mutate(self)
fuzz = i
if fuzz != -1:
self.fuzzify(self.genes[fuzz].function)
# Mutate the colours when a functional mutation occurs, for a visual
# indication of genetic distance.
self.mutate_colors()
i += 1
# 4. Reset genome consistency
self.link()
# 5. Mutate the metagenome
# fuzz [0.0, inf)
self.fuzziness = mutated_num(self.fuzziness, self.mute_rates["genome"],
self, [0.001, None])
# const bounds (-inf, inf), but small smaller than large
self.const_bounds[0] = mutated_num(self.const_bounds[0],
self.mute_rates["genome"], self,
[None, None])
self.const_bounds[1] = mutated_num(self.const_bounds[1],
self.mute_rates["genome"], self,
[None, None])
if self.const_bounds[0] > self.const_bounds[1]:
self.const_bounds = self.const_bounds[::-1]
# fun gen depth [0.0, 5.0]
self.fun_gen_depth = mutated_by_factor(self.fun_gen_depth, 1.7,
self.mute_rates["genome"],
[0.001, 5.0])
# incr_range [0.0, inf)
self.incr_range = mutated_num(self.incr_range,
self.mute_rates["genome"], self,
[0.001, None])
# mult_range [1.0, inf)
self.mult_range = mutated_num(self.mult_range,
self.mute_rates["genome"], self,
[1.0, None])
# Colours used to be mutated here.
# mute_rates "mute", "genome" [0.0, 1.0]
self.mute_rates["mute"] = mutated_by_const(self.mute_rates["mute"],
0.04,
self.mute_rates["genome"],
[0.001, 1.0])
self.mute_rates["genome"] = mutated_by_const(self.mute_rates["genome"],
0.04,
self.mute_rates["mute"],
[0.001, 1.0])
# other mute_rates [0.0, inf)
rel_lists = [
self.mute_rates["genome_rel"], self.mute_rates["const_rel"],
self.mute_rates["leaf_rel"]
]
for rel_list in rel_lists:
for k in rel_list:
rel_list[k] = mutated_num(rel_list[k], self.mute_rates["mute"],
self, [0.001, None])
def mutate(self, genome):
if random.random() < genome.mute_rates["gene_action"]:
# Mutate this gene's action
self.action = mutated_intenum(self.action, goomba.Action, 1.0,
genome.mute_rates["enum_rel"])
elif random.random() < genome.mute_rates["struct_mod"]:
# Structure-modifying function mutations.
# Select a random node and mutation
node = random.choice(self.function.as_list())
mute = weighted_choice(genome.mute_rates["struct_rel"])
if mute == StructMutes.SubTree:
new_node = FTreeNode.random(round(genome.fun_gen_depth),
len(genome), genome.const_bounds,
genome.mute_rates["leaf_rel"],
node.parent)
if node.parent is None:
self.function = new_node
elif node.parent.left == node:
node.parent.left = new_node
else:
node.parent.right = new_node
elif mute == StructMutes.OpAbove:
new_node = FTreeNode(random.choice(list(Op)), None, None,
node.parent)
if node.parent is None:
self.function = new_node
elif node.parent.left == node:
node.parent.left = new_node
else:
node.parent.right = new_node
new_child = FTreeNode.random(round(genome.fun_gen_depth),
len(genome), genome.const_bounds,
genome.mute_rates["leaf_rel"],
new_node)
if random.random() < 0.5:
new_node.left = node
new_node.right = new_child
else:
new_node.left = new_child
new_node.right = node
elif mute == StructMutes.Swap:
if isinstance(node, FTreeLeaf):
if node.parent is not None:
node = node.parent
else:
return
# swap operands
tmp = node.left
node.left = node.right
node.right = tmp
else:
# Non-strucure-modifying function mutation
# Select a random node
node = random.choice(self.function.as_list())
if isinstance(node, FTreeNode):
# mutate operator
node.operator = mutated_intenum(node.operator, Op, 1.0,
genome.mute_rates["enum_rel"])
else:
if random.random() < genome.mute_rates["leaf_type"]:
# mutate the leaf type
new_type = node.ref_type
# Keep trying to mutate until the value actually changes
while new_type == node.ref_type:
new_type = mutated_intenum(
node.ref_type, RefType, 1.0,
genome.mute_rates["leaf_rel"])
if node.ref_type == RefType.Constant:
node.val = round(
node.val) # In case mutating from float to int
node.ref_type = new_type
else:
# mutate the leaf value
if node.ref_type == RefType.Constant:
node.val = mutated_num(node.val, 1.0, genome,
[None, None])
elif node.ref_type in [
RefType.Pure_Offset_Call,
RefType.Impure_Offset_Call
]:
node.val = mutated_int_in_range(
node.val, 1.0,
[-len(genome), len(genome)],
genome.mute_rates["enum_rel"])
elif node.ref_type == RefType.Poll_Sensor:
node.val = mutated_int_in_range(
node.val, 1.0, [0, len(goomba.Sensor) - 1],
genome.mute_rates["enum_rel"])
def mutate(self, genome):
if random.random() < genome.mute_rates["gene_action"]:
# Mutate this gene's action
self.action = mutated_intenum(self.action, goomba.Action,
1.0, genome.mute_rates["enum_rel"])
elif random.random() < genome.mute_rates["struct_mod"]:
# Structure-modifying function mutations.
# Select a random node and mutation
node = random.choice(self.function.as_list())
mute = weighted_choice(genome.mute_rates["struct_rel"])
if mute == StructMutes.SubTree:
new_node = FTreeNode.random(round(genome.fun_gen_depth),
len(genome),
genome.const_bounds,
genome.mute_rates["leaf_rel"],
node.parent)
if node.parent is None:
self.function = new_node
elif node.parent.left == node:
node.parent.left = new_node
else:
node.parent.right = new_node
elif mute == StructMutes.OpAbove:
new_node = FTreeNode(random.choice(list(Op)), None, None, node.parent)
if node.parent is None:
self.function = new_node
elif node.parent.left == node:
node.parent.left = new_node
else:
node.parent.right = new_node
new_child = FTreeNode.random(round(genome.fun_gen_depth),
len(genome),
genome.const_bounds,
genome.mute_rates["leaf_rel"],
new_node)
if random.random() < 0.5:
new_node.left = node
new_node.right = new_child
else:
new_node.left = new_child
new_node.right = node
elif mute == StructMutes.Swap:
if isinstance(node, FTreeLeaf):
if node.parent is not None:
node = node.parent
else:
return
# swap operands
tmp = node.left
node.left = node.right
node.right = tmp
else:
# Non-strucure-modifying function mutation
# Select a random node
node = random.choice(self.function.as_list())
if isinstance(node, FTreeNode):
# mutate operator
node.operator = mutated_intenum(node.operator, Op,
1.0, genome.mute_rates["enum_rel"])
else:
if random.random() < genome.mute_rates["leaf_type"]:
# mutate the leaf type
new_type = node.ref_type
# Keep trying to mutate until the value actually changes
while new_type == node.ref_type:
new_type = mutated_intenum(node.ref_type, RefType,
1.0, genome.mute_rates["leaf_rel"])
if node.ref_type == RefType.Constant:
node.val = round(node.val) # In case mutating from float to int
node.ref_type = new_type
else:
# mutate the leaf value
if node.ref_type == RefType.Constant:
node.val = mutated_num(node.val, 1.0,
genome, [None, None])
elif node.ref_type in [RefType.Pure_Offset_Call, RefType.Impure_Offset_Call]:
node.val = mutated_int_in_range(node.val, 1.0,
[-len(genome), len(genome)],
genome.mute_rates["enum_rel"])
elif node.ref_type == RefType.Poll_Sensor:
node.val = mutated_int_in_range(node.val, 1.0,
[0, len(goomba.Sensor) - 1],
genome.mute_rates["enum_rel"])
def mutate(self):
# 1. Iterate through genome, checking each item for mutation
i = 0
while i < len(self):
# 2. Check if the gene mutates.
rand = random.random()
mutation = None
if rand < self.mute_rates["genome"]:
mutation = weighted_choice(self.mute_rates["genome_rel"])
# 3. Apply appropriate mutations, if any.
if mutation is not None:
fuzz = -1
if mutation == GenomeMutes.Insert:
new_gene = Gene.random(round(self.fun_gen_depth),
len(self), self.const_bounds,
self.mute_rates["leaf_rel"])
self.genes.insert(i, new_gene)
fuzz = i
i += 1
elif mutation == GenomeMutes.Dupe:
self.genes.insert(i, self.genes[i].copy())
fuzz = i
i += 1
elif mutation == GenomeMutes.Delete:
del self.genes[i]
i -= 1
elif mutation == GenomeMutes.Invert:
swapindex = (i + 1)%len(self)
tmp = self.genes[i]
self.genes[i] = self.genes[swapindex]
self.genes[swapindex] = tmp
elif mutation == GenomeMutes.MuteGene:
self.genes[i].mutate(self)
fuzz = i
if fuzz != -1:
self.fuzzify(self.genes[fuzz].function)
# Mutate the colours when a functional mutation occurs, for a visual
# indication of genetic distance.
self.mutate_colors()
i += 1
# 4. Reset genome consistency
self.link()
# 5. Mutate the metagenome
# fuzz [0.0, inf)
self.fuzziness = mutated_num(self.fuzziness,
self.mute_rates["genome"],
self,
[0.001, None])
# const bounds (-inf, inf), but small smaller than large
self.const_bounds[0] = mutated_num(self.const_bounds[0],
self.mute_rates["genome"],
self,
[None, None])
self.const_bounds[1] = mutated_num(self.const_bounds[1],
self.mute_rates["genome"],
self,
[None, None])
if self.const_bounds[0] > self.const_bounds[1]:
self.const_bounds = self.const_bounds[::-1]
# fun gen depth [0.0, 5.0]
self.fun_gen_depth = mutated_by_factor(self.fun_gen_depth,
1.7, self.mute_rates["genome"], [0.001, 5.0])
# incr_range [0.0, inf)
self.incr_range = mutated_num(self.incr_range,
self.mute_rates["genome"],
self,
[0.001, None])
# mult_range [1.0, inf)
self.mult_range = mutated_num(self.mult_range,
self.mute_rates["genome"],
self,
[1.0, None])
# Colours used to be mutated here.
# mute_rates "mute", "genome" [0.0, 1.0]
self.mute_rates["mute"] = mutated_by_const(self.mute_rates["mute"],
0.04, self.mute_rates["genome"], [0.001, 1.0])
self.mute_rates["genome"] = mutated_by_const(self.mute_rates["genome"],
0.04, self.mute_rates["mute"], [0.001, 1.0])
# other mute_rates [0.0, inf)
rel_lists = [self.mute_rates["genome_rel"],
self.mute_rates["const_rel"],
self.mute_rates["leaf_rel"]]
for rel_list in rel_lists:
for k in rel_list:
rel_list[k] = mutated_num(rel_list[k],
self.mute_rates["mute"],
self,
[0.001, None])
words = line.split()
grams += [tuple(words[i:i + N]) for i in xrange(len(words) - N + 1)]
gprob = u.to_prob(grams)
gram = dd(lambda: dd(lambda: 0))
gram_prob = dd(lambda: dd(lambda: 0))
for key, prob in gprob.items():
gram[key[:-1]][key[-1]] = prob
for gram1, gram1_dict in gram.items():
for gram2, p in gram1_dict.items():
gram_prob[gram1][gram2] = u.softmax(p, gram1_dict.values())
start = random.choice(gprob.keys())
output = " ".join(start)
last = start[1:]
for i in range(T):
gen = u.weighted_choice(gram_prob[last].items())
if gen: output += gen + " "
last = last[1:] + tuple([gen])
line = output.split("|")
phonemes = []
for word in line:
phonemes.append(tuple(word.split()))
print to_words([phonemes], text)
def generate_age(classification):
# age distribution at last tab "17.Population by Age-Group"
# http://rural.nic.in/sites/downloads/IRDR/1.%20Demographic%20Profile.xls
age_range = util.weighted_choice(age_ranges, age_weights[classification])
return random.randint(age_range[0], age_range[1])
