def __init__(self, operator, context):
seed(operator.seed)
if operator.create_empty and not operator.convert:
create.empty(operator, context)
if operator.uniform:
if operator.amount > 1:
operator.depth_locations = [
operator.depth * (index / (operator.amount - 1))
for index in range(operator.amount)
]
for index in range(operator.amount):
thickness = random_float(operator.thickness_min,
operator.thickness_max)
pipe = create.pipe(operator, context, index, thickness)
self.pipe(operator, context, pipe, index, thickness)
def straight(self, operator, pipe, spline, thickness): spline.points[0].co.x = self.keep_inside(random_float(-operator.width * 0.5, operator.width * 0.5), thickness, operator.width * 0.5) spline.points.add(count=1) spline.points[-1].co.x = spline.points[-2].co.x spline.points[-1].co.y = operator.height
def depth(self, operator, context, pipe, depth, index, thickness): pipe.location.y += self.keep_inside(random_float(-depth, depth), thickness, depth) if operator.uniform: pipe.location.y = context.space_data.cursor_location.y if operator.amount > 1: pipe.location.y += operator.depth_locations[index] - operator.depth * 0.5
def depth(self, ot, context, pipe, depth, index, thickness):
pipe.location.y += self.keep_inside(random_float(-depth, depth),
thickness, depth)
if ot.uniform:
pipe.location.y = ot.location.y
if ot.amount > 1:
pipe.location.y += ot.depth_locations[
index] - ot.depth * 0.5
def __init__(self, ot, context):
seed(ot.seed)
create.empty(ot, context)
if ot.uniform:
if ot.amount > 1:
ot.depth_locations = [
ot.depth * (index / (ot.amount - 1))
for index in range(ot.amount)
]
for index in range(ot.amount):
thickness = random_float(ot.thickness_min, ot.thickness_max)
if ot.thickness_min > ot.thickness_max:
thickness = ot.thickness_max
pipe = create.pipe(ot, context, index, thickness)
self.pipe(ot, context, pipe, index, thickness)
def __init__(self, operator, context): seed(operator.seed) if operator.create_empty and not operator.convert: create.empty(operator, context) if operator.uniform: if operator.amount > 1: operator.depth_locations = [operator.depth * (index / (operator.amount - 1)) for index in range(operator.amount)] for index in range(operator.amount): thickness = random_float(operator.min, operator.max) pipe = create.pipe(operator, context, index, thickness) self.pipe(operator, context, pipe, index, thickness)
def _random_weight(self) -> _CrawlerWeight:
return random_float(0, sum(crawler.weight for crawler in self))
def get_corners(self, operator, context, pipe, spline, thickness):
keep_inside = generate.pipe.keep_inside
spline.points[-1].co.x = keep_inside(
random_float(-operator.width * 0.5, operator.width * 0.5),
thickness, operator.width * 0.5)
last_x = spline.points[-1].co.x
last_y = 0.0
first_pass = True
pipe_corners = [[last_x, last_y]]
while last_y < operator.height:
if first_pass:
coord_y = keep_inside(
last_y + random_float(operator.length_y_min,
operator.length_y_max) * 0.5,
thickness, operator.height)
first_pass = False
else:
coord_y = keep_inside(
last_y + random_float(operator.length_y_min,
operator.length_y_max),
thickness, operator.height)
if coord_y + min(operator.length_y_min, operator.
length_y_max) * 0.5 > operator.height:
pipe_corners.append([last_x, operator.height])
break
length_x_min = operator.length_x_min
length_x_max = operator.length_x_max
if last_x - length_x_min - thickness <= -operator.width * 0.5:
left = False
elif last_x + length_x_min + thickness >= operator.width * 0.5:
left = True
else:
left = choice([True, False])
thickness = -thickness if left else thickness
length_x_min = -length_x_min if left else length_x_min
length_x_max = -length_x_max if left else length_x_max
coord_x = keep_inside(
last_x + random_float(length_x_min, length_x_max),
thickness, operator.width * 0.5)
pipe_corners.append([last_x, coord_y, True, left])
last_x = coord_x
last_y = coord_y
pipe_corners.append([last_x, last_y, False, left])
return pipe_corners
def run(self):
super(Pav,self).run()
import time
from progressbar import progress
from random import uniform as random_float
#Reset since start stopwatch
self.since_start.reset()
#Log start
self.log.append((0,0,"Start"))
#Start doing the tasks
current_task = 0
for current_task in range(self.action_count):
#Update progressbar
progress(current_task*100/self.action_count)
#Execute stimulus command
self.stimulus()
#Reset since stim stopwatch
self.since_stim.reset()
#Log the stimulus
self.log.append((self.since_start.value(), 0, "Stimulus"))
print "Stimulus at "+ str(self.since_start)
#Wait until the stim is over. Detect premature licks.
self.stim_timer.reset()
while self.stim_timer.is_running():
time.sleep(0.001)
if self.sensor.detected():
self.log.append((self.since_start.value(), self.since_stim.value(), "Lick (premature)"))
print "Lick at " + str(self.since_start) +" Since stim. " +str(self.since_stim)+ " //Premature"
#Give water
self.water_valve.pulse()
#Log the water
self.log.append((self.since_start.value(), self.since_stim.value(), "Water"))
print "Water at " + str(self.since_start) +" Since stim. " +str(self.since_stim)
#Generate random wait time
wait_time = random_float(self.wait_time_min,self.wait_time_max)
#Log wait time
self.wait_times.append(wait_time)
print "Wait time "+mtools.toString(wait_time)+" sec"
#Set new time and reset the main timer
self.main_timer.set(wait_time)
self.main_timer.reset()
#Wait until next stim. Log licks
while self.main_timer.is_running():
time.sleep(0.001)
if self.sensor.detected():
self.log.append((self.since_start.value(), self.since_stim.value(), "Lick"))
print "Lick at " + str(self.since_start) +" Since stim. " +str(self.since_stim)
#Update progressbar
progress(100)
#Log end of project
self.log.append((self.since_start.value(), self.since_stim.value(), "End"))
#Calculate wait time statistics
average_wait_time = mtools.avg(self.wait_times)
wait_time_deviation = mtools.dev(self.wait_times)
#Create specific logs
licks_log = filter(lambda record: record[2]=="Lick" or record[2]=="Lick (premature)", self.log)
reaction_times = map(lambda record: record[1], licks_log)
#Calculate lick statistics
average_reaction_time = mtools.avg(reaction_times)
reaction_time_deviation = mtools.dev(reaction_times)
#Create log files
main_logfile = open("/MouseCandy/run/log.txt", "w")
licks_logfile = open("/MouseCandy/run/licks.csv", "w")
#Write logfile headers
main_logfile.write(str(self)+"\n")
main_logfile.write("Average wait time: " + mtools.toString(average_wait_time, padded=False) +" sec\n")
main_logfile.write("Wait time deviation: " + mtools.toString(wait_time_deviation, padded=False) +" sec\n")
main_logfile.write("Average reaction time: " + mtools.toString(average_reaction_time, padded=False) +" sec\n")
main_logfile.write("Reaction time deviation: " + mtools.toString(reaction_time_deviation, padded=False) +" sec\n\n")
licks_logfile.write("time[s],since_last_stim[s]\n")
#Write records into log files
for record in self.log:
main_logfile.write(mtools.toString(record[0])+" "+mtools.toString(record[1])+" "+record[2]+"\n")
for record in licks_log:
licks_logfile.write(str(record[0])+","+str(record[1])+"\n")
main_logfile.close()
licks_logfile.close()
#Create zipfiles
import os
zipname = mtools.CRC32_from_file("/MouseCandy/run/log.txt")
os.system("zip -j /MouseCandy/logs/"+zipname+".zip /MouseCandy/run/log.txt /MouseCandy/run/licks.csv")
os.remove("/MouseCandy/run/log.txt")
os.remove("/MouseCandy/run/licks.csv")
os.system("zipnote /MouseCandy/logs/"+zipname+".zip > /MouseCandy/logs/temp_notes.txt")
notesfile = open("/MouseCandy/logs/temp_notes.txt", "a")
tags = str(self).split("\n")
tags = tags[0]
notesfile.write(tags+"\n")
notesfile.write(self.name)
notesfile.close()
os.system("zipnote -w /MouseCandy/logs/"+zipname+".zip < /MouseCandy/logs/temp_notes.txt")
os.remove("/MouseCandy/logs/temp_notes.txt")
def generate_unique_id(length=15):
id = bytearray()
for i in range(length):
id.append(int(random_float(0,255)))
return urlsafe_b64encode(id).decode("ASCII")
def simulated_annealing(**kwargs):
"""
Creates a random individual from which simulated annealing is used to generate a population.
:param kwargs: Dictionary of expected parameters:
- (int) 'node_count': Number of nodes used in the problem. Includes depot nodes and optional nodes.
- (list<int>) 'depot_nodes': List of depot nodes used in the problem.
- (list<int>) 'optional_nodes': List of optional nodes used in the problem.
- (int) 'vehicle_count': Number of vehicles used in the problem.
- (int) 'population_count': Number of individuals in the population.
- (int) 'minimum_cpu_time': CPU time that is allotted for the initialization of an individual solution.
The purpose of this is to stop the algorithm if that is unable to create a valid individual
(or it takes too long).
- (dict) 'validation_args': Dictionary of arguments that are used in individual validations. See
validation functions for what is expected of them.
- (dict) 'evaluation_args': Dictionary of arguments that are used in individual evaluations. See
evaluation functions for what is expected of them.
- (int) 'sa_iteration_count': Number of iterations that SA is allowed to go for.
- (int) 'sa_initial_temperature': Initial temperature, acts as how easily a solution could be accepted.
- (float) 'sa_p_coeff': Annealing coefficient.
- (bool) 'maximize': Flag that determines whether the objective to maximize or minimize.
:return: List of randomly generated individuals, representing the population. (list<VRP>)
"""
population = []
node_count = kwargs["node_count"]
depot_nodes = kwargs["depot_nodes"]
optional_nodes = kwargs["optional_nodes"]
vehicle_count = kwargs["vehicle_count"]
population_count = kwargs["population_count"]
minimum_cpu_time = kwargs["minimum_cpu_time"]
validation_args = kwargs["validation_args"]
evaluation_args = kwargs["evaluation_args"]
sa_iteration_count = kwargs["sa_iteration_count"]
sa_initial_temperature = kwargs["sa_initial_temperature"]
sa_p_coeff = kwargs["sa_p_coeff"]
if "maximize" in kwargs:
if kwargs["maximize"] is True:
reverse_sort = True
max_factor = 1
else:
reverse_sort = False
max_factor = -1
else:
reverse_sort = False
max_factor = -1
population_timer = Timer()
individual_timer = Timer(goal=minimum_cpu_time)
def check_goal(timer):
return timer.past_goal()
population_timer.start()
individual_timer.start()
individual_args = {
"node_count": node_count,
"depot_nodes": depot_nodes,
"optional_nodes": optional_nodes,
"vehicle_count": vehicle_count,
"failure_msg":
"(Simulated Annealing - Random) Individual initialization is taking too long.",
"individual_timer": individual_timer,
"check_goal": check_goal,
"validation_args": validation_args,
"evaluation_args": evaluation_args
}
candidate_individual, individual_msg = random_valid_individual(
**individual_args)
if candidate_individual is None:
return None, individual_msg
individual_timer.reset()
population.append(candidate_individual)
guide_individual = deepcopy(candidate_individual)
candidate_individual = deepcopy(candidate_individual)
guide_individual.assign_id()
candidate_individual.assign_id()
for n in range(1, sa_iteration_count):
# Once all of the iterations have been exhausted, the state of the population is checked.
# If the population quota is not met, random individuals are created to make up for it.
valid_individual = False
while valid_individual is False:
# Usually only one change is considered in SA. In this case, there is a possibility
# that one change can invalidate the individual. For that reason, we'll keep changing it
# until it is valid.
VRP.mutation_operator[randint(0,
len(VRP.mutation_operator) -
1)](candidate_individual)
for validator in VRP.validator:
valid_individual, validation_msg = validator(
candidate_individual, **validation_args)
if valid_individual is False:
break
# If the solution is invalid, mutate it again.
candidate_individual.valid = valid_individual
# Should solution-finding via mutations take too long, it is halted here.
if check_goal(individual_timer):
return None, "(Simulated Annealing) Individual initialization is taking too long."
# Once the solution is valid, evaluate it.
candidate_individual.fitness = VRP.evaluator(candidate_individual,
**evaluation_args)
# Calculate temperature for current iteration and generate a "pass requirement".
temperature = sa_initial_temperature * (
1 - (n - 1) / (sa_iteration_count - 1))**sa_p_coeff
pass_requirement = random_float()
# With the fitness values of both guide and candidate, SA probability can be calculated.
try:
sa_probability = exp(
max_factor *
(candidate_individual.fitness - guide_individual.fitness) /
temperature)
except OverflowError:
sa_probability = float("inf")
if sa_probability >= pass_requirement:
# Mutation has been selected as the new guide.
population.append(candidate_individual)
# Delete old individuals if current population is too large.
if len(population) > population_count:
del population[0]
guide_individual = deepcopy(candidate_individual)
guide_individual.assign_id()
candidate_individual = deepcopy(guide_individual)
outcome_str = "Selected"
else:
# Mutation has been rejected. Revert to guide individual.
candidate_individual = deepcopy(guide_individual)
outcome_str = "Discarded"
print("Iteration: {} |"
" Fitness: {:> .5f} |"
" Temperature: {:> .5f} |"
" Selection Probability: {:> .5f} |"
" Outcome: {}".format(n, candidate_individual.fitness,
temperature, sa_probability, outcome_str))
# Reset individual timer upon completing an iteration.
individual_timer.reset()
population_timer.stop()
individual_timer.stop()
msg = "(Simulated Annealing) Population initialization OK (Time taken: {} ms)\n" \
"- Result Population Size: {}" \
.format(population_timer.elapsed(), len(population))
# If resulting population is too small, add missing individuals by
# generating random individuals.
if len(population) < population_count:
missing_population_count = population_count - len(population)
missing_population, msg0 = random(
node_count=node_count,
depot_nodes=depot_nodes,
optional_nodes=optional_nodes,
vehicle_count=vehicle_count,
population_count=missing_population_count,
minimum_cpu_time=minimum_cpu_time,
validation_args=validation_args,
evaluation_args=evaluation_args)
population = population + missing_population
population.sort(key=attrgetter("fitness"), reverse=reverse_sort)
return population, msg
def random_valid_individual(**kwargs):
"""
Creates a random individual, the solution of which has been both validated
and evaluated.
:param kwargs: Dictionary of expected parameters:
- (int) 'node_count': Number of nodes used in the problem. Includes depot nodes and optional nodes.
- (list<int>) 'depot_nodes': List of depot nodes used in the problem.
- (list<int>) 'optional_nodes': List of optional nodes used in the problem.
- (int) 'vehicle_count': Number of vehicles used in the problem.
- (str) 'failure_msg': Text to represent if individual creation is taking too long.
- (Timer) 'individual_timer': Timer based on specified minimum CPU time. Should be started before
calling this function.
- (function) 'check_goal': Convenience function that checks whether minimum CPU time has passed.
- (dict) 'validation_args': Dictionary of arguments that are used in individual validations. See
validation functions for what is expected of them.
- (dict) 'evaluation_args': Dictionary of arguments that are used in individual evaluations. See
evaluation functions for what is expected of them.
:return: Randomly generated individual that has been validated and evaluated.
"""
node_count = kwargs["node_count"]
depot_nodes = kwargs["depot_nodes"]
optional_nodes = kwargs["optional_nodes"]
vehicle_count = kwargs["vehicle_count"]
failure_msg = kwargs["failure_msg"]
individual_timer = kwargs["individual_timer"]
check_goal = kwargs["check_goal"]
validation_args = kwargs["validation_args"]
evaluation_args = kwargs["evaluation_args"]
valid_individual = False
candidate_individual = None
while valid_individual is False:
candidate_solution = random_solution(node_count=node_count,
depot_nodes=depot_nodes,
optional_nodes=optional_nodes,
vehicle_count=vehicle_count)
# Create an individual so that a solution can be assigned, validated and evaluated.
candidate_individual = VRP(node_count, vehicle_count, depot_nodes,
optional_nodes)
candidate_individual.assign_solution(candidate_solution)
# Mutate the individual with "vehicle diversification" 10% of the time.
if random_float() <= 0.10:
vehicle_diversification(candidate_individual)
for validator in VRP.validator:
valid_individual, validation_msg = validator(
candidate_individual, **validation_args)
# print("(Random Valid Individual) {}".format(validation_msg))
if valid_individual is False:
break
# If the solution is invalid, the process is restarted.
candidate_individual.valid = valid_individual
# Should solution-finding take too long, it is halted here.
if check_goal(individual_timer):
return None, failure_msg
# Once the solution is valid, it is evaluated.
candidate_individual.fitness = VRP.evaluator(candidate_individual,
**evaluation_args)
# The individual is now ready for use.
return candidate_individual, "Individual Creation OK (Time taken: {} ms)".format(
individual_timer.elapsed())
def get_corners(self, operator, context, pipe, spline, thickness): keep_inside = generate.pipe.keep_inside spline.points[-1].co.x = keep_inside(random_float(-operator.width * 0.5, operator.width * 0.5), thickness, operator.width * 0.5) last_x = spline.points[-1].co.x last_y = 0.0 first_pass = True pipe_corners = [[last_x, last_y]] while last_y + abs(operator.length_y_max - thickness) < operator.height - abs(operator.length_y_max - thickness): if last_x - thickness <= -operator.width * 0.5: left = False elif last_x + thickness >= operator.width * 0.5: left = True else: left = choice([True, False]) if first_pass: left_first = choice([True, False]) coord_y = random_float(thickness, operator.length_y_max) first_pass = False else: length_y_min = operator.length_y_min + abs(operator.length_y_min - thickness) length_y_max = operator.length_y_max + abs(operator.length_y_max - thickness) coord_y = keep_inside(last_y + random_float(length_y_min, length_y_max), thickness, operator.height) length_x_min = operator.length_x_min + abs(operator.length_x_min - thickness) length_x_max = operator.length_x_max + abs(operator.length_x_max - thickness) thickness = -thickness if left else thickness length_x_min = -length_x_min if left else length_x_min length_x_max = -length_x_max if left else length_x_max coord_x = keep_inside(last_x + random_float(length_x_min, length_x_max), thickness, operator.width * 0.5) pipe_corners.append([last_x, coord_y, True, left]) last_x = coord_x last_y = coord_y pipe_corners.append([last_x, last_y, False, left]) else: pipe_corners.append([last_x, operator.height]) return pipe_corners
max_longitude = max(longitudes)
print('Using latitude range: ', min_latitude, max_latitude)
print('Using longitude range: ', min_longitude, max_longitude)
# Base API URL
base_url = 'https://maps.googleapis.com/maps/api/staticmap?'
map_param = '&maptype=map'
satellite_param = '&maptype=satellite'
default_params = '&zoom=16&size=256x286&sensor=false&style=feature:all|element:labels|visibility:off'
for i in range(500, 500 + num_images + 1):
# Sleep every 0.5 seconds so we don't get throttled
sleep(0.5)
local_latitude = random_float(min_latitude, max_latitude)
local_longitude = random_float(min_longitude, max_longitude)
location_param = 'center=' + str(local_latitude) + ',' + str(
local_longitude)
# Map image
fname = str(i) + '_map_' + location_param + '.png'
url = base_url + location_param + default_params + map_param
img = get_imagery(url)
img.save(os.path.join('raw/', fname))
# Satellite image
fname = str(i) + '_satellite_' + location_param + '.png'
url = base_url + location_param + default_params + satellite_param
img = get_imagery(url)
