def solve_sequence(self): logging.info( '--------------------Solving one sequence---------------------------------' ) self.set_sequence = SetSequence(self.data) self.set_sequence.exec_() sequence = self.set_sequence.set_sequence() sequence.print_sequence() self.one_time_model = Solver(self.data) self.one_time_model.current_data_set = self.current_data_set_number self.one_time_model.load_data_set() self.one_time_model.set_sequence(sequence) while not self.one_time_model.finish: self.one_time_model.next_step() total_error = 0 for truck in itertools.chain( self.one_time_model.outbound_trucks.values(), self.one_time_model.compound_trucks.values()): truck.calculate_error() logging.info("Truck {0}, error {1}\n".format( truck.truck_name, truck.error)) total_error += abs(truck.error) logging.info("Error: {0}\n".format(total_error))
def run_calculator_in_command_line(): print( '--------- ** Run A Scientific Calculator Using Command Line ** ---------' ) print( '** Enter the command "-h" or "help" to show available calculator functions...\n' ) problem = Solver() global valid_answer_previous while True: infix = input('---> ') if infix in ['exit', 'quit']: break elif infix == 'ans': print(valid_answer_previous) elif infix in ["help", "-h"]: helper() else: try: temp_ans = problem.solve(infix) if temp_ans in errors: print(temp_ans) else: if isFloat(temp_ans): temp_ans = float(temp_ans) else: temp_ans = integer_modification(temp_ans) valid_answer_previous = temp_ans print(temp_ans) except: print('Wrong Input')
def main(): # Initiaise the solver solver = Solver(n=3, NUM_TERMS=5, epsilon=1e-4) env = simpy.Environment() env.process(example1(env, solver)) # Run the simulation until all events in the queue are processed. # Make it some number to halt simulation after sometime. env.run()
def main(_): os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu_index solver = Solver(FLAGS) if FLAGS.is_train: solver.train() else: solver.test()
def generate_data_set(self): # ask if sure self.data.arrival_times = [] self.data.boundaries = [] self.model = Solver(self.data) for i in range(len(self.data.data_set_list)): self.model.current_data_set = i self.model.set_data()
def main(): # make a string that describes the current running setup num = 0 run_setup_str = f"{args.source}2{args.target}_k_{args.num_k}_kq_{args.num_kq}_lamb_{args.lamb_marg_loss}" while os.path.exists(f"record/{run_setup_str}_run_{num}.txt"): num += 1 run_setup_str = f"{run_setup_str}_run_{num}" # eg, svhn2mnist_k_4_kq_4_lamb_10.0_run_5 # set file names for records (storing training stats) record_train = f"record/{run_setup_str}.txt" record_test = f"record/{run_setup_str}_test.txt" if not os.path.exists('record'): os.mkdir('record') # create a folder for records if not exist # set the checkpoint dir name (storing model params) checkpoint_dir = f'checkpoint/{run_setup_str}' if not os.path.exists('checkpoint'): os.mkdir('checkpoint') # create a folder if not exist if not os.path.exists(checkpoint_dir): os.mkdir(checkpoint_dir) # create a folder if not exist #### # create a solver: load data, create models (or load existing models), # and create optimizers solver = Solver(args, source=args.source, target=args.target, nsamps_q=args.nsamps_q, lamb_marg_loss=args.lamb_marg_loss, learning_rate=args.lr, batch_size=args.batch_size, optimizer=args.optimizer, num_k=args.num_k, num_kq=args.num_kq, all_use=args.all_use, checkpoint_dir=checkpoint_dir, save_epoch=args.save_epoch) # run it (test or training) if args.eval_only: solver.test(0) else: # training count = 0 for t in range(args.max_epoch): num = solver.train(t, record_file=record_train) count += num if t % 1 == 0: # run it on test data every epoch (and save models) solver.test(t, record_file=record_test, save_model=args.save_model) if count >= 20000 * 10: break
def main(): # Initiaise the solver solver = Solver(epsilon=1e-6) # For higher precision, default is 5 env = simpy.Environment() env.process(example1(env, solver)) # Run the simulation until all events in the queue are processed. # Make it some number to halt simulation after sometime. env.run(until=10.0) print('total steps: ', step)
def main(): # Initiaise the solver solver = Solver(n=5, epsilon=1e-6) env = simpy.Environment() env.process(lorenz(env, solver)) # Run the simulation until all events in the queue are processed. # Make it some number to halt simulation after sometime. env.run(until=STOP_TIME) # Plot the output plt.plot(data['t'], data['x']) plt.show()
def main(config): os.environ["CUDA_VISIBLE_DEVICES"] = str(config["gpu_no"]) save_path = Path(config["training"]["save_path"]) save_path.mkdir(parents=True, exist_ok=True) mode = config["mode"] solver = Solver(config) if mode == "train": solver.train() if mode == "test": solver.test()
def get_answer(expression): problem = Solver() try: temp_ans = problem.solve(expression) if temp_ans in errors: return str(temp_ans) else: global valid_answer_previous if isFloat(temp_ans): temp_ans = float(temp_ans) else: temp_ans = integer_modification(temp_ans) valid_answer_previous = temp_ans return str(temp_ans) except: return 'Wrong Input'
def main(config): os.environ["CUDA_VISIBLE_DEVICES"] = str(config["gpu_no"]) mode = config["mode"] save_path = Path(config["training"]["save_path"]) / config["version"] save_path.mkdir(parents=True, exist_ok=True) config["save_path"] = save_path datasets = DataLoader(mode, **config["dataset"]) solver = Solver(config, datasets) if mode == "train": solver.train() if mode == "test": solver.test()
def evaluate(self, prob_id, tune=False, plot=True): assert prob_id in [1, 2, 3, 4], "Only support evaluation for problems1~4" self.prob_id = prob_id self.base_dir = osp.join(cfg.EVALUATION.ROOT_DIR, "prob" + str(prob_id)) if not osp.exists(self.base_dir): os.makedirs(self.base_dir) self.strategy_path = osp.join(cfg.PROB.PROBLEM_LIST[prob_id - 1], "strategies.pkl") self.csv_path = self.strategy_path[:-3] + "csv" self.hub_path = osp.join(osp.dirname(self.strategy_path), "hubs.pkl") if not tune and not osp.exists(self.strategy_path): key = input( "It seems that you have not run solver for this problem yet. Run Now?(y or n)" ) if key == 'Y' or key == 'y': solver = Solver() solver.solve(problem_id=prob_id) else: print("exit") return if osp.exists(self.strategy_path): self._pkl2csv() avg_amount_cost, avg_time_cost = self.get_avg_cost() print( "For problem {}:\nAverage amount cost:{:.2f} | Average time cost: {:.2f}min" .format(prob_id, avg_amount_cost, avg_time_cost)) # whether we are tuning the parameters if tune: if prob_id == 1: # for problem1 we tune the weight_amount and weight_cost # self.weight_tune() self.weight_plot() elif prob_id == 2: # self.hub_cost_test() self.hub_cost_plot() elif prob_id == 3: # self.hub_cap_test() self.hub_cap_plot() # plot the distribution or not if plot: self.plot_distribution()
def hub_cap_test(self): hub_cap_path = osp.join(self.base_dir, "cap.csv") index = np.where( cfg.EVALUATION.HUB_CAPACITY_FIELD == cfg.PARAM.HUB_CAPACITY)[0] hub_capacity_field = np.insert(cfg.EVALUATION.HUB_CAPACITY_FIELD, index, 0.95 * cfg.PARAM.HUB_CAPACITY) hub_capacity_field = np.insert(hub_capacity_field, index + 2, 1.05 * cfg.PARAM.HUB_CAPACITY) new_dict = edict() num_hubs_list, amount_cost_list, time_cost_list = [], [], [] mask = np.ones_like(hub_capacity_field) for idx, cap in enumerate(hub_capacity_field): new_dict["HUB_CAPACITY"] = cap merge_a_into_b(new_dict, cfg) solver = Solver() solver.solve(problem_id=3, tune_mode=True) with open(self.hub_path, "rb") as f: data = pkl.load(f) num_hubs = len(data["hubs"]) if num_hubs == 0: print("When capacity is :{}. No hubs were built...Continue...". format(cap)) mask[idx] = 0 continue self._pkl2csv() avg_amount_cost, avg_time_cost = self.get_avg_cost() amount_cost_list.append(avg_amount_cost) time_cost_list.append(avg_time_cost) num_hubs_list.append(num_hubs) print( "Hub capacity: {:.0f} | Hubs: {:.0f} | Average amount cost: {:.3f}$ | Average time cost: {:.2f}m." .format(cap, num_hubs, avg_amount_cost, avg_time_cost)) df = pd.DataFrame( data=list( zip(hub_capacity_field[np.nonzero(mask)], num_hubs_list, amount_cost_list, time_cost_list)), columns=["HubCapacity", "NumHubs", "AmountCost", "TimeCost"]) df["Products"] = df["AmountCost"] * df["TimeCost"] df["Values"] = cfg.PARAM.WEIGHT_AMOUNT * df[ "AmountCost"] + cfg.PARAM.WEIGHT_TIME * df["TimeCost"] df.to_csv(hub_cap_path, index=False, float_format="%.2f")
def setup_data_set(self): # setup for one data set self.model = Solver(self.data) self.model.current_data_set = self.current_data_set_number self.model.load_data_set() self.algorithm = self.algorithm_list[self.algorithm_name]( self.number_of_iterations, self.current_data_set_number, self.model, self.data) logging.info("Solving using {0} data set {1}".format( self.algorithm_name, self.current_data_set_number + 1)) logging.info("Nuber of iterations {0}".format( self.number_of_iterations)) self.solve_step_button.setEnabled(True) self.solve_iteration_button.setEnabled(True) self.solve_data_set_button.setEnabled(True) self.solve_sequence_button.setEnabled(True) self.show_solution_button.setEnabled(True) self.show_sequences_button.setEnabled(True)
def __init__(self): super(MainWindow, self).__init__() self.setupUi(self) self.data = DataStore() self.solver_data = SolverData() self.solver = Solver(self.data, self.solver_data) self.update_data_table() self.setup_data() self.value_connections() self.connections() self.combobox_coming_sequence = [] self.combobox_going_sequence = [] self.statusBar().showMessage('Ready') self.load_generated_data() self.results = OrderedDict() self.shoved_solution_name = "" self.shoved_iteration = IterationResults() self.shoved_solution = ModelResult() self.shoved_iteration_number = 0 self.continue_solution = True self.showing_result = [] self.result_times = {} self.function_type = "normal" self.solution_name = "" self.solution_number = 0 self.sequence_solver = SequenceSolver() self.solution_results = dict() self.enter_sequence_widget = EnterSequenceWidget(self.data) self.current_sequence = Sequence() self.load_data() self.simulationStartButton.setEnabled(False) self.simulationStepForwardButton.setEnabled(False) self.result_show_best_solution_button.setEnabled(False) self.result_show_errors_button.setEnabled(False) self.result_show_sequences_button.setEnabled(False) self.result_show_trucktimes_button.setEnabled(False) self.result_show_truckgoods_button.setEnabled(False) self.run_simulation_button.setEnabled(False)
def weight_tune(self): """ tuning the weight of time and weight of cost """ new_dict = edict() weight_data_path = osp.join(self.base_dir, "weight.csv") weight_time_list, weight_amount_list = [], [] amount_cost_list, time_cost_list = [], [] for weight_amount in cfg.EVALUATION.WEIGHT_AMOUNT_FIELD: for weight_time in cfg.EVALUATION.WEIGHT_TIME_FIELD: new_dict["WEIGHT_AMOUNT"] = round(weight_amount, 2) new_dict["WEIGHT_TIME"] = round(weight_time, 2) # merge the config merge_a_into_b(new_dict, cfg) # solve the problem and get the output solver = Solver() solver.solve(problem_id=1, tune_mode=True) # don't forget transform into csv file self._pkl2csv() avg_amount_cost, avg_time_cost = self.get_avg_cost() weight_amount_list.append(round(weight_amount, 2)) weight_time_list.append(round(weight_time, 2)) amount_cost_list.append(avg_amount_cost) time_cost_list.append(avg_time_cost) print( "When weight of amount is {:.2f} and weight of time is:{:.2f}" .format(weight_amount, weight_time)) print( "Average amount cost is: {:.1f}. Average time cost is:{:.1f}" .format(avg_amount_cost, avg_time_cost)) df = pd.DataFrame(data=list( zip(weight_amount_list, weight_time_list, amount_cost_list, time_cost_list)), columns=[ "WeightOfAmount", "WeightOfTime", "AmountCost", "TimeCost" ]) # multiply the two columns to get the products df["Products"] = df["AmountCost"] * df["TimeCost"] df.to_csv(weight_data_path, index=False, float_format="%.2f")
help="the number of orders to parse", type=int, default=2400) parser.add_argument("--process_num", dest="NUM_PROCESSES", help="the number of processes", type=int, default=16) parser.add_argument("--weight_amount", dest="WEIGHT_AMOUNT", help="the weight of the amountCost in the objective function", type=float, default=15) parser.add_argument("--weight_time", dest="WEIGHT_TIME", help="the weight of the timeCost in the objective function", type=float, default=1) parser.add_argument("--hub_cost_const", dest="HUB_BUILT_COST_CONST", help="the constant part of cost of building a hub", type=int, default=3000) parser.add_argument("--hub_cost_vary", dest="HUB_BUILT_COST_VARY", help="the variable part cost of building a hub", type=float, default=2.0) parser.add_argument("--hub_ratio", dest="HUB_UNIT_COST_RATIO", help="the cutoff of unit price of a hub", type=float, default=0.7) parser.add_argument("--hub_capacity", dest="HUB_CAPACITY", help="the capacity of the hub(in prob3)", type=int, default=500) args = parser.parse_args() arg_dict = edict(vars(args)) merge_a_into_b(arg_dict, cfg) print("Using the config:") print(cfg) solver = Solver() evaluator = Evaluator() solver.solve(problem_id=args.PROBLEM_ID) # disable the tune mode but plot the distribution, see the outputs for more detail evaluator.evaluate(prob_id=args.PROBLEM_ID, tune=False, plot=True)
import sys from src.solver import Solver from src.parsing import parse lines = [] for line in sys.stdin: lines.append(line.rstrip('\n')) matrix = parse() solver = Solver(matrix) # print(matrix) # print(solver.is_solved(matrix)) # print(solver.manhattan_distance(matrix)) print(solver.solve(matrix))
num_workers=config['num_workers'], sampler=train_data_sampler) val_data_loader = torch.utils.data.DataLoader( dataset=data_set, batch_size=config['batch_size'], num_workers=config['num_workers'], sampler=val_data_sampler) if config['continue_training']: model = torch.load(config['model_path']) solver = pickle.load(open(config['solver_path'], 'rb')) start_epoch = config['start_epoch'] else: model = EncoderDecoder() solver = Solver(optim_args={ "lr": config['learning_rate'], "betas": config['betas'] }) start_epoch = 0 solver.train(lr_decay=config['lr_decay'], start_epoch=start_epoch, model=model, train_loader=train_data_loader, val_loader=train_data_loader, num_epochs=config['num_epochs'], log_after_iters=config['log_interval'], save_after_epochs=config['save_interval'], lr_decay_interval=config['lr_decay_interval'], save_path=config['save_path'], num_subtasks=config['num_subtasks'])
for net in range(1000): # counter printer print "iteration: ", net # train net1 model1 = FullyConnectedNet([100, 100], weight_scale=0.003, use_batchnorm=False, reg=0.6) solver1 = Solver( model1, data1, print_every=data1['X_train'].shape[0], num_epochs=50, batch_size=100, update_rule='sgd', optim_config={ 'learning_rate': 0.03, }, verbose=False, lr_decay=0.9, ) solver1.train() pass #train net2 model2 = FullyConnectedNet([100, 100], weight_scale=0.003, use_batchnorm=False, reg=0.6) solver2 = Solver( model2,
from src.solver import Solver for i in range(2, 42): runner = Solver() print("========================================================") print(i.__str__() + "begin :: ") runner.run("../dataset/raw_datas/g" + i.__str__())
def main(args): # load dictionary and generate char_list, sos_id, eos_id char_list, sos_id, eos_id = process_dict(args.dict) vocab_size = len(char_list) tr_dataset = AudioDataset('train', args.batch_size) cv_dataset = AudioDataset('dev', args.batch_size) tr_loader = AudioDataLoader(tr_dataset, batch_size=1, num_workers=args.num_workers, shuffle=args.shuffle, feature_dim=args.feature_dim, char_list=char_list, path_list=tr_dataset.path_lst, label_list=tr_dataset.han_lst, LFR_m=args.LFR_m, LFR_n=args.LFR_n) cv_loader = AudioDataLoader(cv_dataset, batch_size=1, num_workers=args.num_workers, feature_dim=args.feature_dim, char_list=char_list, path_list=cv_dataset.path_lst, label_list=cv_dataset.han_lst, LFR_m=args.LFR_m, LFR_n=args.LFR_n) data = {'tr_loader': tr_loader, 'cv_loader': cv_loader} encoder = Encoder(args.d_input * args.LFR_m, args.d_low_dim, args.n_layers_enc, args.n_head, args.d_k, args.d_v, args.d_model, args.d_inner, dropout=args.dropout, pe_maxlen=args.pe_maxlen) decoder = Decoder( sos_id, eos_id, vocab_size, args.d_word_vec, args.n_layers_dec, args.n_head, args.d_k, args.d_v, args.d_model, args.d_inner, dropout=args.dropout, tgt_emb_prj_weight_sharing=args.tgt_emb_prj_weight_sharing, pe_maxlen=args.pe_maxlen) model = Transformer(encoder, decoder) print(model) model.cuda() # optimizer optimizier = TransformerOptimizer( torch.optim.Adam(model.parameters(), betas=(0.9, 0.98), eps=1e-09), args.init_lr, args.d_model, args.warmup_steps) # solver solver = Solver(data, model, optimizier, args) solver.train()
def main(): # torch.set_default_tensor_type('torch.FloatTensor') # set up default cuda device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Load the (preprocessed) CIFAR10 data. The preprocessing includes # channel swapping, normalization and train-val-test splitting. # Loading the datasets might take a while. datasetGen = DatasetGen() datasetGen.BinaryShinyPokemonDataset() data_dict = datasetGen.Subsample([0.6, 0.2, 0.2]) print("Train size: %i" % len(data_dict["X_train"])) print("Val size: %i" % len(data_dict["X_val"])) print("Test size: %i" % len(data_dict["X_test"])) train_data, val_data, test_data = ConvertDatasetDictToTorch(data_dict) from src.solver import Solver from torch.utils.data.sampler import SequentialSampler num_train = len(train_data) OverfitSampler = SequentialSampler(range(num_train)) train_loader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True, num_workers=4) val_loader = torch.utils.data.DataLoader(val_data, batch_size=64, shuffle=False, num_workers=4) ############################################################################ # Hyper parameter Grid search : Set grids below # ############################################################################ print(train_data) lr = 1e-3 kernelsize = 3 hidden_dims = [200] convArray = [64, 128] model = ClassificationCNN(input_dim=[3, 96, 96], num_classes=2, convolutionalDims=convArray, kernel_size=kernelsize, stride_conv=1, weight_scale=0.02, pool=2, stride_pool=2, hiddenDims=hidden_dims, dropout=0.0) model.to(device) solver = Solver(optim_args={"lr": lr, "weight_decay": 1e-3}) print( "training now with values: lr=%s, hidden_dim=%s, filtersize=%s, convArray=%s" % (lr, str(hidden_dims), kernelsize, str(convArray))) solver.train(model, train_loader, val_loader, log_nth=6, num_epochs=10, L1=False, reg=0.1) from src.vis_utils import visualize_grid # first (next) parameter should be convolutional conv_params = next(model.parameters()).cpu().data.numpy() grid = visualize_grid(conv_params.transpose(0, 2, 3, 1)) plt.imshow(grid.astype('uint8')) plt.axis('off') plt.gcf().set_size_inches(6, 6) plt.show()
final_state = [] cnt = 0 print("{:<20} {:<10}".format('PHM positions', 'Failure of critical function')) print("------------- ----------------------------") for state in states: cnt += 1 if select and cnt < number: continue if select and cnt > number: break model_description = model.load_phm(model_description, state) # Build the model bn = BayesianNetwork(model_description) bayesian_model = bn.build() solver = Solver(bayesian_model, display, evidence) e = solver.run(mapquery=False, printed=False) if e < failure: final_state = state failure = e print("{:<20} {:.4E} *".format(cnt, e)) else: print("{:<20} {:.4E}".format(cnt, e)) if details: print('\n=====================\n') model_description = model.load_phm(model_description, final_state) # Build the model bn = BayesianNetwork(model_description) bayesian_model = bn.build() solver = Solver(bayesian_model, display_final, evidence) e = solver.run(mapquery=False, printed=True)
def test_ctor(self): solver = Solver("", "", False) self.assertEqual(solver.name, "") self.assertEqual(solver.quiet_mode, False)
def train(data_dir, epochs, batch_size, model_path, max_hours=None, continue_from=""): # General config # Task related json_dir = data_dir train_dir = data_dir + "tr" valid_dir = data_dir + "cv" sample_rate = 8000 segment_len = 4 cv_maxlen = 6 # Network architecture N = 256 # Number of filters in autoencoder L = 20 # Length of filters in conv autoencoder B = 256 # number of channels in conv blocks - after bottleneck 1x1 conv H = 512 # number of channels in inner conv1d block P = 3 # length of filter in inner conv1d blocks X = 8 # number of conv1d blocks in (also number of dilations) in each repeat R = 4 # number of repeats C = 2 # Number of speakers norm_type = 'gLN' # choices=['gLN', 'cLN', 'BN'] causal = 0 mask_nonlinear = 'relu' use_cuda = 1 half_lr = 1 # Half the learning rate when there's a small improvement early_stop = 1 # Stop learning if no imporvement after 10 epochs max_grad_norm = 5 # gradient clipping shuffle = 1 # Shuffle every epoch # batch_size = 3 num_workers = 4 # optimizer optimizer_type = "adam" lr = 1e-3 momentum = 0 l2 = 0 # Weight decay - l2 norm # save and visualize save_folder = "../egs/models" enable_checkpoint = 0 # enables saving checkpoints # continue_from = save_folder + "/speech_seperation_first_try.pth" # model to continue from # model_path = "speech_separation_first_try_more_epochs.pth" # TODO: Fix this print_freq = 20000 visdom_enabled = 1 visdom_epoch = 1 visdom_id = "Conv-TasNet Training" # TODO: Check what this does arg_solver = (use_cuda, epochs, half_lr, early_stop, max_grad_norm, save_folder, enable_checkpoint, continue_from, model_path, print_freq, visdom_enabled, visdom_epoch, visdom_id) # Datasets and Dataloaders tr_dataset = AudioDataset(train_dir, batch_size, sample_rate=sample_rate, segment=segment_len, max_hours=max_hours) cv_dataset = AudioDataset(valid_dir, batch_size=1, # 1 -> use less GPU memory to do cv sample_rate=sample_rate, segment=-1, cv_maxlen=cv_maxlen, max_hours=max_hours) # -1 -> use full audio tr_loader = AudioDataLoader(tr_dataset, batch_size=1, shuffle=shuffle, num_workers=num_workers) cv_loader = AudioDataLoader(cv_dataset, batch_size=1, num_workers=0) data = {'tr_loader': tr_loader, 'cv_loader': cv_loader} # model model = ConvTasNet(N, L, B, H, P, X, R, C, norm_type=norm_type, causal=causal, mask_nonlinear=mask_nonlinear) # print(model) if use_cuda: model = torch.nn.DataParallel(model) model.cuda() # optimizer if optimizer_type == 'sgd': optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=momentum, weight_decay=l2) elif optimizer_type == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=l2) else: print("Not support optimizer") return # solver solver = Solver(data, model, optimizer, arg_solver) # TODO: Fix solver thing solver.train()
def main(): parser = setup_parser() args = parser.parse_args() solver = Solver(args.text_file) solver.run()
def train(): # path of this file ABS_PATH = os.path.dirname(os.path.abspath(__file__)) + '/' # Year-month-day_Hour-Minute-Second timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S") print("Loading data...") # currently only using AN Dataset train_data, val_data = get_Dataset() train_loader = torch.utils.data.DataLoader(train_data, batch_size=25, shuffle=True, num_workers=0) val_loader = torch.utils.data.DataLoader(val_data, batch_size=25, shuffle=False, num_workers=0) #train_loader = torch.utils.data.DataLoader(train_data, batch_size=25, shuffle=False, num_workers=4, sampler=OverfitSampler(3000)) #val_loader = torch.utils.data.DataLoader(val_data, batch_size=25, shuffle=False,num_workers=2, sampler=OverfitSampler(100)) log_n = 50 # Train acc every x iterations epochs = 20 # x epochs, model gets saved after each completed epoch val_n = 0 # Run validation every x iterations (default: off/0) print("Training for %d epochs." % epochs) model = CNNEmoClassifier(weight_scale=0.0005) solver = Solver(optim_args={'lr': 5e-5}) tic = time.time() solver.train(model, train_loader, val_loader, num_epochs=epochs, log_nth=log_n, val_nth=val_n) temp_time = time.time() - tic m, s = divmod(temp_time, 60) h, m = divmod(m, 60) print('Done after %dh%02dmin%02ds' % (h, m, s)) # Save model model.save("models/model_{}.model".format(timestamp)) plt.subplot(2, 1, 1) plt.plot(solver.train_loss_history, '-', label='train_loss') x = np.linspace(0, len(solver.train_loss_history), len(solver.val_loss_history)) plt.plot(x, solver.val_loss_history, '-o', label='val_loss') plt.legend(loc='upper right') plt.title('Training vs Validation loss | %d Epochs' % epochs) plt.xlabel('iteration') plt.ylabel('loss') plt.subplot(2, 1, 2) plt.plot(solver.train_acc_history, '-o', label='train_acc=%.4f' % (solver.train_acc_history[-1])) plt.plot(solver.val_acc_history, '-o', label='val_acc=%.4f' % (solver.val_acc_history[-1])) plt.legend(loc='upper left') plt.title('Training vs Validation accuracy') plt.xlabel('epoch') plt.ylabel('accuracy') plt.gca().yaxis.grid(True) plt.gcf().set_size_inches(15, 15) plt.tight_layout() plt.savefig(ABS_PATH + 'output/performance_{}.png'.format(timestamp)) plt.gcf().clear() # plot examples: model.eval() # get_pics might not work! If it doesn't, uncomment the old code. test_pics, example_labels, filenames, amount_example_pics = get_pics( train_data, val_data) output = model.forward(Variable(torch.Tensor(test_pics).float()).cuda()) emotions = { 0: 'neutral', 1: 'happy', 2: 'sad', 3: 'surprise', 4: 'fear', 5: 'disgust', 6: 'anger', 7: 'contempt' } print( '0=neutral, 1=happy, 2=sad, 3=surprise, 4=fear, 5=disgust, 6=anger, 7=contempt' ) print( np.argmax(output.data.cpu().numpy(), axis=1, out=np.empty(amount_example_pics, dtype='int64'))) print(example_labels) output = torch.nn.functional.softmax(output).cpu().data.numpy() # plot images and write output under them, very unsure!! Better check on this one! for i in range(amount_example_pics): plt.subplot(amount_example_pics, 1, i + 1) #plt.legend(loc='upper left') plt.title( '%s: Truth=%s, N=%.2e, H=%.2e, Sad=%.2e, Sur=%.2e, F=%.2e, D=%.2e, A=%.2e, C=%.2e' % (filenames[i], emotions[example_labels[i]], list(output[i])[0], list(output[i])[1], list(output[i])[2], list( output[i])[3], list(output[i])[4], list( output[i])[5], list(output[i])[6], list(output[i])[7])) plt.imshow(test_pics[i][0]) plt.tight_layout() plt.savefig(ABS_PATH + 'output/examples_{}.png'.format(timestamp)) plt.gcf().clear()
parser.add_argument('--raw_data_path', type=str, default='', help="rewrite the data path in config file") paras = parser.parse_args() setattr(paras,'gpu',not paras.cpu) setattr(paras,'verbose',not paras.no_msg) config = yaml.load(open(paras.config,'r')) if paras.data_path != '': config['solver']['data_path'] = paras.data_path if paras.raw_data_path != '': config['solver']['raw_data_path'] = paras.raw_data_path random.seed(paras.seed) np.random.seed(paras.seed) torch.manual_seed(paras.seed) if torch.cuda.is_available(): torch.cuda.manual_seed_all(paras.seed) if not paras.rnnlm: if not paras.test: # Train ASR from src.solver import Trainer as Solver else: # Test ASR from src.solver import Tester as Solver else: # Train RNNLM from src.solver import RNNLM_Trainer as Solver solver = Solver(config,paras) solver.load_data() solver.set_model() solver.exec()
default=0, type=int, help='Random seed for reproducible results.', required=False) parser.add_argument('--cpu', action='store_true', help='Disable GPU training') parser.add_argument('--no-msg', action='store_true', help='Hide all messages') args = parser.parse_args() args.gpu = not args.cpu args.verbose = not args.no_msg config = yaml.load(open(args.config, 'r'), Loader=yaml.FullLoader) # Set seed random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if torch.cuda.is_available(): torch.cuda.manual_seed_all(args.seed) # Train from src.solver import Trainer as Solver solver = Solver(config, args) solver.load_data() solver.build_model() solver.exec()