def __init__(self, config): # Load the system calibration values from the calibration file. self.cal_dict = get_calibration('calibration.yaml') self.cal = np.array(self.cal_dict[1]) # Define system magnetic model and solver with specific loaded configuration self.model = MagneticModel(config['model']) self.solver = Solver(self.cal, self.model, config['solver']) self.channels = config['system']['channels'] # Create a dictionary to store previous sensor positions self.prevPositions = dict() self.flipflags = config['system']['flip_list'] # Define DAQ and Filter objects with their associated configuration self.daq = DAQ(config) self.filter = Filter(config) # Declare storage for sample data and field strengths self.data = np.matrix([]) self.magnitudes = np.matrix([]) # Create local OpenIGTLink server self.igtconn = None if config['system']['igt'] is True: self.igtconn = PyIGTLink(port=config['system']['igt_port'], localServer=config['system']['igt_local'])
def test_random_solvable_quadratics(self): for i in range(0, 3): g = Generator(1, 2, 3, True) e = Equation(g.generate_quadratic(), bound='linear') solver = Solver(e, True, verbose=False) solver.solve() self.assertTrue(solver.solvable)
def train(args): convert_annotations(cfg.DATASET.ANNOT_PATH, cfg.DATASET.ANNOT_JSON_SAVE_PATH) assert (os.path.exists(cfg.DATASET.ANNOT_JSON_SAVE_PATH)) # prepare the data dataloaders = prepare_data() # initialize model model_state_dict = None resume_dict = None if cfg.RESUME != '': resume_dict = torch.load(cfg.RESUME) model_state_dict = resume_dict['model_state_dict'] elif cfg.WEIGHTS != '': param_dict = torch.load(cfg.WEIGHTS) model_state_dict = param_dict['parameters'] net = model.get_MaskGenNet(state_dict=model_state_dict) net = torch.nn.DataParallel(net) if torch.cuda.is_available(): net.cuda() # initialize solver train_solver = Solver(net, dataloaders, resume=resume_dict) # train train_solver.solve() print('Finished!')
def main(): colorama.init() namespace = parse_args() file_names = sorted( glob.glob('resources/puzzles/*.txt')) if not namespace.cube \ else sorted(glob.glob('resources/cube_puzzles/*.txt')) for filename in file_names: if namespace.cube: board = CubeGameBoard(filename) board.read_board() texture_factory = TextureFactory(board.boards) texture_factory.generate_textures() start(board.boards) continue board = GameBoard(filename) board.read_board() print(filename) solver = Solver(board) solver.backtrack() board.print_solution() if board.verify_solution(): print('Solved') else: print('Not solved')
def test_solves_quadratic(self): e = Equation("aXba*X*b*", bound='linear') solver = Solver(e, False, verbose=False) solver.solve() self.assertTrue(solver.solvable) solutions = solver.solution_printer.solutions for solution in solutions: self.assertTrue(e.solves(solution))
def test_solves_linear(self): e = Equation("aXa") solver = Solver(e, True, verbose=False) solver.solve() self.assertTrue(solver.solvable) solutions = solver.solution_printer.solutions self.assertEqual(len(solutions), 1) self.assertTrue(e.solves(solutions[0])) e = Equation("aaXbbYba*") solver = Solver(e, False, verbose=False) solver.solve() self.assertTrue(solver.solvable) solutions = solver.solution_printer.solutions self.assertTrue(len(solutions) > 1) for solution in solutions: self.assertTrue(e.solves(solution))
def test_solve_no_constants(self): e = Equation("XYZ") solver = Solver(e, False, verbose=False) solver.solve() self.assertTrue(solver.solvable) solutions = solver.solution_printer.solutions self.assertEqual(len(solutions), 1) for solution in solutions: self.assertTrue(e.solves(solution))
def test_unconstrained_problem(self): solver = Solver() var1 = solver.add_variable() var2 = solver.add_variable() solver.add_rule(Rule(var1, [(1, var2)], 3)) self.assertFalse(solver.is_constrained)
def test_simple_constrained_problem(self): solver = Solver() var1 = solver.add_variable() var2 = solver.add_variable() solver.add_rule(Rule(var1, [(1, var2)], 3)) solver.add_rule(Rule(var2, [], 3)) self.assertTrue(solver.is_constrained)
def solve_sudoku(digits): ''' Solving the sudoku ''' solver = Solver() solver.load_solver_model(SUDOKU_SOLVER_MODEL_NAME) solved = solver.solve_sudoku(digits) return solved
def main(args): # Construct Solver np.random.seed(1) torch.manual_seed(1) torch.cuda.manual_seed_all(1) torch.backends.cudnn.deterministic = True # 保证每次结果一样 # data tr_dataset = AudioDataset(args.train_mfccjson, args.batch_size, args.maxlen_in, args.maxlen_out, batch_frames=args.batch_frames) cv_dataset = AudioDataset(args.valid_mfccjson, args.batch_size, args.maxlen_in, args.maxlen_out, batch_frames=args.batch_frames) tr_loader = AudioDataLoader(tr_dataset, batch_size=1, num_workers=args.num_workers, shuffle=args.shuffle, LFR_m=args.LFR_m, LFR_n=args.LFR_n, model_choose=args.model_choose) cv_loader = AudioDataLoader(cv_dataset, batch_size=1, num_workers=args.num_workers, LFR_m=args.LFR_m, LFR_n=args.LFR_n, model_choose=args.model_choose) data = {'tr_loader': tr_loader, 'cv_loader': cv_loader} model = Baseline1(args) print(model) print('model parameters:', sum(param.numel() for param in model.parameters())) model.cuda() optimizier = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), betas=(0.9, 0.98), eps=1e-09, lr=args.lr) # solver solver = Solver(data, model, optimizier, args) solver.train()
def __init__(self): # set main pygame screen size self.__screen_size = (1000, 720) self.__screen = pygame.display.set_mode(self.__screen_size[:2]) # change display icon pygame.display.set_icon(pygame.image.load("../assets/icon.png")) self.__generator = Generator() self.__board = self.__generator.generate() # create board object self.__board_model = Board(self.__screen_size, self.__board, self.__screen) # create solver object self.__solver = Solver(self.__board_model, 500) # create left panel object self.__left_panel = LeftPanel(self.__solver, self.__screen_size, self.__screen) # set screen title pygame.display.set_caption("Sudoku")
def __init__(self, size: tuple, board: list, screen: pygame.Surface): super().__init__((size[1], size[1], size[0] - size[1]), screen) self.__board = board self.__solver = Solver(self) # create squares list self.__squares = [[ Square( self.__board[c][r], (r, c), (self.size[0], self.size[2]), self.screen, True if self.__board[c][r] == 0 else False, ) for r in range(9) ] for c in range(9)] self.__selected = None self.__wrong = None
def labyrinth(args): # create maze, set it with rows and columns option maze = Maze(args.rows, args.columns) # create printer and set it with print option printer = Printer(maze, pause=args.pause) maze.set_maze() # print according to display options if args.display == 'both' or args.display == 'without-solution': printer.print_maze() if args.no_solve == False: # create solver and set it with maze object solver = Solver(maze) solver.solve() # print according to display options if args.display == 'both' or args.display == 'with-solution': printer.print_maze() print('Shortest path:', ', '.join(map(str, solver.shortest))) return solver.shortest
def main(config): set_random_seed(config) # Environment env = get_environment(config) # Policy & Baseline policy = get_policy_for_env(config, env, hidden_sizes=config.hidden_sizes, nonlinearity=config.nonlinearity).to( config.device) # policy.share_memory() baseline = LinearFeatureBaseline( reduce(mul, env.observation_space.shape, 1)).to(config.device) # Meta Learner metalearner = MAMLTRPO(config, policy, adapt_lr=config.adapt_lr, first_order=config.first_order, device=config.device) # Sampler sampler = MultiTaskSampler(config, config.env_name, env_kwargs=config.env_kwargs, batch_size=config.fast_batch_size, adapt_lr=config.adapt_lr, policy=policy, baseline=baseline, env=env, seed=config.seed) # Solver solver = Solver(config, policy, sampler, metalearner) solver.train(config)
def train(args): #seed = 12345 #random.seed(seed) #np.random.seed(seed) #torch.random.manual_seed(seed) # initialize model model_state_dict = None model_state_dict_D = None resume_dict = None if cfg.RESUME != '': resume_dict = torch.load(cfg.RESUME, torch.device('cpu')) model_state_dict = resume_dict['model_state_dict'] elif cfg.WEIGHTS != '': param_dict = torch.load(cfg.WEIGHTS, torch.device('cpu')) model_state_dict = param_dict['weights'] model_state_dict_D = param_dict[ 'weights_D'] if 'weights_D' in param_dict else None net = SegNet.__dict__[cfg.MODEL.NETWORK_NAME]( pretrained=False, pretrained_backbone=False, num_classes=cfg.DATASET.NUM_CLASSES, aux_loss=cfg.MODEL.USE_AUX_CLASSIFIER) net = gen_utils.load_model(net, './model/resnet101-imagenet.pth', True) if args.distributed: net = torch.nn.SyncBatchNorm.convert_sync_batchnorm(net) #net = apex.parallel.convert_syncbn_model(net) if cfg.MODEL.DOMAIN_BN: net = DomainBN.convert_domain_batchnorm(net, num_domains=2) if model_state_dict is not None: try: net.load_state_dict(model_state_dict) except: net = DomainBN.convert_domain_batchnorm(net, num_domains=2) net.load_state_dict(model_state_dict) if cfg.TRAIN.FREEZE_BN: net.apply(freeze_BN) if torch.cuda.is_available(): net.cuda() if args.distributed: net = DistributedDataParallel(net, device_ids=[args.gpu]) #net = DistributedDataParallel(net) else: net = torch.nn.DataParallel(net) net_D = init_net_D(args, model_state_dict_D) if cfg.TRAIN.ADV_TRAIN else None dataloaders = prepare_data(args) # initialize solver train_solver = Solver(net, net_D, dataloaders, args.distributed, resume=resume_dict) # train train_solver.solve() print('Finished!')
def __init__(self): self.__solver = Solver()
def __init__(self, MBD_system, parent=None, flags=0): """ Constructor """ super(SimulationControlWidget, self).__init__(parent) self._parent = parent self.ui = Ui_Form() self.ui.setupUi(self) # set size independent of screen resolution to be equal for all resolutions self.setFixedWidth(.2 * self._parent.screen_geometry.width()) self.ui.simulationStopButton.setEnabled(False) self.ui.simulationResetButton.setEnabled(False) self.ui.forwardButton.setEnabled(False) self.ui.backwardButton.setEnabled(False) self.ui.playButton.setEnabled(False) # movie maker self.movie_maker = None # pool of tasks self.pool = QtCore.QThreadPool.globalInstance() self.pool.setMaxThreadCount(1) self.MBD_system = MBD_system # self.simulation_control_widget = self # when simulation is finishes # automatically load solution file self.ui.loadSolutionFileStatus.setChecked(self.MBD_system.loadSolutionFileWhenFinished) # restore initial conditions self.ui.restoreInitialConditionsStatus.setChecked(self.MBD_system.restoreInitialConditionsWhenFinished) # set visualization widget in central widget position self.vtkWidget = VTKWidget(MBD_system=self.MBD_system, parent=self._parent) self._status = "simulation" # simulation or animation # set integration method to display self.ui.integrationMethodComboBox.addItems(self.MBD_system.integrationMethods) _index = self.ui.integrationMethodComboBox.findText(self.MBD_system.integrationMethod) self.ui.integrationMethodComboBox.setCurrentIndex(_index) # signals self.step_num_signal = stepSignal() self.energy_signal = EnergySignal() self.status_signal = StatusSignal() self.signal_simulation_status = SignalSimulationStatus() # use BSM - baumgarte stabilization method self.ui.useBSM_checkBox.setChecked(self.MBD_system.use_BSM) # set validators to limit user input __validator_dbl = QtGui.QDoubleValidator() __validator_int = QtGui.QIntValidator() # predefined values # end time self.ui.endTime.setValidator(__validator_dbl) if self.MBD_system.t_n is not None: self.ui.endTime.setText(str(self.MBD_system.t_n)) # number of steps self.ui.stepsNumber.setValidator(__validator_int) if self.MBD_system.stepsNumber is not None: self.MBD_system.stepsNumber = int(self.MBD_system.stepsNumber) self.ui.stepsNumber.setText(str(self.MBD_system.stepsNumber)) # simulation time step self.step = 0 self._step = 0 # animation properties self._delta_step = None # H min self.MBD_system.evaluate_Hmin() # H max self.ui.Hmax.setText(str(self.MBD_system.Hmax)) self.ui.Hmax.setValidator(__validator_dbl) # H min self.ui.Hmin.setText(str(self.MBD_system.Hmin)) self.ui.Hmin.setValidator(__validator_dbl) # H contact self.ui.Hcontact.setText(str(self.MBD_system.Hcontact)) # abs tol self.ui.absTol.setText(str(self.MBD_system.absTol)) self.ui.absTol.setValidator(__validator_dbl) # rel tol self.ui.relTol.setText(str(self.MBD_system.relTol)) self.ui.relTol.setValidator(__validator_dbl) # tolerance for newton differences self.ui.TOL_dq_i.setText(str(self.MBD_system.TOL_dq_i)) # tolerance for constraint equations C self.ui.TOL_C.setText(str(self.MBD_system.TOL_C)) # create solver thread # solver thread self._solver_thread = QtCore.QThread() self._solver_thread.start() if not MBD_system.monte_carlo: self.solver = Solver(MBD_system, parent=self) else: # jobs of threads # self.solver = SolverThreadManager(MBD_system=self.MBD_system, parent=self) # jobs as processes self.solver = SolverProcessManager(MBD_system=self.MBD_system, parent=self) self.solver.moveToThread(self._solver_thread) # self.solver_process = psutil.Process(id(self._solver_thread)) # timer to update cpu, memory data in simulation control widget self._data_timer = QtCore.QTimer(self) self._data_timer.timeout.connect(self._update_cpu_memory_data) # display update self._update_display_type = self.MBD_system._update_display_type _index = self.ui.updateDisplay_comboBox.findText(self._update_display_type) self.ui.updateDisplay_comboBox.setCurrentIndex(_index) # available options self._update_display_types = ["dt", "step"] # update display on every i-th simulation step if hasattr(self.solver.analysis, "update_opengl_widget_every_Nth_step"): self.ui.updateStep_lineEdit.setText(str(int(self.solver.analysis.update_opengl_widget_every_Nth_step))) self._delta_step = self.solver.analysis.update_opengl_widget_every_Nth_step self.ui.updateStep_lineEdit.setValidator(__validator_int) self.ui.updateStep_lineEdit.setText(str(int(self.MBD_system.updateEveryIthStep))) # update display on dt of simulation time # default value if self.MBD_system._dt == 0: self._dt = self.MBD_system.t_n / 100. else: self._dt = self.MBD_system._dt self.ui.updateDt_lineEdit.setValidator(__validator_dbl) self.ui.updateDt_lineEdit.setText(str(self._dt)) self.ui.currentStep_lineEdit.setEnabled(False) self.ui.currentStep_lineEdit.setValidator(__validator_int) # profiler self.profile = cProfile.Profile() # analysis type self.ui.analysisTypeComboBox.currentIndexChanged.connect(self._analysis_type_changed) # set analysis type to display it in combobox if self.MBD_system.analysis_type is not None: _index = self.ui.analysisTypeComboBox.findText(QtCore.QString(self.MBD_system.analysis_type.title())) self.ui.analysisTypeComboBox.setCurrentIndex(_index) # tab widget of simulation control widget self.ui.tabWidget.setCurrentIndex(0) # video maker attribute object self.video_maker = None # initial start time and date self.ui.simulationStartTime_dateTimeEdit.setDate(QtCore.QDate().currentDate()) # progress bar style css_file = open(os.path.join(os.path.dirname(os.path.realpath(__file__)), "progress_bar_style_no_error.css"), 'r') self.progress_bar_no_error_css_stype = css_file.read() self.ui.simulation_progressBar.setStyleSheet(self.progress_bar_no_error_css_stype) css_file = open(os.path.join(os.path.dirname(os.path.realpath(__file__)), "progress_bar_style_error.css"), 'r') self.progress_bar_error_css_stype = css_file.read() # signals self.connect_signals() # buttons self.connect_buttons() # connections self.connect_UIWidgetItems2variables() # check if solutionfile is defined and load it if self.MBD_system.solutionFilename is not None: solutionFilePath = os.path.join(self.MBD_system.MBD_folder_abs_path, self.MBD_system.solutionFilename) if os.path.isfile(solutionFilePath): self.__automaticaly_load_solution_file(filename=solutionFilePath) else: print "Solution File not found at path %s: " % self.MBD_system.MBD_folder_abs_path print "Check Filename: %s" % self.MBD_system.solutionFilename
from model.cube import Cube from solver.solver import Solver import numpy as np from utils.read_cube import read_cube_arr if __name__ == '__main__': c = Cube() color = 'gyrgggbbb boyyybrrb obwyryooo yrgrowrgy wwwwwowwr gggobrybo' arr = read_cube_arr(color) print(arr) c.read_cube(arr) s = Solver(c) s.solve() print(s.solution)
def test_unsolvable(self): e = Equation("abXcX", bound='linear') solver = Solver(e, False, verbose=False) solver.solve() self.assertFalse(solver.solvable)
#!/usr/bin/env python # coding=utf-8 ''' @Author: wjm @Date: 2019-10-12 23:50:07 @LastEditTime: 2020-06-23 17:46:46 @Description: main.py ''' from utils.config import get_config from solver.solver import Solver import argparse if __name__ == '__main__': parser = argparse.ArgumentParser(description='N_SR') parser.add_argument('--option_path', type=str, default='option.yml') opt = parser.parse_args() cfg = get_config(opt.option_path) solver = Solver(cfg) solver.run()
parser.add_argument('--BFS', dest='search_method', action='store_const', const=bfs, help='Uses BFS search to solve the puzzle') parser.add_argument('--DFS', dest='search_method', action='store_const', const=dfs, help='Uses DFS search to solve the puzzle') parser.add_argument('--auto-play', dest='run_mode', action='store_const', const=True, help='It plays the solution automatically.') parser.add_argument('--step-by-step', dest='run_mode', action='store_const', const=False, help='It allows to show the solution step-by-step') args = parser.parse_args() solver = Solver(args.puzzlename, args.search_method) solution = solver.solve() SolutionViewer(solver.problem.startState, solution, args.run_mode)
def __init__(self): self._solver = Solver() self._geometric_elements = []
def run_experiment(self): """ Run Experiment with different configurations (input via --argument): 1) --model_type: linear, lstm, social-lstm 2) --socialforce: specify whether dataset is synthetic dataset (True), or real (False) 3) --phase: train or test Trained Models are saved under "Saved_Models/dataset_name/model_name". For a list of possible input arguments run script with --help. """ # ============================== # Check input-configurations # ============================== viz = self.connect2visdom(self.args.viz_server, self.args.viz_port, "losses") if self.args.lstm_pool and self.args.model_type != "social-lstm": print( "WARNING: model_type was changed to social-lstm since Social-Pooling was set to True!" ) self.args.model_type = "social-lstm" elif self.args.model_type == "social-lstm" and not self.args.lstm_pool: print( "WARNING: Social-Pooling was set to True because model_type is specified as social-lstm!" ) self.args.lstm_pool = True if self.args.socialforce: # Get name of dataset and model - for synthetic datasets model name will be of the form: ModelType_UniqueIdentifier parameterinfo = "V0" + str(self.args.V0).replace( ".", "u") + "b" + str(self.args.sigma).replace(".", "u") self.args.model_name = self.args.model_type + "_" + parameterinfo self.args.dataset_name = self.args.dataset_type + "simulated_" + parameterinfo else: # Get name of dataset and model - for real datasets model name will be of the form: ModelType_DatasetName_InputModelName if (self.args.model_type not in self.args.model_name) or ( self.args.dataset_name not in self.args.model_name): self.args.model_name = self.args.model_type + "_" + self.args.dataset_name + "_" + self.args.model_name if self.args.model_name[-1] == "_": self.args.model_name = self.args.model_name[:-1] if not os.path.exists( os.path.join(self.root_path, "datasets", self.args.dataset_name)): raise ValueError( "Specified dataset: %s does not exist! Please check existing datasets and specify one with flag: --dataset_name" % (self.args.dataset_name)) if self.args.phase == "test": # Ensure that for testing we only run one epoch and do not augment the data self.args.num_epochs = 1 self.args.load_model = True self.args.data_augmentation = False # Get configs for data preparation config_data = config_dataprep() # Configurations for logging losses self.log_configs() # ============== # Data prep # ============== dset, loader, dset_val, val_loader = self.load_data( config_data, logger) # ============= # Get model # ============= if self.args.model_type.lower() == "linear": model = LINEAR(self.args) elif self.args.model_type.lower() == "lstm": model = LSTM(self.args) elif self.args.model_type.lower() == "social-lstm": self.args.lstm_pool = True model = LSTM(self.args) else: raise ValueError( "Please choose model_type either: linear, lstm or social-lstm") # =============== # Optimizer # =============== # Define optimizer if self.args.optim.lower() == "adam": config_opt = config_Adam(lr=self.args.lr, weight_decay=self.args.wd) optimizer = torch.optim.Adam( model.parameters(), **{ "lr": config_opt.lr, "betas": config_opt.betas, "eps": config_opt.eps, "weight_decay": config_opt.weight_decay }) elif self.args.optim.lower() == "rmsprop": config_opt = config_RMSprop(lr=self.args.lr, weight_decay=self.args.wd) optimizer = torch.optim.RMSprop( model.parameters(), **{ "lr": config_opt.lr, "alpha": config_opt.alpha, "eps": config_opt.eps, "weight_decay": config_opt.weight_decay }) elif self.args.optim.lower() == "sgd": config_opt = config_SGD(lr=self.args.lr, weight_decay=self.args.wd) optimizer = torch.optim.SGD( model.parameters(), **{ "lr": config_opt.lr, "weight_decay": config_opt.weight_decay, "momentum": config_opt.momentum, "dampening": config_opt.dampening, "nesterov": config_opt.nesterov }) else: raise ValueError("Please specify a valid optimizer with optim!") # ================= # load Model # ================ # Define saving directory for Model saving_directory = os.path.join(self.root_path, "Saved_Models", str(self.args.dataset_name)) if not os.path.exists(saving_directory): print("Create path for saving model: %s" % (saving_directory)) os.makedirs(saving_directory) if self.args.save_model: print("Model will be saved under: " + saving_directory + "/" + self.args.model_name) else: print("Model " + self.args.model_name + " will not be saved") loaded_states = {} loss_history_all = { self.args.dataset_name: { "train": {}, "val": {}, "test": {} } } epochs = 0 if self.args.load_model: print("Loading Model...") if os.path.isfile( os.path.join(str(saving_directory), self.args.model_name)): loaded_states = torch.load( os.path.join(str(saving_directory), self.args.model_name)) model.load_state_dict(loaded_states["model_state_dict"]) device = torch.device("cpu") optimizer.load_state_dict( loaded_states["optimizer_state_dict"]) move_opt_state_to_GPU(optimizer) loss_history_all = loaded_states["loss"] if self.args.dataset_name not in loss_history_all: loss_history_all[self.args.dataset_name] = { "train": {}, "val": {}, "test": {} } if self.args.phase == "train": epochs = loaded_states["epochs"] print("Model loaded...") else: print( "Tried to load model, but model does not exist!\nContinued with new model" ) else: print("Create new Model...") # ================= # Train Model # ================= # Define solver solver = Solver(optim=optimizer, loss_all=loss_history_all, epochs=epochs, args=self.args, server=self.server) # Train/eval Model solver.train(model, self.args.model_type.lower(), loader, val_loader, phase=self.args.phase, log_nth=self.args.log_nth, num_epochs=self.args.num_epochs) # Save Model if self.args.save_model: model.save( solver.optim, solver.loss_history_all, solver.last_epoch, os.path.join(str(saving_directory), self.args.model_name)) # ============== # RESULTS # ============= # Plot Histogram for Distances to other pedestrians in order to avoid collision behavior of models if self.args.phase == "test": if self.args.analyse_coll_avoidance: histo = create_histogram(self.args, self.server) histo.plot_histogram_distances(solver) # Note Results of testing of Socialforce Experiment for further Analysis if self.args.socialforce: if self.args.phase == "test": print( "Writing test losses for Socialforce-Experiment to .xlsx-file..." ) # ============================================================== # For Analysis of overall ADE and FDE for specific V0 and sigma # ============================================================== result_path = os.path.join(self.root_path, "Analyse_Results", "Overall_Loss") if not os.path.exists(result_path): os.makedirs(result_path) file_name = "socialforce_" + str( self.args.model_type) + "_results" if self.args.model_type == "social-lstm": file_name += "_ns_" + str(int( self.args.neighborhood_size)) + "_gs_" + str( int(self.args.grid_size)) file_name += ".xlsx" filepath = os.path.join(result_path, file_name) final_ADE_loss = solver.loss_history_all[ self.args.dataset_name][self.args.phase]["G_ADE"][-1] final_FDE_loss = solver.loss_history_all[ self.args.dataset_name][self.args.phase]["G_FDE"][-1] # Create or Append Excel sheet with ADE and FDE of respective dataset note_test_results_for_socialforce(filepath, self.args, final_ADE_loss, final_FDE_loss) # =========================================== # For Analysis of ADE in non-linear regions # =========================================== if "G_ADE_nl_regions" in model.losses: print("Writing loss in nonlinear Regions to .xlsx-file...") result_path = os.path.join(self.root_path, "Analyse_Results", "Nonlinear_ADE") if not os.path.exists(result_path): os.makedirs(result_path) file_name = "socialforce_nl_loss.xlsx" filepath = os.path.join(result_path, file_name) final_nl_ADE_loss = solver.loss_history_all[ self.args.dataset_name][ self.args.phase]["G_ADE_nl_regions"][-1] note_nonlinear_loss(filepath, self.args, final_ADE_loss, final_nl_ADE_loss) # Note results of best validation ADE loss of training if self.args.phase == "train": print("Writing train losses with configs to .xlsx-file...") result_path = os.path.join(self.root_path, "Stats", "BestVal", self.args.dataset_name) if not os.path.exists(result_path): os.makedirs(result_path) xlsx_file = self.args.dataset_name + "_" + self.args.model_type + ".xlsx" filepath = os.path.join(result_path, xlsx_file) note_best_val(filepath, self.args, solver.best_val, solver.best_val_FDE, solver.best_val_epoch) # Plot losses if self.args.visdom: self.plot_loss_visdom(viz, solver.loss_history_all) else: self.plot_loss(solver.loss_history_all) # Print Hyperparameters as Summary self.log_HyperParameters()
#!/usr/bin/env python # coding=utf-8 ''' @Author: wjm @Date: 2019-10-12 23:50:07 @LastEditTime: 2020-06-23 17:46:46 @Description: main.py ''' from utils.config import get_config from solver.solver import Solver import argparse if __name__ == '__main__': parser = argparse.ArgumentParser(description='N_SR') parser.add_argument('--option_path', type=str, default='option.yml') opt = parser.parse_args() cfg = get_config(opt.option_path) for i in range(2, 3): solver = Solver(cfg, i) solver.run()
from solver.solver import Solver from model.baseline import Baseline """ 创建一个模型, 训练这个模型, 测试这个模型 """ if __name__ == '__main__': print('C2JD Start.') model = Baseline() solver = Solver(model) solver.solve() solver.evaluate() print('C2JD End.')
def test_no_solution_puzzle(self): board = GameBoard('tests/test_no_solution_puzzle.txt') board.read_board() solver = Solver(board) solver.backtrack() self.assertFalse(board.verify_solution())
def test_common_puzzle(self): board = GameBoard('tests/test_puzzle.txt') board.read_board() solver = Solver(board) solver.backtrack() self.assertEqual(board.solution, [[0, 1, 1], [0, 1, 1], [0, 2, 2]])
from solver.solver import Solver solver = Solver() solver.train()
def __init__(self, data_dir): self.jinja_env = Environment( loader=PackageLoader('webserver', 'templates')) self.solver = Solver(data_dir, 100000) self.game_words = self.solver.filter_in_vocab(load_game_words())