def train(args): train_data = Mnist_Data("./dataset/train.csv", "train") val_data = Mnist_Data("./dataset/train.csv", "val") train_loader = DataLoader(train_data, batch_size=100, shuffle=True) model = CNNModel() model.to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=1e-2) scheduler = StepLR(optimizer, step_size=20, gamma=0.1) epochs = 30 #'''(int) iterations / len(train_data) / batch_size''' best_val_acc = None best_val_loss = None with torch.no_grad(): best_val_acc, best_val_loss = evaluate(model, val_data, criterion) print('Best Validation Accuracy : {}'.format(best_val_acc)) print('Best Validation Loss : {}'.format(best_val_loss)) for epoch in range(epochs): train_loss = 0.0 model.train() for i, (images, labels) in enumerate(tqdm(train_loader)): images = Variable(images.view(100, 1, 28, 28)).to(device) labels = Variable(labels).to(device) # print(images.shape, labels.shape) # print(labels.size()) optimizer.zero_grad() output = model(images) loss = criterion(output, labels) train_loss += loss.item() loss.backward() optimizer.step() if i % 500 == 0: print('Epoch {}/{} : Step {}/{}, Loss: {:.4f}'.format( epoch + 1, 30, i + 1, len(train_loader), loss.item())) with torch.no_grad(): validation_acc, val_loss = evaluate(model, val_data, criterion) model.train() if val_loss < best_val_loss: best_val_loss = val_loss best_val_acc = validation_acc best_epoch = epoch torch.save( model.state_dict(), "saved_models/best_epoch_digit_recognizer_mnist_data_pytorch1.6_lr_1e-2_aug_{}.pth" .format(epoch + 1)) # torch.save(model.state_dict(), "weights_epoch_{}.pth".format(epoch + 1)) print('Best Validation Loss : {}'.format(best_val_loss)) print('Best Validation Accuracy : {}'.format(best_val_acc)) print('Best Epoch: {}'.format(best_epoch + 1)) print( 'Epoch {}/{} Done | Train Loss : {:.4f} | Validation Loss : {:.4f} | Validation Accuracy : {:.4f}' .format(epoch + 1, 30, train_loss / len(train_loader), val_loss, validation_acc)) return best_val_loss
def launch_simplified_mode(tmp_path, models, engine_config): model_name, model_framework, algorithm, preset, _ = SIMPLIFIED_TEST_MODELS[0] algorithm_config = make_algo_config(algorithm, preset) model = models.get(model_name, model_framework, tmp_path) config = merge_configs(model.model_params, engine_config, algorithm_config) _ = optimize(config) output_dir = os.path.join(config.model.exec_log_dir, 'optimized') model = os.path.join(output_dir, config.model.model_name + '.xml') weights = os.path.join(output_dir, config.model.model_name + '.bin') assert os.path.exists(model) assert os.path.exists(weights) paths = [{ 'model': model, 'weights': weights }] config.engine = get_engine_config(model_name) metrics = evaluate( config=config, subset=range(1000), paths=paths) metrics = OrderedDict([(metric.name, np.mean(metric.evaluated_value)) for metric in metrics]) for metric_name, metric_val in metrics.items(): print('{}: {:.4f}'.format(metric_name, metric_val)) return metrics
def main( config_path: Path, dataset_path: Path, predict_path: Path, input_path: Path, evaluate_path: Optional[Path] = None, ) -> None: """ Main function responsible for prediction with passed model. Arguments: Path config_path: Path to main config (of :class:`DefaultConfig` class) Path dataset_path: Path to dataset Path predict_path: Path to file with model predictions Path input_path: Path to file with input data Path evaluate_path: Path to evaluations """ logger.info("Trainer") result = train(config_path=config_path, dataset_path=dataset_path) info = "Pipline required training_config.py with attribute save = True" assert len(vars(result)) != 1, info root = result.model_path.parent.parent logger.info("Predictor") predict( config_path=config_path, input_path=input_path, model_path=result.model_path, predict_path=root / predict_path, val_loader=result.val_loader, ) if evaluate_path: logger.info("Evaluator") evaluate( config_path=config_path, input_path=input_path, predict_path=root / predict_path, evaluate_path=root / evaluate_path, val_loader=result.val_loader, )
def test_sample_compression(_sample_params, tmp_path, models): model_name, model_framework, algorithm, preset, expected_accuracy, custom_mo_config = _sample_params # hack for sample imports because sample app works only from sample directory pot_dir = Path(__file__).parent.parent sys.path.append(str(pot_dir / 'sample')) # pylint: disable=C0415 from openvino.tools.pot.api.samples.classification.classification_sample import optimize_model model = models.get(model_name, model_framework, tmp_path, custom_mo_config=custom_mo_config) data_source, annotations = get_dataset_info('imagenet_1001_classes') args = Dict({ 'model': model.model_params.model, 'dataset': data_source, 'annotation_file': annotations['annotation_file'] }) model_, _ = optimize_model(args) paths = save_model(model_, tmp_path.as_posix(), model_name) model_xml = os.path.join(tmp_path.as_posix(), '{}.xml'.format(model_name)) weights = os.path.join(tmp_path.as_posix(), '{}.bin'.format(model_name)) assert os.path.exists(model_xml) assert os.path.exists(weights) algorithm_config = make_algo_config(algorithm, preset) engine_config = get_engine_config(model_name) config = merge_configs(model.model_params, engine_config, algorithm_config) config.engine = get_engine_config(model_name) metrics = evaluate(config=config, subset=range(1000), paths=paths) metrics = OrderedDict([(metric.name, np.mean(metric.evaluated_value)) for metric in metrics]) for metric_name, metric_val in metrics.items(): print('{}: {:.4f}'.format(metric_name, metric_val)) if metric_name == 'accuracy@top1': assert { metric_name: metric_val } == pytest.approx(expected_accuracy, abs=0.006)
def run_algo(model, model_name, algorithm_config, tmp_path, reference_name): engine_config = get_engine_config(model_name) config = merge_configs(model.model_params, engine_config, algorithm_config) model = load_model(model.model_params) data_loader = create_data_loader(engine_config, model) engine = create_engine(engine_config, data_loader=data_loader, metric=None) pipeline = create_pipeline(algorithm_config.algorithms, engine) with torch.backends.mkldnn.flags(enabled=False): model = pipeline.run(model) paths = save_model(model, tmp_path.as_posix(), reference_name) engine.set_model(model) metrics = evaluate(config=config, subset=range(1000), paths=paths) metrics = OrderedDict([(metric.name, np.mean(metric.evaluated_value)) for metric in metrics]) return metrics, model
def train(args, net): # Get DataLoader data_loader = make_dataloader(args) # Get Optimizer optimizer = make_optimizer(args, net) # Get Criterion criterion = Loss(args=args) # Get Timer timer = Chronometer() # Get Logger logger = Logger(args=args) logger.print_net(net) # Check for Multi GPU Support if torch.cuda.device_count() > 1 and args.mGPU: net = torch.nn.DataParallel(net) # Create a directory for training files if not os.path.exists(args.ckpt): os.mkdir(args.ckpt) start_epoch = args.start_epoch if args.resume: checkpoint = torch.load(args.resumed_ckpt) start_epoch = checkpoint['epoch'] best_accuracy = 0.0 timer.set() for epoch in range(start_epoch, args.epochs): logger('Epoch: {}'.format(epoch + 1), prt=False) epoch_train_loss, is_best = 0.0, False with tqdm(total=len(data_loader), ncols=0, file=sys.stdout, desc='Epoch: {}'.format(epoch + 1)) as pbar: for i, in_batch in enumerate(data_loader): optimizer.zero_grad() in_data, target = in_batch # Load to GPU if torch.cuda.is_available(): in_data, target = in_data.cuda(), target.cuda() # Forward Pass predicted = net(in_data) # Backward Pass loss = criterion(predicted, target) epoch_train_loss += loss.item() loss.backward() optimizer.step() # Update Progressbar if i % 50 == 49: logger('[Train loss/batch: {0:.4f}]'.format(loss.item()), prt=False) pbar.set_postfix(Loss=loss.item()) pbar.update() epoch_train_loss /= len(data_loader) message = 'Average Training Loss : {0:.4f}'.format(epoch_train_loss) logger(message) # Check Performance of the trained Model on test set if epoch % args.evaluate_every_n_epoch == args.evaluate_every_n_epoch - 1: print('Network Evaluation...') net.eval() output = evaluate.evaluate(args, net) net.train() logger(output['message']) if output['accuracy'] > best_accuracy: best_accuracy = output['accuracy'] is_best = True # save the checkpoint as best checkpoint so far save_checkpoint( { 'epoch': epoch + 1, 'net_state_dict': net.module.state_dict() if args.mGPU else net.state_dict() }, is_best, filename=os.path.join(args.ckpt, 'checkpoint.pth.tar'), best_filename=os.path.join(args.ckpt, 'best_checkpoint.pth.tar')) timer.stop() message = 'Finished Trainig Session in {0} hours & {1} minutes, Best Accuracy Achieved: {2:.2f}\n'.format( int(timer.elapsed / 3600), int((timer.elapsed % 3600) / 60), best_accuracy) logger(message) logger.end()
def main(): args = parse_args() cfg = Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.gpus = args.gpus if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') model = APCModel(cfg) load_checkpoint(model, args.checkpoint, strict=True) generater = model.generator generater = MMDataParallel(generater, device_ids=[0]) generater.eval() transform = GroupImageTransform(mean=cfg.img_norm_cfg['mean'], std=cfg.img_norm_cfg['std'], to_rgb=cfg.img_norm_cfg['to_rgb']) video_path = cfg.data.test.v_prefix video_list = os.listdir(video_path) video_list.sort() psnr_records = [] for video in video_list: frame_list = os.listdir(os.path.join(video_path, video)) frame_list.sort() size = len(frame_list) clip_length = cfg.data.test.time_steps + cfg.data.test.num_pred c, w, h = cfg.data.val.scale_size psnrs = np.empty(shape=(size, ), dtype=np.float32) for i in range(clip_length, size - 1): frame_clip = frame_list[i - clip_length:i] frame_arr = [] for frame_path in frame_clip: frame_arr.append( mmcv.imread(os.path.join(video_path, video, frame_path))) frames, img_shape, pad_shape, scale_factor, crop_quadruple = transform( frame_arr, (w, h), keep_ratio=False, div_255=False) frames = to_tensor(frames) size = len(frame_clip) frames = frames.reshape(c * size, w, h).unsqueeze(0) g_t = frames[:, :c * cfg.data.test.time_steps, :, :] g_t_1 = frames[:, c * cfg.data.test.time_steps:, :, :] p_t_1 = generater(g_t) psnr = psnr_error(p_t_1, g_t_1.cuda()) psnrs[i] = psnr psnrs[:clip_length] = psnrs[clip_length] psnr_records.append(psnrs) result_dict = { 'dataset': 'avenue', 'psnr': psnr_records, 'flow': [], 'names': [], 'diff_mask': [] } # # TODO specify what's the actual name of ckpt. pickle_path = '../result/Avenue.pkl' with open(pickle_path, 'wb') as writer: pickle.dump(result_dict, writer, pickle.HIGHEST_PROTOCOL) results = evaluate.evaluate('compute_auc', pickle_path) print(results)
optimizer = optim.Adam(model.parameters()) criterion = CRITERION best_valid_loss = float('inf') print("Starting to train model...") train_losses = [] valid_losses = [] epochs = [] for epoch in range(N_EPOCHS): start_time = time.time() train_loss = train(model, train_iterator, optimizer, criterion, CLIP, epoch) valid_loss = evaluate(model, valid_iterator, criterion) train_losses.append(train_loss) valid_losses.append(valid_loss) epochs.append(epoch) end_time = time.time() epoch_mins, epoch_secs = epoch_time(start_time, end_time) if valid_loss < best_valid_loss: best_valid_loss = valid_loss torch.save(model.state_dict(), 'ckpts/ckpt_%d.pt' % epoch) long_string = f'Epoch: {epoch + 1:02} | Time: {epoch_mins}m {epoch_secs}s\n' +\ f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}\n' + \ f'\t Val. Loss: {valid_loss:.3f} | Val. PPL: {math.exp(valid_loss):7.3f}\n' print(long_string)
def evolutionary_algorithm(init_parameters): str_time = 'Total time: \n' str_function = 'Function: \n' with open("tools/parameters.json") as f: parameters = json.load(f) if 'number_of_iterations' in parameters['config1'].keys(): number_of_iterations = parameters['config1']['number_of_iterations'] else: number_of_iterations = parameters['default']['number_of_iterations'] current_generation = initialise(init_parameters) best_solution = evaluate(current_generation, init_parameters, True, True)[random.randint(0, len(current_generation) - 1)] content = display(best_solution, init_parameters, 0) image_map.loadFromData(content[0]) label_map.setPixmap(image_map) label_best_solution.setText(content[1]) # label_energy.setText(content[2]) label_map.repaint() label_best_solution.repaint() #label_energy.repaint() for i in range(number_of_iterations): print('------------------------------') print('LOOP : ', i + 1) current_generation = evaluate(current_generation, init_parameters, True) parent_generation = current_generation parent_generation = remove_penalties(parent_generation) current_generation = select(current_generation) print('len po select', len(current_generation)) current_generation = mutate(current_generation, init_parameters) print('len po mutate', len(current_generation)) current_generation = evaluate(current_generation, init_parameters, False) current_generation = select_next_generation(parent_generation, current_generation) print('len po select for next gener', len(current_generation)) print("END GENERATION: ", current_generation) current_generation = remove_penalties(current_generation) best_solution = evaluate(current_generation, init_parameters, True, True)[0] content = display(best_solution, init_parameters, i + 1) image_map.loadFromData(content[0]) label_map.setPixmap(image_map) label_best_solution.setText(content[1]) str_time += content[3] str_function += content[4] str_algo_time = '\n' + 'In average solution, for number of iterations 10 and population size of 12,' \ ' we get around 800 requests from gmaps' + '\n' + 'with 50ms per request sums up to 40 seconds ' \ 'plus around 5 seconds for requests from mapbox gives 45 seconds total (33%). ' + '\n' + '' \ 'Total time of algorithm = 140 seconds, time of calculations = 95 seconds (67% of total time).' label_energy.setText(str_time + '\n' + str_function + '\n' + str_algo_time) label_map.repaint() label_best_solution.repaint() label_energy.repaint()
def main( root_path: Path, experiments: str, model_paths: str, input_path: Path, predict_path: Path, config_path: Path, evaluate_path: Path, ) -> Path: """ Main function responsible for prediction with passed model. Arguments: Path root_path: Path to the root folder for the subprocess str experiment_paths: Relative paths to experiments separated by coma Path model_path: Subpath to trained model Path input_path: Path to file with input data Path predict_path: Path to output directory Path config_path: Path to main config (of :class:`DefaultConfig` class) Path evaluate_path: Path to evaluations Returns: Path to the experiment root dir. """ models_with_config = [] data_type = None prediction_bs = None main_config = None zipped = zip(unpack_string(experiments), unpack_string(model_paths)) for index, (experiment, model_path) in enumerate(zipped): config_paths = (root_path / experiment / config_path).iterdir() config = get_config(config_paths) if index == 0: main_config = config model = load_model(config, root_path / experiment / model_path) model.eval() models_with_config.append(dict(model=model, config=config)) data_type = set_param(previous=data_type, current=config.training.dtype, name="dtype") prediction_bs = set_param( previous=prediction_bs, current=config.prediction.batch_size, name="batch_size", ) _, val_loader, _ = DataLoader.get_loaders(input_path, config=main_config) model_preds = [] for model_with_config in models_with_config: model = model_with_config["model"] config = model_with_config["config"] all_preds = torch.tensor([]) for x, _ in tqdm(val_loader, desc="Predictions"): predictions = model(x) processed_preds = pred_transform( preds=predictions, postprocessors=config.postprocessors) all_preds = torch.cat([all_preds, processed_preds]) model_preds.append(all_preds) predictions = two_classifiers(model_preds, loader=val_loader) save_prediction( predictions=predictions, output_path=root_path / predict_path, ) if evaluate_path: logger.info("Evaluator") evaluate( config=main_config, input_path=input_path, predict_path=root_path / predict_path, evaluate_path=root_path / evaluate_path, val_loader=val_loader, )