def t_tester(solver_a, solver_b, verbose=False, difficulty='easy', trials=10): board = get_sugoku_board(difficulty) solvers = [solver_a, solver_b] timers = [Timer(f.__name__) for f in solvers] for timer, solver in zip(timers, solvers): solver_guesses = [] for _ in range(trials): game = Sudoku(board) empty = game.number_empty() timer.start() done, guesses = solver(game) timer.stop(verbose=verbose) if not done: print('unsolved') else: solver_guesses.append(guesses / empty) print("{:50}: Avg Number of Percentage Guess: {:.5f}".format( solver.__name__, stat.mean(solver_guesses))) for timer in timers: timer.summary() print(sci_stats.ttest_rel(timers[0].times, timers[1].times)) return 0
def constant(Nx, Ny, version): """Exact discrete solution of the scheme.""" def exact_solution(x, y, t): return 5 def I(x, y): return 5 def V(x, y): return 0 def f(x, y, t): return 0 def q(x,y): return 1 Lx = 5; Ly = 2 b = 1.5; dt = -1 # use longest possible steps T = 4 def assert_no_error(u, x, xv, y, yv, t, n): u_e = exact_solution(xv, yv, t[n]) diff = abs(u - u_e).max() error.append(diff) tol = 1E-12 msg = 'diff=%g, step %d, time=%g' % (diff, n, t[n]) assert diff < tol, msg new_dt, u = solver( I, V, f, q, b, Lx, Ly, Nx, Ny, dt, T, user_action=assert_no_error, version=version) print(u)
def __init__(self, game): self.game = game self.solver = solver(self.game) self.database = None self.player1 = None self.player2 = None self.name1 = None self.name2 = None
def test_solve_1(self): solution = [[3, 9, 6, 5, 2, 4, 8, 7, 1], [8, 2, 7, 1, 3, 6, 5, 9, 4], [5, 1, 4, 8, 9, 7, 6, 2, 3], [4, 5, 3, 7, 6, 1, 9, 8, 2], [1, 7, 8, 9, 5, 2, 4, 3, 6], [9, 6, 2, 4, 8, 3, 7, 1, 5], [7, 4, 5, 3, 1, 9, 2, 6, 8], [6, 8, 1, 2, 7, 5, 3, 4, 9], [2, 3, 9, 6, 4, 8, 1, 5, 7]] self.assertEquals(solver(self.problem1, []), solution, "I felt a disturbance in the force")
def test_manufactured_solution(): Lx = 1; Ly = 1 dt = -1; T = 0.4 b = 4 mx = 4; my = 2 kx = (mx*np.pi)/Lx ky = (my*np.pi)/Ly w = np.sqrt(kx**2 + ky**2); A = 1.5; B = 3 def u_e(x, y, t): return (A*np.cos(w*t) + B*np.sin(w*t))*(np.exp(-c(x,y)*t))*np.cos(kx*x)*np.cos(ky*y) def I(x, y): return A*np.cos(kx*x)*np.cos(ky*y) def V(x, y): return (w*B - c(x,y)*A)*np.cos(kx*x)*np.cos(ky*y) def q(x,y): return 1 def c(x,y): return np.sqrt(q(x,y)) f = source_term(A, B, kx, ky, w, b) N_values = [5,10,20,40,80,160,320] E_values = [] # Contains largest error for different Nx values h_values = [] error = Error(u_e) for N in N_values: # Run all experiments print('Running Nx=Ny:', N) Nx = Ny = N dt = -1 solver(I, V, f, q, b, Lx, Ly, Nx, Ny, dt, T, user_action=error, version='vectorized') E_values.append(error.E) h_values.append(error.h) r = [(np.log(E_values[i]/E_values[i-1]))/np.log(h_values[i]/h_values[i-1]) for i in range(1, len(N_values))] print("\n CONVERGENCE RATES WITH DETAILS ") print(" N(i) | N(i+1) | dt(i) | dt(i+1) | r(i) | \n") for i in range(len(N_values)-1): print(" %-3i %-4i %-9.3E %-9.3E %-5.4f" \ %(N_values[i], N_values[i+1], h_values[i], h_values[i+1], r[i])) print('') tol = 0.05 assert r[-1]-2 < tol and r[-1]-2 > 0 #Test to check that r converges to two
def test_undamped_waves(): Lx = 1; Ly = 1 dt = -1; T = 0.4 b = 0 mx = 2; my = 3 kx = (mx*np.pi)/Lx ky = (my*np.pi)/Ly w = np.sqrt(kx**2 + ky**2); A = 1.5 def u_e(x, y, t): return A*np.cos(kx*x)*np.cos(ky*y)*np.cos(w*t) def I(x, y): return A*np.cos(kx*x)*np.cos(ky*y) def V(x, y): return 0 def f(x, y, t): return 0 def q(x,y): return 1 def c(x,y): return np.sqrt(q(x,y)) N_values = [5,10,20,40,80,160,320] E_values = [] # Contains largest error for different Nx values h_values = [] error = Error(u_e) for N in N_values: # Run all experiments print('Running Nx=Ny:', N) Nx = Ny = N dt = -1 solver(I, V, f, q, b, Lx, Ly, Nx, Ny, dt, T, user_action=error, version='vectorized') E_values.append(error.E) h_values.append(error.h) r = [(np.log(E_values[i]/E_values[i-1]))/np.log(h_values[i]/h_values[i-1]) for i in range(1, len(N_values))] print("\n CONVERGENCE RATES WITH DETAILS ") print(" N(i) | N(i+1) | dt(i) | dt(i+1) | r(i) | \n") for i in range(len(N_values)-1): print(" %-3i %-4i %-9.3E %-9.3E %-5.4f" \ %(N_values[i], N_values[i+1], h_values[i], h_values[i+1], r[i])) print('')
def test_filter_reads1(self): reads1 = ["ACTG", "TGCA", "ACAC", "TTTT", "GGGG"] solver1 = solver(reads1) solver1.reads = reads1 solver1.main() solver1.print_nodes() for read in reads1: good = False for node in solver1.nodes: if node.read == read: good = True self.assertTrue(good)
def tree_fitness(self,tree): # use full test set this is defined here because we want to change to use partial test for other GPs fitness = 0 for test in self.test_set: if tree.evaluate(test) == solver(test): fitness = fitness + 1 if tree.num_of_nodes > self.node_limit and fitness != len(self.test_set): fitness = fitness - (tree.num_of_nodes - self.node_limit)//100 tree.fitness = fitness return fitness
def q(): value = request.forms.get('value') vals_dict = parser(value) print vals_dict vals_list = get_vals(vals_dict) values = solver(vals_list[0], vals_list[1], vals_list[2], vals_list[3], vals_list[4], vals_list[5], vals_list[6], vals_list[7], vals_list[8], vals_list[9], vals_list[10]) new_dict = {} for key in values: if values[key] is not None: new_dict[key] = values[key] steps = [] steps = oursteps() return dict(values=new_dict, steps=steps)
def run_model(data, hidden_dims, input_dims, num_classes, weight_scale, learning_rate): model = fullyConnectedNet(hidden_dims, input_dims, num_classes, weight_scale=weight_scale, dtype=np.float64) Solver = solver(model, data, print_every=10, num_epochs=20, batch_size=25, update_rule='sgd', optim_config={ 'learning_rate': learning_rate, }) Solver.train() return Solver.loss_history, Solver.train_err_history
def tree_fitness(self,tree): # use full test set this is defined here because we want to change to use partial test for other GPs fitness = 0 if self.cur_iter >= self.max_iters: # this means do full evaluation for the last iteration proportion = 1.0 else: proportion = 1.0 index = 0 for test in self.test_set: if random.random() < proportion : if tree.evaluate(test) == solver(test): fitness = fitness + 1 index = index + 1 if tree.num_of_nodes > self.node_limit and fitness != len(self.test_set): fitness = fitness - (tree.num_of_nodes - self.node_limit)//100 tree.fitness = fitness return fitness
def main(): ai = matlabarray(zeros (10,10,dtype=int),dtype=int) af = copy(ai) ai[1,1]=2 ai[2,2]=3 ai[3,3]=4 ai[4,4]=5 ai[5,5]=1 af[9,9]=1 af[8,8]=2 af[7,7]=3 af[6,6]=4 af[10,10]=5 t0 = time.clock() mv = solver(ai,af,0) t1 = time.clock() print t1-t0 print mv.shape
def tester(solvers, verbose=False, difficulty='easy', trials=1): boards = get_test_boards(difficulty=difficulty) timers = [Timer(f.__name__) for f in solvers] for timer, solver in zip(timers, solvers): solver_guesses = [] for board in boards: for _ in range(trials): game = Sudoku(board) empty = game.number_empty() timer.start() done, guesses = solver(game) timer.stop(verbose=verbose) if not done: print('unsolved') else: solver_guesses.append(guesses / empty) print("{:50}: Avg Number of Percentage Guess: {:.5f}".format( solver.__name__, stat.mean(solver_guesses))) for timer in timers: timer.summary() return 0
filePath = '{}_test.csv'.format(config.load_from) if os.path.exists(filePath): os.remove(filePath) for batch in tqdm(range(config.batch_size)): hPlacement, hEnergy, hCst_occupancy, hCst_bandwidth, hCcst_latency = first_fit( networkServices.state[batch], networkServices.service_length[batch], env) hPenalty = agent.lambda_occupancy * hCst_occupancy + agent.lambda_bandwidth * hCst_bandwidth + agent.lambda_latency * hCcst_latency hLagrangian = hEnergy + hPenalty sPlacement, sSvc_bandwidth, sSvc_net_latency, sSvc_cpu_latency, sEnergy, sOccupancy, sLink_used = \ solver(networkServices.state[batch], networkServices.service_length[batch], env) if sPlacement == None: sReward[batch] = 0 else: env.clear() env.step(networkServices.service_length[batch], networkServices.state[batch], sPlacement) assert sSvc_bandwidth == env.bandwidth assert sSvc_net_latency == env.link_latency assert sSvc_cpu_latency == env.cpu_latency assert sEnergy == env.reward assert sOccupancy == list(env.cpu_used) assert sLink_used == list(env.link_used)
'X_val': data['X_val'], 'y_val': data['y_val'], } weight_scale = 2e-2 bn_model = fullyConnectedNet(input_dims = 32 * 32 * 3, hidden_dims = hidden_dims, num_classes = 10, \ weight_scale=weight_scale, use_batch_normal=True) model = fullyConnectedNet(input_dims = 32 * 32 * 3, hidden_dims = hidden_dims, num_classes = 10, \ weight_scale=weight_scale, use_batch_normal=False) bn_solver = solver(bn_model, small_data, num_epochs=10, batch_size=50, update_rule='adam', optim_config={ 'learning_rate': 1e-3, }, verbose=True, print_every=200) bn_solver.train() solver = solver(model, small_data, num_epochs=10, batch_size=50, update_rule='adam', optim_config={ 'learning_rate': 1e-3, }, verbose=True,
def test(): pygame.init() pygame.display.set_caption("reversed pendulum") viewport = (1800, 600) hx = viewport[0] / 2 hy = viewport[1] / 2 screen = pygame.display.set_mode(viewport, OPENGL | DOUBLEBUF) mat_specular = [1.0, 1.0, 1.0, 1.0] mat_shininess = [50.0] light_position = [0.0, 1.0, 1.0, 0.0] glClearColor(0.0, 0.0, 0.0, 0.0) glShadeModel(GL_SMOOTH) glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular) glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess) glLightfv(GL_LIGHT0, GL_AMBIENT, (0.6, 0.6, 0.6, 1.0)) glLightfv(GL_LIGHT0, GL_POSITION, light_position) glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 45.0) spot_direction = [-1.0, -1.0, 0.0] glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, spot_direction) position = [1.0, 1.0, 1.0, 1.0] glLightfv(GL_LIGHT1, GL_POSITION, position) glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) #glEnable(GL_LIGHT1) glEnable(GL_DEPTH_TEST) revPend = Mecanism() table = Table() clock = pygame.time.Clock() glMatrixMode(GL_PROJECTION) glLoadIdentity() width, height = viewport gluPerspective(90.0, width / float(height), 1, 400.0) glEnable(GL_DEPTH_TEST) glMatrixMode(GL_MODELVIEW) rx, ry = (0, 0) tx, ty = (0, 0) zpos = 200 rotate = move = False alfa = theta = 0 x = 0 dx = 1 step = 5 appliedForce = 0 while 1: #clock.tick(20) for e in pygame.event.get(): if e.type == QUIT: #print(revPend.w, revPend.W) pygame.quit() sys.exit() #glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) elif e.type == KEYDOWN and e.key == K_ESCAPE: pygame.quit() sys.exit() elif e.type == KEYDOWN: pressed_keys = pygame.key.get_pressed() if pressed_keys[K_LEFT]: oldT = revPend.theta revPend.theta += -15 if revPend.theta < -revPend.tMax: revPend.theta = -revPend.tMax revPend.dtheta = oldT - revPend.theta if pressed_keys[K_RIGHT]: oldT = revPend.theta revPend.theta += 15 if revPend.theta > revPend.tMax: revPend.theta = revPend.tMax revPend.dtheta = oldT - revPend.theta glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glLoadIdentity() # RENDER OBJECT glTranslate(tx / 20. - 50, ty / 20. - 50, -zpos) glRotate(ry, 1, 0, 0) glRotate(rx, 0, 1, 0) # se deseneaza masa table.draw(2000) # se aplica modelul fizic t, w = revPend.dynamics(appliedForce) #se calculeaza raspunsul newForce = solver(t, w) if newForce != None: appliedForce = newForce print(t, w, appliedForce) # se deseneaza pendulul revPend.draw() pygame.display.flip() glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) pygame.quit()
v = lambda t: 2 * t # velocity function # Displacement Function from solver import * m = 2 # mass of the system b = 0.8 # friction parameter k = 2 # spring parameter V = 1.5 t = linspace(0, 25, 41) s = lambda u: k * u # restoring force of spring F = lambda t: -m * ddh(v(t) * t) # solver function --> you can change damping mode from 'linear' # to 'quadratic' the result would be changed u, t = solver(I=0, V=V, m=m, b=b, s=s, F=F, t=t, damping="linear") """ # if you want to see plot of solver function,turn me on import matplotlib.pyplot as plt plt.plot(t, u) plt.show() """ # My figure over = Rectangle(lower_left_corner=(-1.5 * R, 2 * H), width=3 * R, height=0.75 * H) tire = Composition( { "wheel": Circle(center=(0, 0), radius=R), "cross": Composition({"cross1": Line((0, -1), (0, R)), "cross2": Line((-R, 0), (R, 0))}),
import json import numpy as np from solver import * with open("model.json") as jfile: data = json.load(jfile) print("\n-----------------") # Convert input - Solver2 title = data["TITLE"] print("\n", title) dimensions = data["DIMENSIONS"] coords = np.array(data["COORDS"]) connectedges = np.array(data["CONNECTEDGE"]) edgesElem = np.array(data["EDGESELEM"]) connect = np.array(data["CONNECTELEM"]) temp = np.array(data["TEMP"]) flux = np.array(data["FLUX"]) prop = np.array(data["PROPERTIES"]) solver(coords, connectedges, edgesElem, connect, temp, flux, prop) print("-----------------\n")
test_data_loader = get_loader( sentences=load_pickle(test_config.sentences_path), labels=load_pickle(test_config.label_path), conversation_length=load_pickle( test_config.conversation_length_path), sentence_length=load_pickle(test_config.sentence_length_path), batch_size=test_config.eval_batch_size, shuffle=False) # for testing solver = Solver solver = solver(config, train_data_loader, eval_data_loader, test_data_loader, is_train=True) solver.build() best_test_loss, best_test_f1_w, best_epoch = solver.train() print(f"Current RUN: {run+1}") print("\n\nBest test loss") print(best_test_loss) print("Best test f1 weighted") print(best_test_f1_w) print("Best epoch") print(best_epoch)
def main(): param = def_param() for method in param.method_list: param.method = method for name in param.list_data: param.name_data = name """ creat result file """ direct = '/Users/messi/Documents/Year1/summer18/results_auc/result_' + param.method + '_test2/' file_name = direct + 'result_' + param.name_data + '.csv' if not os.path.exists(direct): os.makedirs(direct) auc_final = 0 auc_init = 0 time_final = 0 with open(file_name, 'w') as fp: a = csv.writer(fp, delimiter=',') row_new = [[ 'run', 'auc_init', 'auc_final', 'num. iters', 'soltime', 'moment_time' ]] a.writerows(row_new) m_accuracy_init = 0 m_accuracy = 0 m_num_iters = 0 m_sol_time = 0 m_moment = 0 for run in range(param.num_run): data = dataReader(param, run + 1) start_time = timeit.default_timer() w_final, num_iters = solver(param, data) end_time = timeit.default_timer() soltime_time = end_time - start_time print('solution time is: {}'.format(soltime_time)) fval_auc_init = computeAUC(param, data, data.initw) print('auc value with initial w is: {}'.format(fval_auc_init)) fval_auc = computeAUC(param, data, w_final) sol_time = soltime_time print('auc value for this run is : {} with solution time :{}'. format(fval_auc, sol_time)) row_new = [[ run, fval_auc_init, fval_auc, num_iters, sol_time, data.soltime_time_mom ]] m_accuracy_init += fval_auc_init / param.num_run m_accuracy += fval_auc / param.num_run m_num_iters += num_iters / param.num_run m_sol_time += sol_time / param.num_run m_moment += data.soltime_time_mom / param.num_run auc_init += fval_auc_init auc_final += fval_auc time_final += sol_time if run == 0: row_new_0 = row_new """ write result file """ with open(file_name, 'a', newline="") as fp: a = csv.writer(fp, delimiter=',') a.writerows(row_new) if run == param.num_run - 1: with open(file_name, 'a', newline="") as fp: a = csv.writer(fp, delimiter=',') row_new = [[ 'average', m_accuracy_init, m_accuracy, m_num_iters, m_sol_time, m_moment ]] a.writerows(row_new) print('this is ', param.name_data) print('initial auc is: {}'.format(float(auc_init) / param.num_run)) print('final auc is: {}'.format(float(auc_final) / param.num_run)) print('final solution time is: {}'.format( float(time_final) / param.num_run))
positions = sess.run(agent.ptr.positions, feed_dict=feed) reward = np.zeros(config.batch_size) # Compute environment for batch in range(config.batch_size): env.clear() env.step(positions[batch], services.state[batch], services.serviceLength[batch]) reward[batch] = env.reward # Render some batch services if batch % max(1, int(config.batch_size / 5)) == 0: print("\n Rendering batch ", batch, "...") env.render(batch) # Calculate performance if config.enable_performance: print("\n Calculating optimal solutions... ") optReward = np.zeros(config.batch_size) for batch in tqdm(range(config.batch_size)): optPlacement = solver(services.state[batch], services.serviceLength[batch], env) env.clear() env.step(optPlacement, services.state[batch], services.serviceLength[batch]) optReward[batch] = env.reward assert optReward[batch] + 0.1 > reward[batch] # Avoid inequalities in the last decimal... performance = np.sum(reward) / np.sum(optReward) print("\n Performance: ", performance)
'bg': colored, 'fg': 'black' }) subentry[j]['obj'].grid(row=i, column=j, ipady=6, padx=1, pady=1) entry.append(subentry) for i in entry: for j in i: binder(j['obj'], entry) solve = Button(text='Solve', cursor="hand2", width=14, command=lambda: solver(entry, solve)) solve.grid(column=3, row=10, columnspan=3, pady=6) clear = Button(text='Clear', cursor="hand2", width=14, command=lambda: clearer(entry, solve)) clear.grid(column=0, row=10, columnspan=3, pady=6) exitter = Button(text='Exit', width=14, command=root.quit, cursor="hand2") exitter.grid(column=6, row=10, columnspan=3, pady=6) author = Label(text='by Jinol Shah', fg='#696969', font='Helvetica 9 italic', cursor="hand2")
dt = tp[1] - tp[0] # delta t v = lambda t: 2 * t # velocity function # Displacement Function from solver import * m = 2 # mass of the system b = 0.8 # friction parameter k = 2 # spring parameter V = 1.5 t = linspace(0, 25, 41) s = lambda u: k * u # restoring force of spring F = lambda t: -m * ddh(v(t) * t) # solver function --> you can change damping mode from 'linear' # to 'quadratic' the result would be changed u, t = solver(I=0, V=V, m=m, b=b, s=s, F=F, t=t, damping='linear') ''' # if you want to see plot of solver function,turn me on import matplotlib.pyplot as plt plt.plot(t, u) plt.show() ''' #My figure over = Rectangle(lower_left_corner=(-1.5 * R, 2 * H), width=3 * R, height=.75 * H) tire = Composition({ 'wheel': Circle(center=(0, 0), radius=R),
u_r = -q_step[1, -2] / q_step[0, -2] # u_r = 0 t_r = qt_step[2, -2] / R / qt_step[0, -2] p_r = qt_step[2, -2] q1_r = p_r / 287 / t_r q2_r = q1_r * u_r q3_r = q1_r * (cv * t_r + u_r**2 / 2) q_r = [q1_r, q2_r, q3_r] q_l = [q1_l, q2_l, q3_l] return [q_l, q_r] scheme = FTCS shock_tube = solver(gridpts=500, dtdx=0.05, scheme=scheme, ic=ic, bc=bc, spaceDomain=[-.5, .5], tmax=5) print(shock_tube.grid.dtdx) dt = shock_tube.grid.t[1] - shock_tube.grid.t[0] shock_tube.animate(int(shock_tube.grid.timesteps), art_viscosity=[0.007, 0.0007], save=True, filename='q3_anim', fps=60)
counter = 1 temp = line_req[i][0] line_req[i][1] = str(counter) for i in range(len(line_req)): if line_req[i][2].startswith("N$"): line_req[i][2] = line_req[i][2].replace("$", "et") parser = argparse.ArgumentParser() #parser.add_argument('-f', '--file', help='Input file', required=True) parser.add_argument('ids', nargs='*', help='some ids') args = parser.parse_args() #inputFile= args.file #fileName=os.path.splitext(inputFile)[0] fileName = args.ids[1] #Input=inputFile InputFile = args.ids[0] f = open(InputFile, 'r') line = reading_file() line_req = eleminate_unnecessary_data() minor_editing() assigning_nets() changing_names() #nets,file_type=parse_input(Input) nets = creating_nets() file_type = "kicad" solver(nets, file_type, fileName)
import json import numpy as np from solver import * with open("model.json") as jfile: data = json.load(jfile) print("\n-----------------") # Convert input title = data["TITLE"] print("\n", title) dimensions = data["DIMENSIONS"] coords = np.array(data["COORDS"]) connect = np.array(data["CONNECT"]) load = np.array(data["LOAD"]) restr = np.array(data["RESTR"]) prop = np.array(data["PROP"]) solver(coords, connect, load, restr, prop) print("-----------------\n")
eval_data_loader = get_loader( sentences=load_pickle(val_config.sentences_path), conversation_length=load_pickle( val_config.conversation_length_path), sentence_length=load_pickle(val_config.sentence_length_path), vocab=vocab, batch_size=val_config.eval_batch_size, shuffle=False) # for testing # train_data_loader = eval_data_loader if config.model in VariationalModels: if config.model == "ADEM": print("train line:69 config.model", config.model) solver = AdemSolver else: solver = VariationalSolver else: solver = Solver solver = solver(config, train_data_loader, eval_data_loader, vocab=vocab, is_train=True) solver.build(init_by_pretrained_model=True) solver.train()
def create_waves(bottom_shape): for frame in glob.glob("figures/2D_wave_*.png"): os.remove(frame) Lx = 1 Ly = 1 Nx = 120 Ny = 120 dt = -1 # Shortcut to maximum timestep T = 0.6 b = 0.8 def H(x, y, bottom_shape): if bottom_shape == 1: # Gaussian Bmx = 0.5 Bmy = 0.5 B0 = 1 Ba = -0.6 Bs = np.sqrt(1. / 30) b = 0.8 return B0 + Ba * np.exp(-((x - Bmx) / Bs)**2 - ((y - Bmy) / (b * Bs))**2) elif bottom_shape == 2: # Cosine hat Bmx = 0.5 Bmy = 0.5 B0 = 1 Ba = -0.2 Bs = 0.2 condition = np.sqrt(x**2 + y**2) if condition <= Bs and condition >= 0: return B0 + Ba * np.cos( (np.pi * (x - Bmx)) / (2 * Bs)) * np.cos( (np.pi * (y - Bmy)) / (2 * Bs)) else: return B0 elif bottom_shape == 3: # Box addition Bmx = 0.5 Bmy = 0.5 B0 = 1 Ba = -0.6 Bs = 0.2 b = 0.8 if (Bmx - Bs < x < Bmx + Bs) and (Bmy - b * Bs < y < Bmy + b * Bs): return B0 + Ba else: return B0 def q(x, y): # q = c**2 g = 9.81 #[m/s^2] acceleration of gravity if len(x.shape) == 1: q = np.zeros((len(x), len(y))) for i, xx in enumerate(x): for j, yy in enumerate(y): q[i, j] = g * H(xx, yy, bottom_shape) if len(x.shape) == 2: q = np.zeros((x.shape[0], y.shape[1])) for i, xx in enumerate(x[:, 0]): for j, yy in enumerate(y[0]): q[i, j] = g * H(xx, yy, bottom_shape) return q sigma = 0.091 I0 = 0 Im = 0 Ia = 0.3 Is = np.sqrt(2) * sigma def I(x, y): return I0 + Ia * np.exp(-((x - Im) / Is)**2) f = lambda x, y, t: 0 # Source term V = lambda x, y: 0 # Initial du/dt solver(I, V, f, q, b, Lx, Ly, Nx, Ny, dt, T, user_action=plot_2D_wave, version='vectorized')
'y_train': data['y_train'][:num_train], 'X_val': data['X_val'], 'y_val': data['y_val'], } solvers = {} for update_rule in ['sgd', 'rmsprop']: print('running with ', update_rule) model = fullyConnectedNet([100, 100, 100, 100, 100], input_dims = 32 * 32 * 3, \ num_classes = 10, weight_scale=5e-2) Solver = solver(model, small_data, num_epochs=15, batch_size=100, update_rule=update_rule, opt_config={'learning_rate': 1e-2}, verbose=True) Solver.train() solvers[update_rule] = Solver print('training finished.') # print-out results plt.subplot(3, 1, 1) plt.title('Training loss') plt.xlabel('Iteration') plt.subplot(3, 1, 2) plt.title('Training error') plt.xlabel('Epoch')
h = np.zeros(v) node_num = np.zeros(v) elements = np.zeros(v) print('') print( ' Total Nodes Total Elements h L2_error H1_error' ) print('') v = 0 for k in range(start, stop, step): i = 2**k print('i=', i) elements[v] = i * i u, h[v], node_num[v] = solver(element_linear_num=i) e2[v] = L2_error(element_linear_num=i, u=u) h1_error[v] = H1_error(element_linear_num=i, u=u) print(' %4d %4d %8f %14g %14g' % (node_num[v], elements[v], h[v], e2[v], h1_error[v])) v = v + 1 print('') # # plotting L2 error # plt.plot(node_num, e2, 'b') plt.xlabel('Nodes') plt.ylabel('$L_2 \,\,\, Error$') plt.grid()
def cell_is_valid(self, cell): if ((cell[0] < 0 or cell[0] >= self.nrows) \ or (cell[1] < 0 or cell[1] >= self.ncols)): return False return True if __name__ == "__main__": m = Maze() m.setup_maze() d = Displayer(m) print(">> Testing Q learning solver...") bfs_path = solver(m) try: validate_answer(m, bfs_path) # m.goal in bfs_path: print(("solved maze. cost: ", len(bfs_path), "cells visited")) print("Display solution? [y/n]") display_command = input() if "y" in display_command: d.draw_path(bfs_path) except AssertionError as e: print(("answer is invalid: " + e.message)) print(" 1) Save maze to file") print(" 2) exit") command = input() if "1" in command:
def main(): param = def_param() accuracy_final = 0 accuracy_initial = 0 time_final = 0 for method in param.method_list: param.method = method for name in param.list_data: param.name_data = name """ create result file """ direct = '/Users/messi/Documents/summer18/results/result_' + param.method + '_test111/' print(direct) file_name = direct + 'result_' + param.name_data + '.csv' if not os.path.exists(direct): os.makedirs(direct) with open(file_name, 'w') as fp: a = csv.writer(fp, delimiter=',') #row_new = [['run', 'Accuracy_init', 'Accuracy_final', 'num. iters', 'soltime']] row_new = [[ 'run', 'Accuracy_init', 'Accuracy_final', 'num. iters', 'soltime', 'moment_time' ]] a.writerows(row_new) m_accuracy_init = 0 m_accuracy = 0 m_num_iters = 0 m_sol_time = 0 m_moment = 0 for run in range(16, 18): # run = 15 data = dataReader(param, run + 1) print(run) print(param.method) print(param.name_data) print('Optimization process:') start_time = timeit.default_timer() w_final, num_iters = solver(param, data) end_time = timeit.default_timer() soltime_time = end_time - start_time accuracy_init = computeAccuracy(param, data, data.initw) print('Accuracy with initial w is: {}'.format(accuracy_init)) accuracy = computeAccuracy(param, data, w_final) sol_time = soltime_time print( 'Accuracy after minimization is: {} with solution time :{}' .format(accuracy, sol_time)) #row_new = [[run, accuracy_init, accuracy, num_iters, sol_time]] row_new = [[ run, accuracy_init, accuracy, num_iters, sol_time, data.soltime_time_mom ]] """ write result file """ m_accuracy_init += accuracy_init / param.num_run m_accuracy += accuracy / param.num_run m_num_iters += num_iters / param.num_run m_sol_time += sol_time / param.num_run m_moment += data.soltime_time_mom / param.num_run with open(file_name, 'a', newline="") as fp: a = csv.writer(fp, delimiter=',') a.writerows(row_new) if run == param.num_run - 1: with open(file_name, 'a', newline="") as fp: a = csv.writer(fp, delimiter=',') row_new = [[ 'average', m_accuracy_init, m_accuracy, m_num_iters, m_sol_time, m_moment ]] a.writerows(row_new) accuracy_initial += accuracy_init accuracy_final += accuracy time_final += sol_time print('Total initial accuracy is: {}'.format( float(accuracy_initial) / param.num_run)) print('FINAL accuracy is: {} with solution time: {}'.format( float(accuracy_final) / param.num_run, float(time_final) / param.num_run)) print(w_final)
def test_plug_wave(): def V(x, y): return 0 def f(x, y, t): return 0 def q(x,y): return 1 def c(x,y): return np.sqrt(q(x,y)) Lx = 1.1; Ly = 1.1 Nx = 11; Ny = 11 dt = 0.1; T = 1.1 b = 0 class Action: """Store last solution.""" def __call__(self, u, x, xv, y, yv, t, n): if n == len(t)-1: self.u = u.copy(); self.x = x.copy() self.y = y.copy(); self.t = t[n] action = Action() def Ix_scalar(x,y): # Scalar initial condition if abs(x-Lx/2.0) > 0.1: return 0 else: return 1 def Ix_vec(x,y): # vectorized initial condition I = np.zeros(x.shape) for i in range(len(x[:,0])): if abs(x[i,0]-Lx/2.0) > 0.1: I[i,0] = 0 else: I[i,0] = 1 return I def Iy_scalar(x,y): # For scalar scheme if abs(y-Ly/2.0) > 0.1: return 0 else: return 1 def Iy_vec(x,y): I = np.zeros(y.shape) for j in range(len(y[0,:])): if abs(y[0,j]-Ly/2.0) > 0.1: I[0,j] = 0 else: I[0,j] = 1 return I solver(Ix_scalar, V, f, q, b, Lx, Ly, Nx, Ny, dt, T, user_action=action, version='scalar') u_s_x = action.u solver(Iy_scalar, V, f, q, b, Lx, Ly, Nx, Ny, dt, T, user_action=action, version='scalar') u_s_y = action.u solver(Ix_vec, V, f, q, b, Lx, Ly, Nx, Ny, dt, T, user_action=action, version='vectorized') u_v_x = action.u solver(Iy_vec, V, f, q, b, Lx, Ly, Nx, Ny, dt, T, user_action=action, version='vectorized') u_v_y = action.u diff1 = abs(u_s_x - u_v_x).max() diff2 = abs(u_s_y - u_v_y).max() tol = 1e-13 assert diff1 < tol and diff1 < tol u_0_x = np.zeros((Nx+1,Ny+1)) u_0_x[:,:] = Ix_vec(action.x[:,np.newaxis], action.y[np.newaxis,:]) u_0_y = np.zeros((Nx+1,Ny+1)) u_0_y[:,:] = Iy_vec(action.x[:,np.newaxis], action.y[np.newaxis,:]) def check_wave(): #Just to check that the wave splits for different timestep (in x-direction) #At which timestep to plot is modified in Action() by changing 'len(t)-1' import matplotlib.pyplot as plt x = np.linspace(0, Lx, Nx+1) y = np.linspace(0, Ly, Ny+1) plt.plot(x, u_v_x) plt.title("t=%.2f" % action.t) plt.xlabel('Lx') plt.ylabel('U') plt.show() #check_wave() diff3 = abs(u_s_x - u_0_x).max() diff4 = abs(u_s_y - u_0_y).max() diff5 = abs(u_v_x - u_0_x).max() diff6 = abs(u_v_y - u_0_y).max() assert diff3 < tol and diff4 < tol and diff5 < tol and diff6 < tol
def __call__(self): tau = util.tau # Positions des billes après tau up = [] for i in range(len(self.billes)): temp = self.billes[i].testUpdate(tau) up.append([i, temp[0], temp[1], temp[2], temp[3]]) # On regarde s'il y a des conflits conflits = [] # 1. Chocs entre billes tests = [] for elem in up: for j in range(len(up)): if elem[0] != j and [elem[0], j] not in tests and [j, elem[0]] not in tests: tests.append([elem[0], j]) if not self.billes[up[j][0]].rentre: if util.choc([[up[elem[0]][1], up[elem[0]][2]], [up[j][1], up[j][2]]]): conflits.append(["choc", elem[0], j]) # 2. Bille qui s'arrête for elem in up: if not self.billes[elem[0]].rentre: if elem[3] <= 0 and self.billes[elem[0]].v[0] > 0: conflits.append(["v0", elem[0]]) elif elem[4] <= 0 and self.billes[elem[0]].v[1] > 0: conflits.append(["v1", elem[0]]) # 3. Bords du billard for elem in up: if not self.billes[elem[0]].rentre: if util.oob(elem[1:3]): conflits.append(["oob", elem[0]]) if len(conflits) > 0: # On résout le conflit et on récupère le tau correspondant solver(self.billes, conflits) tau = solver.solved[0] # MAJ des billes for b in self.billes: b.update(tau) if len(conflits) > 0: solution = solver.solved[1] # Problème résolu : annulation de la vitesse de glissement if solution[0] == self.V0: self.billes[solution[1]].v[0] = 0 self.billes[solution[1]].glissement = False # Problème résolu : annulation de la vitesse de roulement elif solution[0] == self.V1: self.billes[solution[1]].v[1] = 0 if self.billes[solution[1]].v[0] == 0: self.billes[solution[1]].arret = True # Problème résolu : choc avec les bords elif solution[0] == self.OOB: pos = self.billes[solution[1]].pos # La bille ne tombe pas dans un trou pR = util.t_m * 0.85 gR = util.t_b * 1.5 if not (util.b_d / 2 - pR <= pos[0] <= util.b_d / 2 + pR) \ and not (pos[0] <= util.holes[0][0] + gR and pos[1] <= util.holes[0][1] + gR) \ and not (pos[0] >= util.holes[1][0] - gR and pos[1] <= util.holes[1][1] + gR) \ and not (pos[0] <= util.holes[2][0] + gR and pos[1] >= util.holes[2][1] - gR) \ and not (pos[0] >= util.holes[3][0] - gR and pos[1] >= util.holes[3][1] - gR): dists = [[0, (pos[0] - util.b_g) ** 2], [1, (pos[1] - util.b_h) ** 2], [2, (pos[0] - util.b_d) ** 2], [3, (pos[1] - util.b_b) ** 2]] dists.sort(key=lambda x: x[1]) if dists[0][0] % 2 == 0: self.billes[solution[1]].alpha = np.pi - \ self.billes[solution[1]].alpha else: self.billes[solution[1]].alpha = - \ self.billes[solution[1]].alpha self.billes[solution[1]].v /= np.sqrt(2) # La bille tombe dans un trou else: self.billes[solution[1]].arret = True self.billes[solution[1]].rentre = True # Problème résolu : choc entre bille elif solution[0] == self.CHOC: v1o, v2o = util.getOrth( self.billes[solution[1]], self.billes[solution[2]]) v1p, v2p = util.getPar( self.billes[solution[1]], self.billes[solution[2]]) # Choc v1of = v2o v2of = v1o v1pf = v1p v2pf = v2p alpha = util.getAlpha( self.billes[solution[1]], self.billes[solution[2]]) self.billes[solution[1]].alpha = np.pi - \ alpha - np.arctan2(v1pf, v1of) self.billes[solution[2]].alpha = alpha - \ np.pi / 2 + np.arctan2(v2of, v2pf) self.billes[solution[1]].v[0] = 0 self.billes[solution[2]].v[0] = 0 self.billes[solution[1]].glissement = False self.billes[solution[1]].glissement = False self.billes[solution[1]].v[1] = np.sqrt(v1of ** 2 + v1pf ** 2) self.billes[solution[2]].v[1] = np.sqrt(v2of ** 2 + v2pf ** 2) if self.billes[solution[1]].v[1] <= 0: self.billes[solution[1]].arret = True else: self.billes[solution[1]].arret = False if self.billes[solution[2]].v[1] <= 0: self.billes[solution[2]].arret = True else: self.billes[solution[2]].arret = False self.lastTau = tau