def main(): table = Table(screen) table.draw() algo = Algorithm(args.algo, screen) algo.run(table) make_gif(table.id_screenshot)
def calibrate(self): if not self.model.fetch_data(): self.status.showMessage("No loaded data") return dataset_initial = self.model.fetch_data() maxdub = Algorithm(dataset_initial) dataset_correction = [ maxdub.correct(x, y) for (x, y) in dataset_initial ] union_ = [(x, y, round(xc, 1), round(yc, 1)) for (x, y), (xc, yc) in zip(dataset_initial, dataset_correction)] self.model.reset() self.model.load_data(union_) # self.chartwidget.add_graph(name="Correction Magnitude", model=self.model, xcol=2, ycol=3) #print(self.model.fetch_data()) xdata = [] ydata = [] for (_, _, x, y) in self.model.fetch_data(): xdata.append(x) ydata.append(y) self.chartwidget.set_data(xdata, ydata)
def initialize(self): Algorithm.initialize(self) # to store results # tridiagonal matrix coefficients self.alpha = np.zeros(self.maxiter + 1) self.beta = np.zeros(self.maxiter) self.vectors = np.zeros((self.maxiter + 1, self.n)) self.w = np.zeros(self.n) # starting point self.vectors[0] = np.random.randn(self.n) self.vectors[0] /= np.sqrt(norm2(self.vectors[0]))
def __init__(self, A, **kwargs): self.A = A self.n = self.A.shape[0] self.kwargs = kwargs # extract appropriate kwargs for stop condition maxiter = kwargs.get("maxiter", 300) tol = kwargs.get("tol", None) gtol = kwargs.get("gtol", None) self.stop_condition = StopCondition(maxiter=maxiter, tol=tol, gtol=gtol) # maxiter default to matrix size if not given. self.maxiter = getattr(self.stop_condition, "maxiter", self.n) Algorithm.__init__(self)
def iterate(self): print("Iteration %i / %i" % (self.iter_ + 1, self.stop_condition.maxiter)) print("Outer loop") self.outer() print("Inner loop") self.inner() return Algorithm.iterate(self)
def main(cfg): print(cfg.pretty(), end="\n\n\n") environment = get_environment(**cfg["environment"]) agent = Agent.from_conf(environment, **cfg["agent"]) replay_buffer = ReplayBufferBase.from_conf(**cfg["replay_buffer"]) algorithm = Algorithm.from_conf(environment, agent, replay_buffer, **cfg["algorithm"]) algorithm()
def compute(self): print("Compute start") maxdub = Algorithm(self.data) # for y,x in self.data: # yc, xc = maxdub.correct(x, y) # self.result.append([y, x, yc, xc]) # # fname = "/home/tech/Workspace/python/magnetic-tools/fields.csv" # to_csv(fname, self.result, mode='x') # print("Compute Complete") return maxdub
def main(cfg): print(cfg.pretty(), end="\n\n\n") config_path = cfg.experiment_path + "/.hydra/config.yaml" exp_cfg = omegaconf.OmegaConf.load(config_path) exp_cfg.environment.monitor = "always" environment = get_environment(**exp_cfg["environment"]) agent = Agent.from_conf(environment, **exp_cfg["agent"]) replay_buffer = ReplayBuffer.from_conf(**exp_cfg["replay_buffer"]) algorithm = Algorithm.from_conf(environment, agent, replay_buffer, **exp_cfg["algorithm"]) algorithm.restore_model(cfg.experiment_path + "/checkpoints") for i in range(cfg["n_episodes"]): print("{: 3d}/{: 3d}".format(i + 1, cfg["n_episodes"]), end='\r') algorithm.evaluate()
def __init__(self): pygame.init() self.window = pygame.display.set_mode((Program.WINDOW_WIDTH, Program.WINDOW_HEIGHT)) self.fps = 10 self.clock = pygame.time.Clock() self.runMenu = True self.algo = Algorithm(self.window) self.selectionButton = Button(self.window, (color.RED, color.WHITE), 'Selection Sort', (100, 150, 250, 50), self.algo.sort) self.bubbleButton = Button(self.window, (color.RED, color.WHITE), 'Bubble Sort', (100, 250, 250, 50), self.algo.sort) self.insertionButton = Button(self.window, (color.RED, color.WHITE), 'Insertion Sort', (100, 350, 250, 50), self.algo.sort) self.mergeButton = Button(self.window, (color.RED, color.WHITE), 'Merge Sort', (400, 150, 250, 50), self.algo.sort) self.quickButton = Button(self.window, (color.RED, color.WHITE), 'Quick Sort', (400, 250, 250, 50), self.algo.sort) self.heapButton = Button(self.window, (color.RED, color.WHITE), 'Heap Sort', (400, 350, 250, 50), self.algo.sort)
from algorithms import Algorithm from config import target from facebook import FacebookClient from config import cookies def init(client): username = client.get_myself_username() goals = client.get_friends(target) return (username, goals) if __name__ == '__main__': client = FacebookClient(cookies) username, goals = init(client) print 'Goals: %s' % goals algorithm = Algorithm(username, goals, client) results = algorithm.bfs() print '------------------------------------------' print "RESULT PATHS: %s\n" % '\n'.join(results) print '------------------------------------------'
def main(self): args = self.__parse() with open(args.save_configuration if args. save_configuration else self.__app_dir + '/outputs/save/config.json') as f: save_config = json.load(f) if args.action == 'extract': with open(args.builder_configuration if args. builder_configuration else self.__app_dir + '/datasets/' + args.extractor + '/config.json') as f: dataset_builder_config = json.load(f) dataset = DatasetBuilder(args.extractor).build( args.dataset_filename_in, **dataset_builder_config) with open(args.extractor_configuration if args. extractor_configuration else self.__app_dir + '/extractors/' + args.extractor + '/config.json') as f: extractor_config = json.load(f) features = Extractor(args.extractor).extract( dataset, **extractor_config) Save.features( args.features_filename_out, features, **save_config['extract'] if 'extract' in save_config else {}) elif args.action == 'predict': with open(args.features_filename_in) as f: features = json.load(f) with open(args.algorithm_configuration if args. algorithm_configuration else self.__app_dir + '/algorithms/' + args.algorithm + '/config.json') as f: algorithm_config = json.load(f) algorithm = Algorithm(args.algorithm, features=features, **algorithm_config) if args.kfold: y_tests, y_predictions, y_labels = algorithm.stratified_k_fold( folds=args.kfold) else: raise RuntimeError Save.predictions( args.y_tests_filename, args.y_predictions_filename, args.y_labels_filename, y_tests, y_predictions, y_labels, **save_config['predict'] if 'predict' in save_config else {}) elif args.action == 'eval': with open(args.y_tests_filename) as f: y_tests = json.load(f) with open(args.y_predictions_filename) as f: y_predictions = json.load(f) with open(args.y_labels_filename) as f: y_labels = json.load(f) Save.metrics( args.metrics_filename_out, y_tests, y_predictions, y_labels, **save_config['eval'] if 'eval' in save_config else {}) elif args.action == 'plot': with open(args.metrics_filename_in) as f: metrics = json.load(f) with open(args.plot_configuration if args. plot_configuration else self.__app_dir + '/outputs/plot/config.json') as f: plot_config = json.load(f) Plot.all(args.plot_filename_out, metrics, **plot_config)
import logging from structures import Corpus, Merge from algorithms import Algorithm from visualization import Visualization import utilities logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(name)s %(levelname)s %(message)s', filename='scitext.log', filemode='w') ''' TODO: # ADD MERGE class and functionality with master config and then allow linek to all config classes ''' config = utilities.get_config('./config/data/master.yaml') print('\n\nreading from the following configuration files: \n\n ', config['config_files']) corpi_list = [Corpus(config_file) for config_file in config['config_files']] corpi = Merge([corpus() for corpus in corpi_list]) alg = Algorithm(corpi, './config/algorithms.yaml') alg.run() vis = Visualization('./config/visualization.yaml', './config/algorithms.yaml', alg) vis.run()
def main_loop(problem): """ Synopsis -------- Evolve the (M)HD equations through t = 0 to t = "max time". Args ---- problem: object-like. User defined simulation problem. Attributes ---------- None. TODO ---- None. """ timing = Timer(problem.parameter) timing.start_sim() log = Log(problem.parameter) log.logo() log.options() print(" Initialising IO...") io = OutputInput(problem.parameter, log) if problem.parameter['restart file'] is not None: V = io.input(problem.parameter) # Initialise grid. grid = Grid(problem.parameter, log) # Initialise Algorithms. print(" Assigning algorithms...") algorithm = Algorithm(problem.parameter, log) # Generate state vector to hold conservative # and primative variables. # Initialise the state vector accourding to # user defined problem. if problem.parameter['restart file'] is None: print(" Creating arrays...") V = grid.state_vector(problem.parameter, log) print(" Setting intial conditions...") problem.initialise(V, grid, log) # Apply boundary conditions. print(" Applying boundary conditions...") grid.boundary(V, problem.parameter) print("") # Check initial grid for nans. if np.isnan(np.sum(V)): print("Error, nan in initial conditions, exiting.") print("") sys.exit() U = np.empty(shape=V.shape, dtype=np.float64) prims_to_cons(V, U, algorithm.igamma_1) del V # First output. timing.start_io() io.output(U, grid, algorithm, problem.parameter) timing.stop_io() print("") log.begin() while grid.t < grid.t_max: timing.start_step() U = algorithm.time_incriment(U, grid, algorithm, timing, problem.parameter) timing.stop_step() log.step(grid, timing) timing.start_io() io.output(U, grid, algorithm, problem.parameter) timing.stop_io() grid.update_dt() else: timing.start_step() U = algorithm.time_incriment(U, grid, algorithm, timing, problem.parameter) timing.stop_step() log.step(grid, timing) timing.start_io() io.output(U, grid, algorithm, problem.parameter) timing.stop_io() timing.stop_sim() log.end(timing) return U
# So the position will start from 1, 1 def mouse_pos_to_cell(pos): y = x = -1 for z in range(0, c.cell_nr + 1): if z * c.cell_side > pos[1] and y == -1: y = z if z * c.cell_side > pos[0] and x == -1: x = z return y, x # Configure the board board = Board(c.cell_nr, c.cell_nr) board.create_dest((1, 1)) board.create_dest((c.cell_nr, c.cell_nr)) al = Algorithm(board) end_pos = al.board.en # Configure pygame window pygame.init() clock = pygame.time.Clock() screen = pygame.display.set_mode( (c.cell_side * c.cell_nr, c.cell_side * c.cell_nr)) run = True # Init the algorithm , check if it's finish init = False finish = False while run: screen.fill(c.color['white'])
write_ply('../data/test_perturbed', [cloud_p.T], ['x', 'y', 'z']) # Optimization parameters max_iter = 50 # Maximum iterations in main loop dist_threshold = 0.1 # d_max RMS_threshold = 1e-5 # Convergence threshold kNeighbors = 20 # To compute PCA eps = 1e-3 # Covariance matrix parameter (for Generalized-ICP only) # Transformation estimation Comparison = 0 if Comparison == 0: # Run and compare all methods plt.title("Convergence of the different methods") algos = [ Algorithm('plane-to-plane'), Algorithm('point-to-plane'), Algorithm('point-to-point') ] for algo in algos: start = time() cloud_p_opt, RMS_list, R, T = optimize(cloud_p, cloud_o, algo, kNeighbors, max_iter, dist_threshold, RMS_threshold, eps) print("Optimization for " + algo.name + " lasted: {}s".format(round(time() - start, 2))) plt.plot(RMS_list, label=algo.name) elif Comparison == 1: # Compare Generalized-ICP with exact and relaxed gradients # Exact Gradient
districts = [1, 2, 3] start_condition = 1 iterative_algorithm = 0 additional_algorithm = 0 plotter = 1 setting = "standard" # special conditions lineplot = False option = [1, 0, 4] x_first = False # the code below enables user friendliness and is not to be changed for i in districts: title = f'District {i}: ' algo = Algorithm(i, setting) plot = Plots(algo.grid) # start conditions if iterative_algorithm in [0, 1, 2]: if start_condition == 0: print("please fill in a start condition") break elif start_condition == 1: random() title += 'Random connection' elif start_condition == 2: priority_first() title += 'Priority first' elif start_condition == 3: proximity_first()