def goThread(self):
# get params
filename = self.getTraincomboBox.currentText()
num_iter, num_neuron = self.iterTimesSpinBox.value(
), self.num_nSpinBox.value()
population = self.populationSpinBox.value()
p_c = self.p_cdoubleSpinBox.value()
p_m = self.p_mDoubleSpinBox.value()
self.errorNumLabel.setText('Inf')
# print(filename, num_iter, num_neuron, population, p_c, p_m)
# ga
self.stop_threads = False
self.g = ga.GA(num_iter, population, p_m, p_c, num_neuron, filename,
self.wheel.isChecked())
for i in range(num_iter):
if self.stop_threads:
break
self.IterNumLabel.setText(str(i + 1))
self.g.evolution()
if self.g.BestRBFN:
self.errorNumLabel.setText('{:2.2f}'.format(
self.g.BestRBFN.error))
QtWidgets.QApplication.processEvents()
# print(self.g.BestRBFN.mu)
self.g.BestRBFN.saveParams()
# reset getParamcomboBox
self.getParamcomboBox.clear()
comboList = os.listdir(parent + '/weights/')
self.getParamcomboBox.addItems(comboList)
self.Go.setEnabled(True)
def main():
while True:
file = createdata.choose_file(os.getcwd() + '\\instances')
# file = ''.join((os.getcwd(), '\\instances\\bier127.txt'))
if createdata.check_file(file):
matrix = createdata.create_matrix(file)
break
else:
print("Choose another file or use a generator.")
pygame.init()
pygame.display.set_caption("TSP Genetic Algorithm")
clock = pygame.time.Clock()
font = pygame.font.SysFont('Calibri', 25)
run = True
win = pygame.display.set_mode((WIDTH, HEIGHT))
colour = (127, 0, 127)
# start_time = time.time()
genetic = ga.GA(matrix)
genetic.create_first_generation()
elements = create_list(file)
max_x, max_y = calculate_scale(elements)
elements = refactor_lis(elements, max_x, max_y)
while run:
win.fill((0, 0, 0))
clock.tick(30)
for click in pygame.event.get():
if click.type == pygame.QUIT:
run = False
# draw points on the surface
for x, y in elements:
pygame.draw.circle(win, colour, (x, y), 5)
# get and draw the currently shortest route
route = genetic.run()
for i in range(len(route)):
pygame.draw.line(win, colour,
(elements[route[i]][0], elements[route[i]][1]),
(elements[route[(i + 1) % (len(route))]][0],
elements[route[(i + 1) % (len(route))]][1]))
# print information about algorithm results
num_gen_txt = font.render(
'Number of generation: ' + str(genetic.number_of_generation),
False, colour)
route_len_txt = font.render(
'Length of the shortest route: ' + str(genetic.shortest_distance),
False, colour)
win.blit(num_gen_txt, (0, 0))
win.blit(route_len_txt, (0, 30))
pygame.display.update()
pygame.quit()
def main():
#If user wanted to specify own parameters retrieve them from command line
if len(sys.argv) == 6:
networkType = sys.argv[1]
numIterations = int(sys.argv[2])
populationSize = int(sys.argv[3])
selection = sys.argv[4]
crossover = sys.argv[5]
crossoverProb = float(sys.argv[6])
mutationProb = float(sys.argv[7])
#If not specifed then these are default parameters
else:
networkType = "cnn"
numIterations = 1
populationSize = 2
selection = "rs"
crossover = "uc"
crossoverProb = 0.8
mutationProb = 0.2
#Will define the choice of parameters for neral network
if (networkType == "nn"):
#Dictionary of parameters
nnParams = {
"epochs": [10],
"learningRate": [1, 0.5, 0.1],
"hiddenInfo": [[], [300], [150, 100]],
"startWeights": [0, 1, 0.15, 0.2, 0.25],
}
#Will define the choice of parameters for convolutional neural network
else:
#Dictionary of possible paramaters
nnParams = {
"epochs": [1],
"dropout": [True, False],
"batch_size": [32],
"optimizer": ['sgd', 'rmsprop', 'adam'],
"data_augmentation": [False],
"convActivation": ['relu', 'elu', 'sigmoid'],
"denseActivation": ['softmax', 'tanh', 'sigmoid']
}
#Run the ga algorithm to find optimal set of parameters
geneticAlg = ga.GA(networkType, numIterations, populationSize, selection,
crossover, crossoverProb, mutationProb, nnParams)
geneticAlg.runGA()
def run_experiment(id_: int):
# Starting genetic algorithm
gene_pool = ga.GA(popu_size=settings['experiment']['population'],
n_survivors=settings['experiment']['survivors'],
n_champions=settings['experiment']['champions'])
for i in range(settings['experiment']['generations']):
worker_async_results = [
rq_worker.run.delay(seeds) for seeds in gene_pool.genomes
]
scores = wait_for_results(worker_async_results)
survivors_scores, survivors_genomes = gene_pool.step(scores)
np.savez("out_" + str(id_) + "/" + str(i) + ".npz",
scores=survivors_scores,
genomes=survivors_genomes)
print("=== ID", id_, "Generation", i, "===\n", "Best scores:",
list(reversed(survivors_scores)), "\n")
import ga engine = ga.GA(items_cnt=1) # размеры картинок objs = [[60, 30], [50, 70], [30, 20], [40, 20], [30, 20], [20, 40]] engine.initialisation(objs)
def debug(func, *args):
if DEBUG:
func(*args)
measurement_id = 17
db = dbm.DBExporter(dbtype='sqlite', dbname='vut_db.sqlite')
measured_data = db.columns_from_datatable(measurement_id)
#
# tenzometric = pd.read_csv('data/44 t.asc', sep='\t', header=0, skiprows=[1])
# t1 = tenzometric['T1']
# t2 = tenzometric['T2']
# t_avg = (t1 + t2) / 2 + 63
#
# measured_data = pd.DataFrame(zip(tenzometric['x'], -t_avg), columns=['x_axis', 'y_axis'])
# print(measured_data)
# model = models.Model('dynamic_single_winkler')
# model = models.Model('dynamic_single_winkler')
model = models.Model('dynamic_double_pasternak', False)
for i in range(20):
gen_algs = ga.GA(model, measured_data, 500, 20)
gen_algs.run_optimization(i)
end = time.time()
print(f'Time: {int(end - start)}')
def main():
# argument parsing
parser = argparse.ArgumentParser()
parser.add_argument('data',
type=str,
default="rl11849.tsp",
help="Data file name ex)rl11849.tsp")
parser.add_argument('-p', type=int, default=200, help="Population size")
parser.add_argument('-f',
type=int,
default=250,
help="Total number of fitness evaluations")
parser.add_argument('-e',
type=int,
default=50,
help="The size of the elite population")
parser.add_argument('-m',
type=float,
default=0.01,
help="Probability of the mutation")
parser.add_argument('-plot',
type=str,
default='n',
choices=['n', 'y'],
help="Plot the distance-generation graph (y)es/(n)o")
args = parser.parse_args()
data_name = args.data
pop_size = args.p
generations = args.f
elite_size = args.e
mutation_rate = args.m
is_plot = args.plot
city_list = tsp_parser.parser(data_name)
print("data: " + data_name)
print("population size: " + str(pop_size))
print("total generations: " + str(generations))
print("elite size: " + str(elite_size))
print("mutation_rate: " + str(mutation_rate))
# declare model
model = ga.GA(cityList=city_list,
popSize=pop_size,
eliteSize=elite_size,
mutationRate=mutation_rate,
generations=generations)
progress = []
progress.append(1 / model.rank_routes(model.population)[0][1])
for i in tqdm(range(0, model.generations), desc="Evolving now..."):
model.nextGeneration()
progress.append(1 / model.rank_routes(model.population)[0][1])
best_route = model.population[model.rank_routes(model.population)[0][0]]
print("Final distance: " +
str(1 / model.rank_routes(model.population)[0][1]))
# plot the progress graph if argument plot is 'y'
if is_plot == "y":
plt.plot(progress)
plt.ylabel('Distance')
plt.xlabel('Generation')
plt.show()
# write solution file with best_route
f = open('solution.csv', 'w', newline='')
wr = csv.writer(f)
for i in range(len(best_route)):
wr.writerow([best_route[i]])
f.close()
import numpy as np
import ga, pdb
from matplotlib import pyplot as plt
func0 = lambda x, y: x + y
func1 = lambda x: np.sin(10 * x) * x + np.cos(2 * x) * x
func2 = lambda x, y: x * np.cos(2 * np.pi * y) + y * np.sin(2 * np.pi * x)
func4 = lambda x, y, z, h: x * np.sin(10 * z) + y * np.cos(
2 * np.pi * x) * np.sin(5 * np.pi * h) - h * np.cos(y * h)
nums1 = [[np.random.rand() * 5] for _ in range(100)]
nums2 = list(zip(np.arange(-4, 4, 0.4), np.arange(-4, 4, 0.4)))
#nums4 = list(zip(np.arange(-5, 5, 0.5), np.arange(-5, 5, 0.5), np.arange(-5, 5, 0.5), np.arange(-5, 5, 0.5)))
nums4 = ((np.random.rand(500, 4) - 0.5) * 10).tolist()
bound1 = [(0, 5)]
bound2 = [(-4, 4), (-4, 4)]
bound4 = [(-5, 5), (-5, 5), (-5, 5), (-5, 5)]
#pdb.set_trace()
ga = ga.GA(nums4, bound4, func4, DNA_SIZE=30, cross_rate=0.8, mutation=0.005)
iter_time = 200
ga.plot_in_jupyter_1d(iter_time)
plt.plot(ga.best_fit)
plt.xlabel("Iteration")
plt.ylabel("Fitness")
plt.savefig('result.png')
plt.show()
file_path = os.path.join(dir_name, filename)
try:
shutil.rmtree(file_path)
except OSError:
os.remove(file_path)
remove_folder_content('log')
remove_folder_content('plots')
# pd.set_option('display.max_columns', None)
tenzometric = pd.read_csv('data/44t.asc', sep='\t', header=0, skiprows=[1])
t1 = tenzometric['T1']
t2 = tenzometric['T2']
epsilon = ((t1 + t2) + 125) / 1000000
E = 210e9
W = 330e-6
M = E * W * epsilon
measured_data = pd.DataFrame(zip(tenzometric['x'], -M), columns=['x_axis', 'y_axis'])
man = dtm.Manipulator(measured_data)
man.get_significant_points()
new_measured_data = man.get_measured_data()
model = models.Model('dynamic_double_pasternak')
gen_algs = ga.GA(model, new_measured_data, 640, 5, man)
gen_algs.run_optimization()
import ga
import population
# Create GA object
g = ga.GA(100, 0.001, 0.95, 2)
# Initialize population
p = g.initPopulation(50)
# Evaluate population
g.evalPopulation(p)
# Keep track of current generation
generation = 1
# Start the evolution loop
#
# Every genetic algorithm problem has different criteria for finishing.
# In this case, we know what a perfect solution looks like (we don't
# always!), so our isTerminationConditionMet method is very
# straightforward: if there's a member of the population whose
# chromosome is all ones, we're done!
while g.isTerminationConditionMet(p) == False:
# Print fittest individual from population
print('Best solution: {}'.format(p.getFittest(0).toString()))
#Apply crossover
p = g.crossoverPopulation(p)
# Apply mutation
p = g.mutatePopulation(p)
def main():
utils.Update_Console()
testGA = ga.GA()
testGA.Evolve()
sheet_name='small_cars_terminal')
Terminal = Structures.Terminal(data_car_terminal)
#print('Возможности филиального транспорта: ', Terminal.terminal_count_car_dct)
count_subblock = len(SUBBLOCK.subblock_index_dct)
count_route_block = len(RB.routeblock_index_dct)
for count_day in range(7, 8):
print(count_day)
alloc = Model.Allocation(
SUBBLOCK.subblock_index_dct, SUBBLOCK.subblock_terminal_dct,
SUBBLOCK.block_subblock_dct, RB.routeblock_index_dct,
RB.routeblock_terminal_dct, RB.routeblock_distance_dct,
RB.routeblock_volume_dct, RB.routeblock_adjacency_matrix,
Terminal.terminal_count_car_dct, count_day)
genetic = ga.GA(count_subblock * count_day, count_route_block)
best_person, best_fitness = genetic.optimize(
alloc.get_fitness_glob, genetic.initial_population)
routeblock_day, routeblock_subblock, block_subblock = alloc.form_shedule(
best_person)
df_new = df.copy()
df_new['day'] = df_new['Route_block'].replace(routeblock_day)
df_new['subblock'] = df_new['Route_block'].replace(routeblock_subblock)
df_new['block'] = df_new['subblock'].replace(block_subblock)
write_result(df_new, 'Количество дней {}'.format(count_day))
alloc.finale_check(best_person)
print()
# Equation inputs.
function_inputs = [4, -2, 3.5, 5, -11, -4.7]
# Equation output.
function_output = 44
sol_per_pop = 8 # Number of solutions in the population.
num_parents_mating = 4 # Number of solutions to be selected as parents in the mating pool.
num_generations = 50 # Number of generations.
# Parameters of the mutation operation.
mutation_percent_genes = 10 # Percentage of genes to mutate.
# Creating an instance of the GA class inside the ga module. Some parameters are initialized within the constructor.
ga_instance = ga.GA(num_generations=num_generations,
sol_per_pop=sol_per_pop,
num_parents_mating=num_parents_mating,
function_inputs=function_inputs,
function_output=function_output,
mutation_percent_genes=10)
# Training the GA to optimize the parameters of the function.
ga_instance.train()
# After the generations complete, some plots are showed that summarize the how the outputs/fitenss values evolve over generations.
ga_instance.plot_result()
# Returning the details of the best solution.
best_solution, best_solution_fitness = ga_instance.best_solution()
print("Parameters of the best solution :", best_solution)
print("Fitness value of the best solution :", best_solution_fitness)
return np.array(cost_avg), np.array(cost_std)
num_trails = 30
N = 50
max_iter = 160
sel_mode = 'TS'
population_size = 800
for sel_mode in ['TS', 'FPS']:
ga_cost = []
aver_cost, aver_runtime, num_succ = [], [], 0
for i in (range(num_trails)):
prob = problem.N_QueenProblem(N)
ga = GA.GA(prob,
max_iter=max_iter,
mut_mode='SWAP',
sel_mode=sel_mode,
population_size=population_size)
ga.loop()
sol, runtime, final_cost, cost_his = ga.result()
aver_runtime.append(runtime)
aver_cost.append(final_cost)
if final_cost == 0:
num_succ += 1
del prob, ga
ga_cost.append(cost_his)
print(' Genetic Algorithm')
print('\tAverage Runtime :', np.average(aver_runtime))
print('\tAverage Number of Attacks :', np.average(aver_cost))
print('\tSuccess Rate :', num_succ / num_trails)
# numero de geracoes
ngen = 200
# probabilidade de difusao
p = 0.01
# probabilidade de mutacao
pm = 0.05
# carregando as sementes
df = pd.read_pickle(seeds_path + name + '.pkl')
# colunas do Dataframe: '0_degree', '1_betweennes', '2_pagerank', '3_closeness', '4_eigenvector', '5_pca', 'random'
seeds = list(df['0_degree'][:genes])
ag = ga.GA()
# configurando o AG
ag.properties(g,
seeds,
genes,
population,
random_seeds,
model=model,
selection=selection,
iterations=it,
ngen=ngen,
p=p,
pm=pm)
# executando o AG para um conjunto de sementes
RIGHT = 1
UP = 2
LEFT = 3
pygame.init()
pygame.font.init()
smaller_font = pygame.font.SysFont("Roboto", 45)
width, height = 900, 850
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("2048")
fps = 60
fps_clock = pygame.time.Clock()
running = True
simulating = False
avg, alive = -1, -1
ga = genetic_alg.GA(75 + 1)
speed = 1
amt_to_show = 1
def main():
global running, simulating, avg, alive, width, speed, amt_to_show
while running:
screen.fill((0, 0, 0))
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
total_eval = 0 #总运行次数
def eval_fun(para): #测试评价函数
global total_eval
total_eval += 1
x = para_2_x(para[0])
y = x * math.sin(3 * x) #评价函数本身
return y
population = []
for x in range(15):
t = ga.DNAbase()
population.append(t)
ga = ga.GA(population, 1, eval_fun)
ga.ini()
plt.scatter([para_2_x(x.para[0]) for x in ga.population],
[x.score for x in ga.population],
c=(1, 1, 0),
s=50,
marker='*')
for x in range(7):
#fig=plt.figure()
#plt.subplot(111,axisbg=(0.5,0.5,0.5))
#plt.plot([x/10.0 for x in img_x],img_y,label="$xsin(3x)$",color=(1,0,0),linewidth=1)
#plt.scatter([para_2_x(x.para[0]) for x in ga.population],[x.score for x in ga.population],c=(1,1,0),s=50,marker='*')
ga.run()
print(x, end=' ') #代数
for y in ga.population:
print('%.3f' % y.score, end=',[')
print('Problem (1): 8-queen problem (n = 8)')
print(' Hill Climbing')
print('\tAverage Runtime :', np.average(aver_runtime))
print('\tAverage Number of Attacks :', np.average(aver_cost))
print('\tSuccess Rate :', num_succ / num_trails)
hc_avg, hc_std = statics(hc_cost)
x_range = np.arange(len(hc_avg))
plt.rcParams["figure.figsize"] = [8, 4.5]
plt.plot(x_range, hc_avg, label='Hill Climbing')
plt.fill_between(x_range, hc_avg + hc_std, hc_avg - hc_std, alpha=0.15)
ga_cost = []
aver_cost, aver_runtime, num_succ = [], [], 0
for i in range(num_trails):
prob = problem.N_QueenProblem(8)
ga = GA.GA(prob, max_iter=25)
ga.loop()
sol, runtime, final_cost, cost_his = ga.result()
aver_runtime.append(runtime)
aver_cost.append(final_cost)
if final_cost == 0:
num_succ += 1
del prob, ga
ga_cost.append(cost_his)
print(' Genetic Algorithm')
print('\tAverage Runtime :', np.average(aver_runtime))
print('\tAverage Number of Attacks :', np.average(aver_cost))
print('\tSuccess Rate :', num_succ / num_trails)
ga_avg, ga_std = statics(ga_cost)
x_range = np.arange(len(ga_avg))
# coding: utf-8 import ga def PrintPopulation( D ): print( "Population:" ) i=0 while i<D._pop : print( D.Pop1[i], D.vfobj1[i] ) i += 1 # An instance of GA Data = ga.GA() # Set GA parameters: # 1 population size # 2 number of generations # 3 number of variables # 4 crossover probability # 5 mutation probability # Data.SetParameters( 10, 5, 1, 0.7, 0.1 ) Data.SetParameters( 20, 30, 1, 0.7, 0.1 ) # Args: list with the size in bits for each variable Data.SetSizes( [10] ) # Two lists to set the minimum and maximun values for each # variable Data.SetLimits( [0.0], [7.0] ) Data.Initialize( ) Data.EvaluatePopulation()
parent_selection_type = "tournament" # Type of parent selection.
crossover_type = "two_points" # Type of the crossover operator.
mutation_type = "scramble" # Type of the mutation operator.
keep_parents = 1 # Number of parents to keep in the next population. -1 means keep all parents and 0 means keep nothing.
# Creating an instance of the GA class inside the ga module. Some parameters are initialized within the constructor.
ga_instance = ga.GA(num_generations=num_generations,
sol_per_pop=sol_per_pop,
num_parents_mating=num_parents_mating,
function_inputs=function_inputs,
function_output=function_output,
mutation_percent_genes=mutation_percent_genes,
mutation_num_genes=mutation_num_genes,
parent_selection_type=parent_selection_type,
crossover_type=crossover_type,
mutation_type=mutation_type,
keep_parents=keep_parents,
K_tournament=3)
# Running the GA to optimize the parameters of the function.
ga_instance.run()
# After the generations complete, some plots are showed that summarize the how the outputs/fitenss values evolve over generations.
ga_instance.plot_result()
# Returning the details of the best solution.
best_solution, best_solution_fitness = ga_instance.best_solution()
print("Parameters of the best solution :", best_solution)
