def run(inputCount, outputCount, population, activationFunction, generationCount, windowSize = Fitness.windowSize):
win = graphics.GraphWin("NEAT", width = windowSize[0], height = windowSize[1]) #The window that NEAT will draw the evaluation of each genome in
currGeneration = Generation.generation(inputCount, outputCount, population, activationFunction) #Creates a first generation
t = 0 #Keeps track of which generation we're on
while t < generationCount:
print("Beginning Generation " + str(t))
currGeneration.assignSpecies() #Assigns a species to each member of the current generation
currGeneration.countSpecies() #Counts up how many members are in each species
activeSpecies = sum([x > 0 for x in currGeneration.counts])
print("Active Species: " + str(activeSpecies)) #Prints how many species still have living members
print("Extinct Species: " + str(len(currGeneration.counts) - activeSpecies)) #Prints how many species have lived and then gone extinct
currGeneration.assignFitnesses(win) #Assigns each genome in the generation its fitness
print("Max Fitness: " + str(max([x.FI * currGeneration.counts[int(x.SP[4:])] for x in currGeneration.genomes]))) #Prints the raw fitness of the best genome
print("Average Fitness: " + str((sum([x.FI * currGeneration.counts[int(x.SP[4:])] for x in currGeneration.genomes])) / population)) #Prints the average raw fitness of the generation
currGeneration.assignParents() #Creates the list of parents
currGeneration.generateChildren() #Creates the genomes in the next generation
nextGeneration = Generation.generation(inputCount, outputCount, population, activationFunction, currGeneration.IN) #Creates the next generation
print("Current Innovation Number: " + str(currGeneration.IN)) #Prints the current innovation number
nextGeneration.genomes = copy.deepcopy(currGeneration.children) #Loads the genomes into the new generation
nextGeneration.holotypes = copy.deepcopy(currGeneration.holotypes) #Preserves the collection of holotypes
currGeneration = copy.deepcopy(nextGeneration) #Loads the next generation
del nextGeneration #Deletes the placeholder generation
t += 1 #Moves the generation counter
print(20 * "~*")
win.close()
def turn():
Clear.clear()
with open("UniData.txt", 'r') as f:
variables = json.load(f)
#variables["week"] += 1
#f.close()
variables["week"] += 1
with open("UniData.txt", 'w') as f2:
json.dump(variables, f2, indent=3)
#f2.close()
WordCore.word_core("A new week has come...", 0.01)
print("\n")
print("Week Number: " + str(variables["week"]))
Generation.dna_weekly()
Generation.dna_random()
infecting_agent()
check_cure_start()
BURST_check()
NECROSIS_check()
ZOMBIFY_check()
enforce_value_maximums()
print("\n")
Graph.graphical_analysis_mini()
#time.sleep(3)
player_menu()
def __init__(self,
OutputGeometryFile,
OutputXmlFile,
VoxelSizeMetres,
Axis,
LengthMetres,
RadiusMetres,
InletPressure=None,
OutletPressure=None):
"""Clip the STL and set attributes on the SWIG-proxied C++
GeometryGenerator object.
"""
GeometryGenerator.__init__(self)
self.Axis = Axis
self.LengthMetres = LengthMetres
self.RadiusMetres = RadiusMetres
self.InletPressure = InletPressure
self.OutletPressure = OutletPressure
self._profile = Profile()
self._profile.StlFileUnitId = Profile._UnitChoices.index(metre)
self._profile.VoxelSize = VoxelSizeMetres
self._profile.OutputGeometryFile = OutputGeometryFile
self._profile.OutputXmlFile = OutputXmlFile
self._MakeIolets()
self.generator = Generation.CylinderGenerator()
self._SetCommonGeneratorProperties()
self.generator.SetCylinderLength(LengthMetres / VoxelSizeMetres)
self.generator.SetCylinderRadius(RadiusMetres / VoxelSizeMetres)
self.generator.SetCylinderCentre(Generation.DoubleVector(0., 0., 0.))
self.generator.SetCylinderAxis(Generation.DoubleVector(*self.Axis))
return
def _MakeIolets(self):
# Construct the Iolet structs
inlet = Inlet()
c = [0., 0., 0.]
c[self.OpenAxis] = -0.5 * self.LengthVoxels * self._profile.VoxelSize
inlet.Centre = Vector(*c)
n = Generation.DoubleVector()
n[self.OpenAxis] = 1.
inlet.Normal = Vector(n.x, n.y, n.z)
inlet.Radius = self.SideVoxels * self._profile.VoxelSizeMetres
if self.InletPressure is not None:
inlet.Pressure = self.InletPressure
self._profile.Iolets.append(inlet)
outlet = Outlet()
c = [0., 0., 0.]
c[self.OpenAxis] = 0.5 * self.LengthVoxels * self._profile.VoxelSize
outlet.Centre = Vector(*c)
n = Generation.DoubleVector()
n[self.OpenAxis] = -1.
outlet.Normal = Vector(n.x, n.y, n.z)
outlet.Radius = self.SideVoxels * self._profile.VoxelSizeMetres
if self.OutletPressure is not None:
outlet.Pressure = self.OutletPressure
self._profile.Iolets.append(outlet)
return
def __init__(self, OutputGeometryFile, OutputXmlFile, VoxelSizeMetres,
OpenAxis, LengthVoxels, SideVoxels,
InletPressure=None, OutletPressure=None):
"""Clip the STL and set attributes on the SWIG-proxied C++
GeometryGenerator object.
"""
GeometryGenerator.__init__(self)
assert OpenAxis in (0, 1, 2)
self.OpenAxis = OpenAxis
self.LengthVoxels = LengthVoxels
self.SideVoxels = SideVoxels
self.Sizes = Generation.DoubleVector(SideVoxels, SideVoxels, SideVoxels)
self.Sizes[OpenAxis] = LengthVoxels
self.InletPressure = InletPressure
self.OutletPressure = OutletPressure
self._profile = Profile()
self._profile.StlFileUnitId = Profile._UnitChoices.index(metre)
self._profile.VoxelSize = VoxelSizeMetres
self._profile.OutputGeometryFile = OutputGeometryFile
self._profile.OutputXmlFile = OutputXmlFile
self._MakeIolets()
self.generator = Generation.SquareDuctGenerator()
self._SetCommonGeneratorProperties()
self.generator.SetOpenAxis(self.OpenAxis)
lb = self.Sizes * -0.5
self.generator.SetLowerBound(lb)
ub = self.Sizes * 0.5
self.generator.SetUpperBound(ub)
return
def validate(load_data, feat_dict):
clf = load_data['model']
norm = load_data['norm']
mean = load_data['mean']
std = load_data['std']
if (norm == "MeanStd"):
g.normFeature(feat_dict, norm, mean, std)
elif (norm == "MinMax"):
g.normFeature(feat_dict, norm)
else:
assert (False)
feat_array = g.convertDictToFeatArray(feat_dict)
return clf.predict(feat_array)
def __init__(self):
self.turtleWrapper = turtleWrap.TurtleWrapper()
self.warehouse = warehouse.Warehouse()
self.population = Generation.Generation()
self.screen = turtle.Screen()
self.current_position = Point.Point(round(self.warehouse.WIDTH/2), round(self.warehouse.HEIGHT/2))
self.init_screen()
class God:
generation = None
def initializeFirstGeneration(self):
self.generation = Generation(0)
def applyEvolution(self):
empty = []
empty2 = [] #number of stay puts
for i in range(NUM_GENERATIONS):
self.generation, normalizedScore, bestScore, number_of_stay_puts = self.generation.applyEvolution(
)
print(str(normalizedScore) + ',' + str(bestScore))
empty.append(bestScore)
empty2.append(number_of_stay_puts)
with open('results.txt', 'a') as file:
file.write(str(normalizedScore) + ',' + str(bestScore) + '\n')
plt.plot(empty2, 'r-', label='Number of stay puts')
plt.plot(empty, 'b-', label='Fitness in the population')
plt.ylabel("Best Fitness in Population")
plt.xlabel("Generation")
plt.legend()
plt.savefig('foo.png')
plt.show()
def PrintGenerationMenu():
Selection = input("\nGeneration Menu > ")
try:
if Selection == "exit":
#print("Spacer")
SelectMenu(GenerationMenu, MainMenu)
elif Selection == "reload":
Core.ClearScreen()
os.execl(sys.executable, sys.executable, *sys.argv)
else:
Selection = (int(Selection))
if Selection == 1:
Generation.HTTPGen()
elif Selection == 2:
Generation.DHCPGen()
elif Selection == 3:
Generation.DNSGen()
except:
SelectMenu(GenerationMenu, GenerationMenu)
def main():
# Read yaml configuration file
routing_config = Utilities.read_yml("routing_config.yml")
routes = routing_config['routes']
generations = routing_config['generations']
generation_size = routing_config['generation_size']
mutation_chance = routing_config['mutation_chance']
origin = routing_config['origin']
# Read in csv to a dictionary
#nodes_dict = Utilities.read_input_nodes("Kiosk Coords.csv")
nodes_dict = Utilities.read_json_states("state_capitals.json")
# Creates a Network object for the purpose of organizing the Nodes for use in the genetic algorithm
node_network = Network.Network('StateCapitols', origin, nodes_dict)
# Create the initial generation of solutions
solution_generation = Generation.Generation(size=generation_size,
routes=routes,
origin=origin,
network=node_network)
# Begin iterating through generations
best_solution = None
for i in range(1, generations + 1):
solution_generation.generation_step(mutation_chance)
solution_generation.remove_weakest_half()
# Log best solutions
if best_solution is not None:
current_best_solution = solution_generation.get_best_solution()
if (best_solution.score > current_best_solution.score):
best_solution = current_best_solution
else:
best_solution = solution_generation.get_best_solution()
if i % 100 == 0:
print("Generation: ", i)
print("Average distance: ",
solution_generation.generation_average_score())
print("Min Distance: ", best_solution.score)
print("")
#print(best_solution.route_list)
#print(best_solution.score)
# If the best solution was found to be valid print output and generate a quick plot for validation
if best_solution.valid_solution():
node_network.process_solution(best_solution)
node_network.display_routes()
node_network.plot_routes()
else:
print("Error: Best solution is invalid")
def turn_fast():
Clear.clear()
with open("UniData.txt", 'r') as f:
variables = json.load(f)
variables["week"] += 1
with open("UniData.txt", 'w') as f2:
json.dump(variables, f2, indent=3)
print("A new week has come...")
print("\n")
print("Week Number: " + str(variables["week"]))
Generation.dna_weekly()
Generation.dna_random()
infecting_agent()
check_cure_start()
BURST_check()
NECROSIS_check()
ZOMBIFY_check()
enforce_value_maximums()
Game_Over()
print("\n")
class God:
generation = None
def initialize_first_generation(self):
self.generation = Generation(0)
def apply_evolution(self):
for i in range(NUM_GENERATIONS):
self.generation, normalized_score, best_score = self.generation.apply_evolution()
print(str(normalized_score) + ',' + str(best_score))
with open('results.txt', 'a') as file:
file.write(str(normalized_score) + ',' + str(best_score) + '\n')
def __init__(self, profile):
"""Clip the STL and set attributes on the SWIG-proxied C++
GeometryGenerator object.
"""
GeometryGenerator.__init__(self)
self._profile = profile
self.generator = Generation.PolyDataGenerator()
self._SetCommonGeneratorProperties()
self.generator.SetSeedPointWorking(
profile.SeedPoint.x / profile.VoxelSize,
profile.SeedPoint.y / profile.VoxelSize,
profile.SeedPoint.z / profile.VoxelSize)
# This will create the pipeline for the clipped surface
clipper = Clipper(profile)
# Scale by the voxel size
trans = vtkTransform()
scale = 1. / profile.VoxelSize
trans.Scale(scale, scale, scale)
transformer = vtkTransformFilter()
transformer.SetTransform(trans)
transformer.SetInputConnection(
clipper.ClippedSurfaceSource.GetOutputPort())
# Uncomment this an insert the output path to debug pipeline construction
# write = StageWriter('/Users/rupert/working/compare/aneurysm').WriteOutput
# i = 0
# for alg in getpipeline(transformer):
# print i
# i += 1
# print alg
# write(alg)
transformer.Update()
self.ClippedSurface = transformer.GetOutput()
self.generator.SetClippedSurface(self.ClippedSurface)
originWorking, nSites = self._ComputeOriginWorking()
self.generator.SetOriginWorking(*(float(x) for x in originWorking))
self.generator.SetSiteCounts(*(int(x) for x in nSites))
self.OriginMetres = Vector(originWorking * self.VoxelSizeMetres)
return
def __init__(self, size, maze_type, algorithm, auto_generation=True):
self.size = size
self.maze_type = maze_type
self.type_value = getattr(self.Type, maze_type)
self.position = None
self.cell_size = None
self.graph_cell_size = None
self.algorithm = algorithm
if auto_generation:
self.cell_list = CellList.generate(self.type_value, self.size)
self.edge_list = EdgeList.generate(self.type_value, self.size)
self.maze_list, self.maze_order, self.maze_cell_borders = Generation.generate(
algorithm, self.type_value, self.cell_list, self.edge_list)
else:
self.cell_list = None
self.edge_list = None
self.maze_list, self.maze_order, self.maze_cell_borders = None, None, None
# solution lists
self.solution_path = []
self.visited = []
self.graph_bool = False
self.step_bool = False
self.delay = False
(start,
end) = MazeFunctions.cell_endpoints_calculate(self.type_value,
self.size)
self.start = self.cell_list[start]
self.end = self.cell_list[end]
# maze colors
self.color_background = Color.white
self.color_line = Color.black
self.color_start = Color.green_light
self.color_end = Color.salmon
self.color_frame = Color.black
def __init__(self, ce_id):
# check if there is "Simulations" folder is already created or not
self.simulationsPath = os.path.dirname(
os.path.realpath(__file__)) + "/Simulations/"
if os.path.isdir(self.simulationsPath):
pass
else:
os.makedirs(self.simulationsPath)
# Collection of all CultEvo runs
# something of the form : ..cwd..\Simulations_2016-03-04_[13_23_06]\
self.simulationPath = self.simulationsPath + "Sim_{}/".format(ce_id)
if os.path.isdir(self.simulationPath):
pass
else:
# create folders with specific simulation detail as their name
os.makedirs(self.simulationPath)
# individual simulation run paths(holding all its generation folders):
self.simRunPath = self.simulationPath + "SimRun_000/"
if os.listdir(self.simulationPath).__len__() == 0:
os.makedirs(self.simRunPath)
else:
# get the highest index of the already existing folders.
self.simRunPath = self.simulationPath + "SimRun_{:03}/".format(
int(sorted(os.listdir(self.simulationPath))[-1].split("_")[1])
+ 1)
os.makedirs(self.simRunPath)
# for Generation folders check in Generation.py
# Variable determining how many generations we wan t toallow
generations = P.generations
generation_run = Generation.Generation(P.numberAgents, generations,
self.simRunPath)
self.numOfGenerations = generation_run.countGenUp
def init(floor, wall, render_layer):
lvl, enemies = Generation.generate()
for xx in range(size_x):
for yy in range(size_y):
f = None
if lvl[(xx, yy)] == 1:
f = wall(xx, yy)
else:
f = floor(xx, yy)
actors[(xx, yy)] = None
terrain[(xx, yy)] = f
render_layer.add(f)
for k, v in enemies.items():
enemy = v(k[0], k[1])
actors[k] = enemy
render_layer.add(enemy)
State.spawn(enemy)
def _MakeIoletProxies(self):
# Construct the Iolet structs
nIn = 0
nOut = 0
ioletProxies = []
for io in self._profile.Iolets:
proxy = Generation.Iolet()
proxy.Centre = DVfromV(io.Centre) / self._profile.VoxelSize
proxy.Normal = DVfromV(io.Normal)
proxy.Radius = io.Radius / self._profile.VoxelSize
if isinstance(io, Inlet):
io.Id = proxy.Id = nIn
proxy.IsInlet = True
nIn += 1
elif isinstance(io, Outlet):
io.Id = proxy.Id = nOut
proxy.IsInlet = False
nOut += 1
pass
ioletProxies.append(proxy)
continue
return ioletProxies
def DVfromV(v):
"""Translate a Model.Vector.Vector to a Generation.DoubleVector.
"""
return Generation.DoubleVector(v.x, v.y, v.z)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--Start', '-s', type=int, default=11)
parser.add_argument('--End', '-e', type=int, default=15)
parser.add_argument('--Plot', '-p', type=str, default="False")
# Append additional data to results.pkg
parser.add_argument('--Append', '-a', type=str, default="True")
# Using C values instead
parser.add_argument('--C', '-c', type=str, default="False")
args = parser.parse_args()
meas_obj = mm.Measurement("Study_005_channel1.pkg", args.Start, args.End)
meas_obj.downsample(2)
feat_obj = fe.Feature(meas_obj)
feat_label_dict = g.getFeaturesAndLabel(meas_obj, feat_obj)
feat_dict = dict(
(k, feat_label_dict[k]) for k in feat_key if k in feat_label_dict)
data_downsampled = feat_label_dict['data']
label_downsampled = feat_label_dict['label']
# Good practice to check that the correct keys are generated for their value
if (g.checkDictForFeat(feat_dict) == False):
assert (False)
# MIGHT GET RID OF APPEND AND REPLACE IT WITH ANOTHER FUNCTION THAT SIMPLY DELETES EXTRANEOUS INFORMATION?
list_of_files = os.listdir('.')
trained_files = []
if (str2bool(args.Append) == True and str2bool(args.C) == False):
start_gamma = input("Enter the first gamma: ")
end_gamma = input("Enter the last gamma: ")
inc = 1
for i in np.arange(start_gamma, end_gamma + inc, inc):
pattern = "trained_SVM_rbf_gamma_" + str(i) + "_*"
for entry in list_of_files:
if fnmatch.fnmatch(entry, pattern) and entry.find('C') == -1:
x = input(entry)
trained_files.append(entry)
break
load_results = loadFile("results.pkg")
results = load_results['results']
gamma_data = load_results['gamma_data']
for i in trained_files:
load_svm = loadFile(i)
if (load_svm['gamma'] not in gamma_data):
temp_feat_dict = copy.deepcopy(feat_dict)
result = validate(load_svm, temp_feat_dict)
results.append(result)
gamma_data.append(load_svm['gamma'])
else:
print("Skipping")
save_data = {
'feat_obj': feat_obj,
'results': results,
'gamma_data': gamma_data
}
pickle.dump(save_data, open("results.pkg", 'wb'))
elif (str2bool(args.Append) == False and str2bool(args.C) == False):
pattern = "trained_SVM_rbf_gamma_*"
for entry in list_of_files:
if fnmatch.fnmatch(entry, pattern) and entry.find('C') == -1:
trained_files.append(entry)
# Going through all the trained files and analyzing its performance
results = []
gamma_data = []
for i in trained_files:
load_svm = loadFile(i)
temp_feat_dict = copy.deepcopy(feat_dict)
result = validate(load_svm, temp_feat_dict)
results.append(result)
gamma_data.append(load_svm['gamma'])
#if (str2bool(args.Plot) == True):
# plotResults(data_downsampled, result, label_downsampled, load_data['gamma'], load_data['method'])
save_data = {
'feat_obj': feat_obj,
'results': results,
'gamma_data': gamma_data
}
pickle.dump(save_data, open("results.pkg", 'wb'))
else:
print("Calculating C")
pattern = "trained_SVM_rbf_gamma_*"
for entry in list_of_files:
if fnmatch.fnmatch(entry, pattern) and entry.find('C') != -1:
trained_files.append(entry)
x = input(trained_files)
results = []
C_data = []
gamma_data = []
for i in trained_files:
load_svm = loadFile(i)
print(load_svm['gamma'])
temp_feat_dict = copy.deepcopy(feat_dict)
result = validate(load_svm, temp_feat_dict)
results.append(result)
C_data.append(load_svm['C'])
gamma_data.append(load_svm['gamma'])
#if (str2bool(args.Plot) == True):
# plotResults(data_downsampled, result, label_downsampled, load_data['gamma'], load_data['method'])
save_data = {
'feat_obj': feat_obj,
'results': results,
'gamma_data': gamma_data,
'C_data': C_data
}
pickle.dump(save_data, open("results_C.pkg", 'wb'))
import Generation as G gen = G.Generation()
def __init__(self, island, pos):
self.entities = []
self.island = island
self.pos = pos
self.discovered = False
self.visited = False
self.type = RoomType.NORMAL
# Get background textures
self.map = Parser.main(pos, self.island.width, self.island.length)
self.tileLib = Parser.tileDict()
self.tiles = []
self.drawX = 0
self.drawY = 0
# Get room contents
self.layout = Parser.getLayout(self.type)
self.layoutLib = Parser.getLayoutLib()
# Data from generation
self.neighbors = dict()
self.gen_Object = Generation.Generation().Room()
# Apply background textures
self.bg = pygame.Surface(
pygame.math.Vector2(Constants.ROOM_SIZE * Constants.TILE_SIZE,
Constants.ROOM_SIZE * Constants.TILE_SIZE))
for element in self.map:
self.tilesRow = []
for unit in element:
tilename = self.tileLib[unit].replace('"', '')
tilename = random.choice(tilename.split('&'))
self.image = Drawing.Sprite(
pygame.image.load(tilename).convert_alpha())
self.image.scale = pygame.math.Vector2(
64 / self.image.tex.get_width(),
64 / self.image.tex.get_height())
self.tilesRow.append(self.image)
self.tiles.append(self.tilesRow)
for element in self.tiles:
for unit in element:
unit.pos = pygame.math.Vector2(self.drawX, self.drawY)
unit.draw(self.bg)
self.drawX += 64
self.drawY += 64
self.drawX = 0
# Apply room contents
self.drawX = 0
self.drawY = 0
for row in self.layout:
for element in row:
if element in self.layoutLib:
obj = 0
if element is "h":
obj = Characters.HornetEnemy(self)
elif element is "s":
obj = Characters.SnakeEnemy(self)
obj.pos = pygame.math.Vector2(self.drawX, self.drawY)
self.entities.append(obj)
self.drawX += 64
self.drawY += 64
self.drawX = 0
def initialize_first_generation(self):
self.generation = Generation(0)
def generate_sudoku(difficulty):
return remove_numbers(Generation.make_full_grid(3), difficulty)
#1 - 3 - 6 - 7 sont ok
# NOK : 2 - 4 - 5
from Generation import *
fichier = open("passtext.txt", "r", encoding="UTF-8")
nbligne = 0
while fichier.readline(): #on compte nmobre de ligne du fichier d mot de passe
nbligne += 1
fichier.close()
fichier = open("passtext.txt", "r", encoding="UTF-8")
for i in range(0, nbligne): #on teste tout les mots de passe sur le choix 3
mdp = fichier.readline().rstrip().split(':')
motdepasse = Generation(mdp[1], mdp[0]) #création de l'objet
print(mdp[0] + " : ") # 1 2 3 6 7 OK
print("1. " + str(motdepasse.choix1()))
print("2. " + str(motdepasse.choix2()))
print("3. " + str(motdepasse.choix3()))
print("4. " + str(motdepasse.choix4()))
print("5. " + str(motdepasse.choix5()))
print("6. " + str(motdepasse.choix6()))
print("7. " + str(motdepasse.choix7()))
print()
fichier.close()
def test05Ordering(self):
self.makeDir("g0001", with_pkl=1)
self.makeDir("g0002", with_pkl=1)
gen_id = Generation.getLatestGenerationID(self.dir)
self.failUnless(gen_id == 2, "Generation found was not the latest: %s" % (gen_id))
def test03FalseGenerations(self):
self.makeFile("galileo")
gen_id = Generation.getLatestGenerationID(self.dir)
self.failUnlessEqual(gen_id, None, "Directory with false Generation did not return None")
def test01EmptyDir(self):
gen_id = Generation.getLatestGenerationID(self.dir)
self.failUnlessEqual(gen_id, None, "Empty directory did not return None")
ftime = timel / 100.0
return ftime
def solve_timing(glist):
timel = 0.0
for x in glist:
start = time.time()
Solving.solve_grid(x)
end = time.time()
timel = timel + (end - start)
ftime = timel / 100.0
return ftime
def constraint_solve_timing(glist):
timel = 0.0
for x in glist:
start = time.time()
SolveConstraintPropagation.constraint_solve(x)
end = time.time()
timel = timel + (end - start)
ftime = timel / 100.0
return ftime
grids = [Generation.make_full_grid(3) for x in range(0, 500)]
print("Remove time: " + str(remove_timing(copy.deepcopy(grids))))
print("RecursiveRemove time: " + str(rec_remove_timing(copy.deepcopy(grids))))
print("Solving time: " + str(solve_timing(copy.deepcopy(grids))))
print("SolveConstraintPropagation: " + str(constraint_solve_timing(copy.deepcopy(grids))))
def search(self):
# self.res["text"]=(str(self.choix.get()))+" - "+str(self.entryNb.get())
g = Generation(self.Imdp.get(),self.Ilogin.get())
a=self.choix.get()
rep=0
if a==0:
print("Choisissez une option")
elif a==1:
rep=g.choix1()
elif a==2:
rep=g.choix2()
elif a==3:
rep=g.choix3()
elif a==4:
rep=g.choix4()
elif a==5:
rep=g.choix5()
elif a==6:
rep=g.choix6()
elif a==7:
rep=g.choix7()
elif a==9:
if g.choix1()!=0:
rep=g.choix1()
elif g.choix2()!=0:
rep=g.choix2()
elif g.choix3()!=0:
rep=g.choix3()
elif g.choix4()!=0:
rep=g.choix4()
elif g.choix5()!=0:
rep=g.choix5()
elif g.choix6()!=0:
rep=g.choix6()
elif g.choix7()!=0:
rep=g.choix7()
if rep==0:
self.res["text"] = "Décryptage impossible"
else:
self.res["text"]=rep
def test02NoGenerations(self):
self.makeFile("foo.txt")
gen_id = Generation.getLatestGenerationID(self.dir)
self.failUnlessEqual(gen_id, None, "Directory with no Generations did not return None")
def recherche(self):
value = self.CheckVar.get()
mdp_clear = ""
if value == 1:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix1()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 2:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix2()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 3:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix3()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 4:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix4()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 5:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix5()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 6:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix6()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 7:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix7()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 8:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix8()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
def test04FailedDir(self):
self.makeDir("g0001")
gen_id = Generation.getLatestGenerationID(self.dir)
self.failUnlessEqual(gen_id, None, "Directory with failed Generation did not return None")
#model = NeuralNetwork(dimensions = [5, 3, 1], activation_hidden = 'relu')
#print('weights : ', model.getModel().get_weights())
### Set parameters ###
num_episodes = 1
num_individuals = 20
dimensions = [2, 1]
activation_hidden = 'relu'
activation_output = 'sigmoid'
num_timesteps = 400
num_generations = 5
######################
gen = Generation(num_individuals=num_individuals,
dimensions=dimensions,
activation_hidden=activation_hidden,
activation_output=activation_output)
#print(gen)
avg_fitness_history = []
for gen_num in range(num_generations):
print('Generation ', gen_num)
# Loop over the individuals in the population in one generation
for individual in gen.get_population():
observation = env.reset()
fitness = 0
# Loop over the number of time steps
def test06Fallback(self):
self.makeDir("g0001", with_pkl=1)
self.makeDir("g0002")
gen_id = Generation.getLatestGenerationID(self.dir)
self.failUnless(gen_id == 1, "Generation found was not the latest successfull one: %s" % (gen_id))
def startrun():
""" Start the simulation
"""
# catch errors
try:
time1 = time.time()
inframe.reset()
# set grid size, get the values from the entry boxes
# reset the checkboxes
rows = int(inframe.rows())
cols = int(inframe.columns())
empty = float(inframe.empty())
lions = float(inframe.lions())
antelopes = float(inframe.antelopes())
grid = cagrid(rows, cols, empty, lions, antelopes, False)
# enter how many generations it should run, if nothing is entered
# gen stays -1 and the generations loop runs indefinately
gen = -1
run = inframe.generations()
if run:
gen = int(run)
# print the initial grid
PrintGrid(grid)
# record the initial grid
firstRecording(grid)
# run the generation
stop = 0
ext = False
# the generation runs until "gen" or indefinately
# and while the user has not pressed stop
while stop!=gen and not ext:
grid = Generation.run(grid, inframe.features(), inframe.recording())
# the canvas is only changed after a period of time
anigrid.after(100, PrintGrid(grid))
# increment the loop counter
stop+=1
# check whether the stop button has been pressed
ext = inframe.interrupt()
finished(grid)
time2 = time.time()
print (time2-time1)
# display an error message box
except ValueError:
tkMessageBox.showerror(title = "Error",
message = "Please enter only numbers")
except IndexError:
tkMessageBox.showerror(title = "Error",
message = "Please enter positive numbers")
except TclError:
pass
except Exception, e:
print e
tkMessageBox.showerror(title = "Error",
message = "Unknown error:\nPlease try again")
def initializeFirstGeneration(self):
self.generation = Generation(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--Normalize', '-n', type=str, default='MeanStd')
parser.add_argument('--Kernel', '-k', type=str, default='rbf')
parser.add_argument('--Start', '-s', type=int, default=1)
parser.add_argument('--End', '-e', type=int, default=5)
# This flag determines whether or not multiple trainings will be performed for the
# cross validation
parser.add_argument('--CrossValid', '-c', type=bool, default=False)
parser.add_argument('--GammaMin', type=float, default=0.0)
parser.add_argument('--GammaMax', type=float, default=10)
parser.add_argument('--Increment', type=float, default=1.0)
args = parser.parse_args()
# Uploading data from a measurement text file
meas_obj = mm.Measurement("Study_005_channel1.pkg", args.Start, args.End)
meas_obj.downsample(2)
# Calculating all the relevant features using information encompassing all the other
# features
feat_obj = fe.Feature(meas_obj)
feat_label_dict = g.getFeaturesAndLabel(meas_obj, feat_obj)
feat_dict = dict(
(k, feat_label_dict[k]) for k in feat_key if k in feat_label_dict)
label_downsampled = feat_label_dict['label']
# Good practice to check that the correct keys are generated for their value
if (g.checkDictForFeat(feat_dict) == False):
assert (False)
# Storing the temporary means and standard deviations of the features before it is normalized
# since a dictionary is mutable
'''
tempMean = np.asarray([])
tempStd = np.asarray([])
for i in feat_key:
tempMean = np.append(tempMean, np.mean(feat_dict[i]))
tempStd = np.append(tempStd, np.std(feat_dict[i]))
'''
tempMean = {}
tempStd = {}
for i in feat_key:
tempMean[i] = np.mean(feat_dict[i])
tempStd[i] = np.std(feat_dict[i])
if (args.Normalize == "MeanStd"):
g.normFeature(feat_dict, args.Normalize, tempMean, tempStd)
elif (args.Normalize == "MinMax"):
g.normFeature(feat_dict, args.Normalize)
else:
assert (False)
feat_array = g.convertDictToFeatArray(feat_dict)
if (args.CrossValid == True):
for i in np.arange(args.GammaMin, args.GammaMax, args.Increment):
print("Training test set using " + str(i) + " for gamma")
c = train(feat_array, label_downsampled, args.Kernel, i)
saveSVM(c, tempMean, tempStd, args.Normalize, args.Kernel, i)
else:
print("Using default Gamma value")
c = train(feat_array, label_downsampled, args.Kernel)
saveSVM(c, tempMean, tempStd, args.Normalize, args.Kernel)
def generation(island):
width = random.randint(3, 7)
length = random.randint(3, 7)
# implementing Generation.py
gen = Generation.Generation(width, length)
gen.make()
while not gen.isComplete():
del gen
print("Generation failed, remaking...")
gen = Generation.Generation(width, length)
gen.make()
gen.printRooms()
island.width = width
island.length = length
# Start creation
x, y = 0, 0
shop_exists = False
# Loop for each room on Generated island
for row in gen.rows:
for room in row:
if room.iter_num is 6 and not shop_exists:
room_shop = GameBase.Room(island, pygame.math.Vector2(y, x))
room_shop.neighbors = room.neighbors
room_shop.gen_Object = room
shop_exists = True
# print ("shop at " + str(y) + ", " + str(x))
elif room.iter_num is 1:
room_pickups = GameBase.Room(island, pygame.math.Vector2(y, x))
room_pickups.neighbors = room.neighbors
room_pickups.gen_Object = room
# print ("start at " + str(y) + ", " + str(x))
else:
empty_room = GameBase.Room(island, pygame.math.Vector2(y, x))
empty_room.neighbors = room.neighbors
empty_room.gen_Object = room
# print ("empty at " + str(y) + ", " + str(x))
island.rooms.append(empty_room)
y += 1
x += 1
y = 0
# boss room
b = Characters.WizardEnemy(island.rooms[(len(island.rooms) - 1)])
b.teleport()
island.rooms[(len(island.rooms) - 1)].entities.append(b)
island.rooms[(len(island.rooms) - 1)].type = GameBase.RoomType.BOSS
# starting room
island.start_room = island.rooms[0]
ship = Entities.ExitShip(island.start_room)
ship.pos = pygame.math.Vector2(64 * 5, 64 * 5)
island.start_room.entities.append(ship)
island.start_room.type = GameBase.RoomType.EXIT
# pickups room
# places stuff in room_pickups
# for i in range(1, 5):
# heart = Entities.HealthPickup(room_pickups, i)
# heart.pos = pygame.math.Vector2(64 + 48 * i, 96) # location of hearts on screen
# room_pickups.entities.append(heart)
# for i in range(0, 10):
# g = pow(2, i)
# gold = Entities.GoldPickup(room_pickups, g)
# gold.pos = pygame.math.Vector2(Constants.ROOM_SIZE * Constants.TILE_SIZE - 96, 64 + 48 * i) # location of gold on screen
# room_pickups.entities.append(gold)
item = Entities.ItemPickup(room_pickups, Items.DummyItem())
item.pos = pygame.math.Vector2(100, 200)
room_pickups.entities.append(item)
island.rooms.append(room_pickups)
# shop room
# places stuff in room_shop
room_shop.type = GameBase.RoomType.SHOP
shopkeeper = Characters.Shopkeeper(room_shop)
shopkeeper.pos = pygame.math.Vector2(
Constants.ROOM_SIZE * Constants.TILE_SIZE / 2 - 16,
Constants.ROOM_SIZE * Constants.TILE_SIZE / 2 - 96)
room_shop.entities.append(shopkeeper)
pedestal_count = random.randint(1, 4)
for i in range(pedestal_count):
x = Constants.ROOM_SIZE * Constants.TILE_SIZE / (pedestal_count +
1) * (i + 1)
y = shopkeeper.pos.y + 160
make_store_pedestal(room_shop, pygame.math.Vector2(x, y))
island.rooms.append(room_shop)
# island.rooms.append(room_creation)
# Wall placement
for room in island.rooms:
keys = list(room.neighbors.keys())
factor = 64 # rooms are (9 * 64) x (9 * 64) pixels
# if no North exit
if 1 not in keys:
# if not Northernmost row
if (room.pos.y != 0):
# if Westernmost column
if (room.pos.x == 0):
for i in range(1, 9):
addWall(room, factor * i, 0)
# if Easternmost column
elif (room.pos.x == (width - 1)):
for i in range(8):
addWall(room, factor * i, 0)
# make as usual
else:
for i in range(9):
addWall(room, factor * i, 0)
else:
for i in range(9):
addBound(room, factor * i, 0)
else:
# if not Northernmost row
if (room.pos.y != 0):
# if not Westernmost column
if (room.pos.x != 0):
addWall(room, 0, 0)
# if not Easternmost column
if (room.pos.x != (length - 1)):
addWall(room, factor * 8, 0)
# if no East exit
if 2 not in keys:
# if not Easternmost column
if (room.pos.x != (length - 1)):
# if Northernmost row
if (room.pos.y == 0):
for i in range(1, 9):
addWall(room, factor * 8, factor * i)
# if Southernmost row
elif (room.pos.y == (width - 1)):
for i in range(8):
addWall(room, factor * 8, factor * i)
# make as usual
else:
for i in range(9):
addWall(room, factor * 8, factor * i)
else:
for i in range(9):
addBound(room, factor * 8, factor * i)
else:
# if not Easternmost column
if (room.pos.x != (length - 1)):
# if not Northernmost row
if (room.pos.y != 0):
addWall(room, factor * 8, 0)
# if not Southernmost row
if (room.pos.y != (width - 1)):
addWall(room, factor * 8, factor * 8)
# if no South exit
if 3 not in keys:
# if not Southernmost row
if (room.pos.y != (width - 1)):
# if Easternmost column
if (room.pos.x == 0):
for i in range(1, 9):
addWall(room, factor * i, factor * 8)
# if Westernmost column
elif (room.pos.x == (length - 1)):
for i in range(8):
addWall(room, factor * i, factor * 8)
# draw wall as usual
else:
for i in range(9):
addWall(room, factor * i, factor * 8)
else:
for i in range(9):
addBound(room, factor * i, factor * 8)
else:
# if not Southernmost row
if (room.pos.y != (width - 1)):
# if not Easternmost column
if (room.pos.x != 0):
addWall(room, 0, factor * 8)
# if not Westernmost column
if (room.pos.x != (length - 1)):
addWall(room, factor * 8, factor * 8)
# if West exit
if 4 not in keys:
# if not Westernmost room
if (room.pos.x != 0):
# if Northernmost room
if (room.pos.y == 0):
for i in range(1, 9):
addWall(room, 0, factor * i)
# if Southernmost room
elif (room.pos.y == (width - 1)):
for i in range(8):
addWall(room, 0, factor * i)
# draw wall as usual
else:
for i in range(9):
addWall(room, 0, factor * i)
else:
for i in range(9):
addBound(room, 0, factor * i)
else:
# if not Westernmost column
if (room.pos.x != 0):
# if not Northernmost row
if (room.pos.y != 0):
addWall(room, 0, 0)
# if not Southernmost row
if (room.pos.y != (width - 1)):
addWall(room, 0, factor * 8)
def generate_sea_test(self):
# implementing Generation.py
gen = Generation.Generation()
gen.make()
while not gen.isComplete():
del gen
print("Generation failed, remaking...")
gen = Generation.Generation()
gen.make()
gen.printRooms()
# island is at (3, 3)
test = Island(pygame.math.Vector2(3, 3), "Test")
self.islands[str(test.pos)] = test
#
# Test island generation
#
x, y = 0, 0
shop_exists = False
# Loop for each room on Generated island
for row in gen.rows:
for room in row:
if room.iter_num is 6 and not shop_exists:
room_shop = GameBase.Room(test, pygame.math.Vector2(y, x))
room_shop.neighbors = room.neighbors
room_shop.gen_Object = room
shop_exists = True
# print ("shop at " + str(y) + ", " + str(x))
elif room.iter_num is 1:
room_pickups = GameBase.Room(test,
pygame.math.Vector2(y, x))
room_pickups.neighbors = room.neighbors
room_pickups.gen_Object = room
# print ("start at " + str(y) + ", " + str(x))
elif room.iter_num is 2:
room_creation = GameBase.Room(test,
pygame.math.Vector2(y, x))
room_creation.neighbors = room.neighbors
room_creation.gen_Object = room
elif room.iter_num is 3:
room_enemies = GameBase.Room(test,
pygame.math.Vector2(y, x))
room_enemies.neighbors = room.neighbors
room_enemies.gen_Object = room
elif room.iter_num is 4:
room_boss = GameBase.Room(test, pygame.math.Vector2(y, x))
room_boss.neighbors = room.neighbors
room_boss.gen_Object = room
else:
empty_room = GameBase.Room(test, pygame.math.Vector2(y, x))
empty_room.neighbors = room.neighbors
empty_room.gen_Object = room
# print ("empty at " + str(y) + ", " + str(x))
test.rooms.append(empty_room)
y += 1
x += 1
y = 0
# pickups room
# places stuff in room_pickups
ship = Entities.ExitShip(room_pickups)
ship.pos = pygame.math.Vector2(
Constants.TILE_SIZE * Constants.ROOM_SIZE / 2,
Constants.TILE_SIZE * Constants.ROOM_SIZE / 2)
room_pickups.entities.append(ship)
room_pickups.type = GameBase.RoomType.EXIT
for i in range(1, 5):
heart = Entities.HealthPickup(room_pickups, i)
heart.pos = pygame.math.Vector2(64 + 48 * i,
96) # location of hearts on screen
room_pickups.entities.append(heart)
for i in range(1, 7):
enemie = Characters.SnakeEnemy(room_enemies)
enemie.pos = pygame.math.Vector2(
64 + 48 * i, 112) # places the location of the enemie
room_enemies.entities.append(enemie)
for i in range(1, 4):
enemie = Characters.HornetEnemy(room_enemies)
enemie.pos = pygame.math.Vector2(
80 + 120 * i, 112) # places the location of the enemie
room_enemies.entities.append(enemie)
for i in range(0, 10):
g = pow(2, i)
gold = Entities.GoldPickup(room_pickups, g)
gold.pos = pygame.math.Vector2(
Constants.ROOM_SIZE * Constants.TILE_SIZE - 96,
64 + 48 * i) # location of gold on screen
room_pickups.entities.append(gold)
item = Entities.ItemPickup(room_pickups,
Items.BasicMeleeItem("sword", 2))
item.pos = pygame.math.Vector2(100, 200)
room_pickups.entities.append(item)
item3 = Entities.ItemPickup(room_pickups,
Items.BasicMeleeItem("cutlass", 3))
item3.pos = pygame.math.Vector2(300, 200)
room_pickups.entities.append(item3)
item2 = Entities.ItemPickup(room_pickups, Items.BowItem())
item2.pos = pygame.math.Vector2(200, 200)
room_pickups.entities.append(item2)
test.rooms.append(room_enemies)
test.rooms.append(room_pickups)
test.start_room = room_pickups
# boss room
b = Characters.WizardEnemy(room_boss)
b.teleport()
room_boss.entities.append(b)
test.rooms.append(room_boss)
room_boss.type = GameBase.RoomType.BOSS
# shop room
# places stuff in room_shop
room_shop.type = GameBase.RoomType.SHOP
shopkeeper = Characters.Shopkeeper(room_shop)
shopkeeper.pos = pygame.math.Vector2(100, 300)
room_shop.entities.append(shopkeeper)
pedestal = Entities.ShopPedestal(
room_shop, Entities.ItemPickup(room_shop, Items.DummyItem()), 30)
pedestal.pos = pygame.math.Vector2(108, 375)
room_shop.entities.append(pedestal)
test.rooms.append(room_shop)
test.rooms.append(room_creation)
for room in test.rooms:
keys = list(room.neighbors.keys())
factor = 64
# if North exit
if 1 in keys:
thingy = Entities.HealthPickup(room, 1)
# thingy.pos = pygame.math.Vector2(factor * 4, factor * 2)
# room.entities.append(thingy)
else:
if (room.pos.y != 0):
for i in range(9):
wall = Entities.Terrain(room)
wall.pos = pygame.math.Vector2(factor * i, 0)
room.entities.append(wall)
# if East exit
if 2 in keys:
thingy = Entities.HealthPickup(room, 2)
# thingy.pos = pygame.math.Vector2(factor * 7, factor * 4)
# room.entities.append(thingy)
else:
if (room.pos.x != 2):
for i in range(9):
wall = Entities.Terrain(room)
wall.pos = pygame.math.Vector2(factor * 8, factor * i)
room.entities.append(wall)
# if South exit
if 3 in keys:
thingy = Entities.HealthPickup(room, 3)
# thingy.pos = pygame.math.Vector2(factor * 4, factor * 7)
# room.entities.append(thingy)
else:
if (room.pos.y != 2):
for i in range(9):
wall = Entities.Terrain(room)
wall.pos = pygame.math.Vector2(factor * i, factor * 8)
room.entities.append(wall)
# if West exit
if 4 in keys:
thingy = Entities.HealthPickup(room, 4)
# thingy.pos = pygame.math.Vector2(factor * i, factor * 4)
# room.entities.append(thingy)
else:
if (room.pos.x != 0):
for i in range(9):
wall = Entities.Terrain(room)
wall.pos = pygame.math.Vector2(0, factor * i)
room.entities.append(wall)
from pprint import pprint
from Pokedex import *
from Generation import *
json_data = open('pokemon-list.json')
data = json.load(json_data)
listdata = data["list"]
json_data.close()
Pokedex('Kanto', listdata).print_details_to_file()
Pokedex('Johto', listdata).print_details_to_file()
Pokedex('Hoenn', listdata).print_details_to_file()
Pokedex('Sinnoh', listdata).print_details_to_file()
Pokedex('Unova', listdata).print_details_to_file()
Pokedex('New Unova', listdata).print_details_to_file()
Pokedex('Central Kalos', listdata).print_details_to_file()
Pokedex('Coastal Kalos', listdata).print_details_to_file()
Pokedex('Mountain Kalos', listdata).print_details_to_file()
Pokedex('Alola', listdata).print_details_to_file()
Pokedex('Melemele Alola', listdata).print_details_to_file()
Pokedex('Akala Alola', listdata).print_details_to_file()
Pokedex('Ulaula Alola', listdata).print_details_to_file()
Pokedex('Poni Alola', listdata).print_details_to_file()
for i in range(1, 8):
Generation(i, listdata).print_details_to_file()
def rec_generate_sudoku(difficulty):
grid = Generation.make_full_grid(3)
additions = random.randint(min_remove(difficulty), max_remove(difficulty))
return rec_remove_numbers(grid, additions, 0, lowerbound(difficulty), [x for x in range(0, 9)], [x for x in range(0, 9)], [])