def calculate_and_save_results(inputpath, outputpath):
"""
Docstring
"""
rd.load_data(inputpath)
mass = rd.particle_mass()
x_min = rd.x_minimum()
x_max = rd.x_maximum()
npoint = rd.n_point()
fval = rd.first_eigenvalue()
lval = rd.last_eigenvalue()
inter_type = rd.interpolation_type()
x_pot = rd.x_potential()
y_pot = rd.y_potential()
delta = (x_max-x_min)/npoint
const_a = 1/(mass*delta**2)
x_axis = np.linspace(x_min, x_max, npoint)
#interpolating
y_pot_inter = []
if inter_type == "polynomial":
y_pot_inter = KroghInterpolator(x_pot, y_pot)
else:
y_pot_inter = interp1d(x_pot, y_pot, kind=inter_type)
#calculating
expected_x = np.array([])
uncertainties = np.array([])
energies = np.array([])
norm_eigenvecs = np.array([])
maindiag = y_pot_inter(x_axis)+const_a
seconddiag = np.full(npoint-1, -1/2*const_a)
selectrange = (fval-1, lval-1)
ev = eigh_tridiagonal(maindiag, seconddiag, select="i", select_range=selectrange)
(energies, eigenvecs) = ev
norm_eigenvecs = np.array([normalize(eigenvec, delta) for eigenvec in eigenvecs.T])
expected_x = np.array([exp_x(eigenvec, delta, x_axis) for eigenvec in norm_eigenvecs])
uncertaintylist = [uncertainty(eigenvec, delta, x_axis) for eigenvec in norm_eigenvecs]
uncertainties = np.array(uncertaintylist)
rd.save_xyformat(outputpath + "/potential.dat", x_axis, y_pot_inter(x_axis))
rd.save_nxyformat(outputpath + "/wavefuncs.dat", x_axis, norm_eigenvecs.T)
rd.save_xyformat(outputpath + "/energies.dat", energies, ["" for _ in energies])
rd.save_xyformat(outputpath + "/expvalues.dat", expected_x, uncertainties)
layers = [length, 2 * n_imfs, 3, n_imfs]
elif net_mode == 4:
from htt_coe_cnn_model_new import *
layers = [length, 3, 1, n_imfs]
elif net_mode == 5:
from cnn_kernel_test_model import *
layers = [length, 2 * n_imfs, 3, n_imfs]
#######################################################
for linenum in linenum_all:
print(linenum, " trainging test")
curdir = os.path.abspath(os.curdir)
filename = os.path.join(curdir, './data/' + linenum + writefile + suffix)
data, label, name = load_data(filename, length, kinds, fault_type)
label = label[0::length]
data = np.reshape(data, [-1, length, 3])
#################### whether using HHT and its coe or not ###############
if net_mode == 1:
### data for CNN only
pass
# else:
res = multicore(data, 3, kinds)
res = np.array(res)
print(res.shape)
data2 = np.zeros((kinds, length, n_imfs * 2, 3))
for i in range(kinds):
data2[i, :, :, :] = res[i, :, 2:, :]
for i in range(0, 2):
prob_face[i] = prob_face[i] * prior_prob[i]
return prob_face.index(max(prob_face))
#source_train_images = "D:/project2 AI/facedata/facedatatrain"
#source_train_labels = "D:/project2 AI/facedata/facedatatrainlabels"
#source_test_images = "D:/project2 AI/facedata/facedatatest"
#source_test_labels = "D:/project2 AI/facedata/facedatatestlabels"
source_train_images = "/Users/jainipatel/Downloads/data/facedata/facedatatrain"
source_train_labels = "/Users/jainipatel/Downloads/data/facedata/facedatatrainlabels"
source_test_images = "/Users/jainipatel/Downloads/data/facedata/facedatatest"
source_test_labels = "/Users/jainipatel/Downloads/data/facedata/facedatatestlabels"
fetch_data_train = rd.load_data(source_train_images, 451, 70, 60)
fetch_data_test = rd.load_data(source_test_images, 150, 70, 60)
Y_train_labels = labels = rd.load_label(source_train_labels)
X_train = rd.matrix_transformation(fetch_data_train, 70, 60)
X_test = rd.matrix_transformation(fetch_data_test, 70, 60)
Y_test_labels = rd.load_label(source_test_labels)
tem = 0.99
accuracy_array = []
percent_training = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
total_training_time = 0
start1 = time.time()
for i in range(0, 10):
start = time.time()
tem -= 0.10
def calculate_and_save_results(inputpath, outputpath):
"""
this function does three things:
-interpolating the given points of the potential defined by the user
-solving the schrodinger equation and calculating the eigenstates,
eigenvalues, expected values and uncertainties
-saving the results in .dat files
:type inputpath: string
:param inputpath: path of the schrodinger.inp file containing the input information
:type outputpath: string
:param outputpath: path of the directory the .dat files will be stored in
"""
rd.load_data(inputpath)
mass = rd.particle_mass()
x_min = rd.x_minimum()
x_max = rd.x_maximum()
npoint = rd.n_point()
fval = rd.first_eigenvalue()
lval = rd.last_eigenvalue()
inter_type = rd.interpolation_type()
x_pot = rd.x_potential()
y_pot = rd.y_potential()
delta = (x_max - x_min) / npoint
const_a = 1 / (mass * delta**2)
x_axis = np.linspace(x_min, x_max, npoint)
y_pot_inter = []
expected_x = np.array([])
uncertainties = np.array([])
energies = np.array([])
norm_eigenvecs = np.array([])
#interpolating
if inter_type == "polynomial":
y_pot_inter = KroghInterpolator(x_pot, y_pot)
else:
y_pot_inter = interp1d(x_pot, y_pot, kind=inter_type)
#calculating
maindiag = y_pot_inter(x_axis) + const_a
seconddiag = np.full(npoint - 1, -1 / 2 * const_a)
selectrange = (fval - 1, lval - 1)
ev = eigh_tridiagonal(maindiag,
seconddiag,
select="i",
select_range=selectrange)
(energies, eigenvecs) = ev
norm_eigenvecs = np.array(
[normalize(eigenvec, delta) for eigenvec in eigenvecs.T])
expected_x = np.array(
[exp_x(eigenvec, delta, x_axis) for eigenvec in norm_eigenvecs])
uncertaintylist = [
uncertainty(eigenvec, delta, x_axis) for eigenvec in norm_eigenvecs
]
uncertainties = np.array(uncertaintylist)
#saving
if not outputpath.endswith("/"):
outputpath = outputpath + "/"
rd.save_xyformat(outputpath + "potential.dat", x_axis, y_pot_inter(x_axis))
rd.save_nxyformat(outputpath + "wavefuncs.dat", x_axis, norm_eigenvecs.T)
rd.save_xyformat(outputpath + "energies.dat", energies,
["" for _ in energies])
rd.save_xyformat(outputpath + "expvalues.dat", expected_x, uncertainties)
print("The results have been saved succesfully into the folder \"" +
outputpath + "\".")
layers = [length,2*n_imfs,3, n_imfs]
else:
layers = [length,2*n_imfs,3, n_imfs]
'''
read the filename
'''
for linenum in linenum_all:
print(linenum," trainging test")
curdir = os.path.abspath(os.curdir)
filename = os.path.join(curdir,'./data/'+linenum+writefile+suffix)
X_train, y_train = load_data(filename,length,kinds)
y_train = y_train[0::length]
X_train = np.reshape(X_train,[-1,length,3])
#############shuffle the data #######################################
index = [i for i in range(X_train.shape[0])]
np.random.shuffle(index)
data1 = X_train[index,:,:]
label1 = y_train[index,:]
print (data1.shape)
for snr in SNR:
#####################calculate the noise ########################
print('SNR is '+str(snr))
data_noise = np.zeros([kinds, length, 3])
layers = [length, 2 * n_imfs, 3, n_imfs]
elif net_mode == 4:
from htt_coe_cnn_model import *
layers = [length, 3, 1, n_imfs]
elif net_mode == 5:
from cnn_kernel_test_model import *
layers = [length, 2 * n_imfs, 3, n_imfs]
#######################################################
for linenum in linenum_all:
print(linenum, " trainging test")
curdir = os.path.abspath(os.curdir)
filename = os.path.join(curdir, './data/' + linenum + writefile + suffix)
data, label, name = load_data(filename, length, kinds)
label = label[0::length]
data = np.reshape(data, [-1, length, 3])
#################### whether using HHT and its coe or not ###############
if net_mode == 1:
### data for CNN only
pass
# else:
# res = multicore(data, n_imfs, kinds)
print("HHT process is over")
data2 = np.zeros((kinds, length, n_imfs * 2, 3))
for i in tqdm(range(kinds)):
# data2[i, :, :, :] = res[i]
for i in range(0, 10):
prob_digit[i] = prob_digit[i] * prior_prob[i]
return prob_digit.index(max(prob_digit))
source_train_images = "/Users/jainipatel/Downloads/data/digitdata/trainingimages"
source_train_labels = "/Users/jainipatel/Downloads/data/digitdata/traininglabels"
source_test_images = "/Users/jainipatel/Downloads/data/digitdata/testimages"
source_test_labels = "/Users/jainipatel/Downloads/data/digitdata/testlabels"
# source_train_images = "D:/project2 AI/digitdata/trainingimages"
# source_train_labels = "D:/project2 AI/digitdata/traininglabels"
# source_test_images = "D:/project2 AI/digitdata/testimages"
# source_test_labels = "D:/project2 AI/digitdata/testlabels"
fetch_data_train = rd.load_data(source_train_images, 5000, 28, 28)
fetch_data_test = rd.load_data(source_test_images, 1000, 28, 28)
Y_train_labels = labels = rd.load_label(source_train_labels)
X_train = rd.matrix_transformation(fetch_data_train, 28, 28)
X_test = rd.matrix_transformation(fetch_data_test, 28, 28)
Y_test_labels = rd.load_label(source_test_labels)
# print(len(Y1))
tem = 0.99
accuracy_array = []
percent_training = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
total_training_time = 0
start1 = time.time()
for i in range(0, 10):
start = time.time()
def start():
number_of_tries = int(ent_number_of_tries.get())
number_of_individuals = int(ent_number_of_individuals.get())
increase_of_individuals = int(ent_increase_of_individuals.get())
max_generation = int(ent_max_generation.get())
increase_of_max_generation = int(ent_increase_of_max_generation.get())
number_of_genes = int(ent_number_of_genes.get())
number_of_color = int(ent_number_of_color.get())
mutation_rate = float(ent_mutation_rate.get())
method_algorthim= combo_method_algorthim.get()
population_method = radio_population_method.get()
fitness_method = radio_fitness_method.get()
crossover_method = radio_crossover_method.get()
mutation_method = radio_mutation_method.get()
if method_algorthim == 'random':
#Random adjacency matrix
adjacency_matrix = [[random.randint(0, 1) for x in range(number_of_genes)] for y in range(number_of_genes)]
for i in range(number_of_genes):
for j in range(number_of_genes):
if j <= i and adjacency_matrix[j][i] == 1:
adjacency_matrix[j][i] = 0
elif method_algorthim == 'custom':
adjacency_matrix = load_data(path, number_of_genes)
## We can choose two method random to create a random edges between nodes or custom to define our edges in adjacency matrix form
## in the random method the fourth parameter returned by GAlgorthim will by the adjacency matrix which created randomly
with open('Result.txt', 'w') as result:
result.write('max_generation,populition,number_of_solutions,number_of_color,fitness,time\n')
list_number_of_tries = [x for x in range(1,number_of_tries+1)]
list_max_generation=[]
list_number_of_individuals=[]
list_number_sol_color=[]
list_fitness_solution=[]
list_time=[]
list_first_solution=[]
for x in range(number_of_tries):
start_time = time.time()
solution_list, fitness_solution, number_sol_color=GAlgorthim(population_method, fitness_method, crossover_method,mutation_method,
number_of_individuals, max_generation, number_of_genes, number_of_color, mutation_rate, adjacency_matrix)
time_algorthim = "{:.2f}".format(time.time() - start_time)
text.insert(END, "try number "+str(x+1)+" ==========\n" )
text.insert(END, "The time of running the algorithm is %s seconds\n" % time_algorthim)
text.insert(END, "The populition = " + str(number_of_individuals))
text.insert(END, "\nThe max genertion = " + str(max_generation))
text.insert(END, '\nThe algorithm found '+str( len(solution_list))+ ' possible solutions\nMinimum number of colors = '+ str(number_sol_color)+
'\nThe fitness = '+ str(fitness_solution)+'\nNumber of edges = '+str(sum([sum(x) for x in adjacency_matrix]))+'\n')
print("The time of running the algorithm is %s seconds " % time_algorthim)
print('solution_list',solution_list)
print("The populition is = " , number_of_individuals)
print('The algorithm found ', len(solution_list), 'possible solutions\nMinimum number of colors = ', number_sol_color,
'\nThe fitness = ', fitness_solution,'\nNumber of edges = ',sum([sum(x) for x in adjacency_matrix]))
print('solution_list',solution_list)
print('The first possible solution is : ', solution_list[0])
print('====================================================')
result.write(str(max_generation)+','+str(number_of_individuals)+','+ str(len(solution_list))+','+ str(number_sol_color)+','+
str(fitness_solution)+','+ str(time_algorthim)+'\n')
list_max_generation.append(max_generation)
list_number_of_individuals.append(number_of_individuals)
list_number_sol_color.append(number_sol_color)
list_fitness_solution.append(fitness_solution)
list_time.append(time_algorthim)
list_first_solution.append(solution_list[0])
number_of_individuals += increase_of_individuals
max_generation += increase_of_max_generation
final_solution = optimal_solution(list_first_solution, list_fitness_solution)
text.insert(END, "\nthe list of the final solution is "+str(final_solution) )
print('the optimal solutions after all tries ',final_solution)
plot_result(list_number_of_tries, list_max_generation, list_number_of_individuals, list_number_sol_color, list_fitness_solution, list_time)
#Drawing the graph
global idx_solution
global number_of_solution
idx_solution = 0
number_of_solution = len(final_solution)
def next_solution(number_of_genes, adjacency_matrix, number_of_color, show_solution):
global idx_solution
global number_of_solution
idx_solution += 1
if idx_solution == number_of_solution:
Button_solution = Button(root, text="Quit ...", width= 15, command=root.destroy)
Button_solution.grid(row=13, column=2, padx=5, pady=5)
else:
Button_solution = Button(root, text="next solution", width= 15, command=lambda: next_solution(number_of_genes, adjacency_matrix, number_of_color, final_solution[idx_solution]))
Button_solution.grid(row=13, column=2, padx=5, pady=5)
draw_graph(number_of_genes, adjacency_matrix, number_of_color, show_solution)
Button_solution = Button(root, text="display solution", width= 15, command=lambda: next_solution(number_of_genes, adjacency_matrix, number_of_color, final_solution[idx_solution]))
Button_solution.grid(row=13, column=2, padx=5, pady=5)
