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())
