def get_ng_and_semiprog(): # open model model = common.get_model('NN-Lower') # get data ds = open_data('training').sel(time=slice(100,115)) def integrate_moist(src): return (src * ds.layer_mass).sum('z')/1000 q2 = compute_apparent_source(ds.QT, 86400 * ds.FQT) ng = xr.Dataset({ netprec_name: -integrate_moist(q2), pw_name: integrate_moist(ds.QT) }) # semiprognostic predicted_srcs = model.predict(ds) ds = xr.Dataset({ netprec_name: -integrate_moist(predicted_srcs['QT']), pw_name: integrate_moist(ds.QT) }) return ng, ds
def __init__(self, config_path): # 설정 값을 읽는다. print('Reading config file...') self.config = common.Config(config_path) # 학습 영상 파일들을 읽는다. print('Reading image files...') image_reader = ImageReader(self.config.image_width, self.config.image_height) positive_samples = image_reader.read_from( self.config.positive_data_path) negative_samples = image_reader.read_from( self.config.negative_data_path) # 학습 데이터 형태로 변환한다. print('Preparing training files...') self.train_data = TrainData(positive_samples, negative_samples) print('# of images = {} positives vs. {} negatives'.format( self.train_data.positive_count, self.train_data.negative_count)) # 학습 모델을 생성한다. print('Building training model...') shape = (self.config.image_width, self.config.image_height, 3) self.model = common.get_model(shape, self.config.model_type)
def __init__(self, config_path): """Load trained_model.""" # 환경 설정 값을 읽는다. print('Reading config file...') self.config = common.Config(config_path) # 학습 모델을 읽는다. shape = (self.config.image_width, self.config.image_height, 3) self.model = common.get_model(shape, self.config.model_type) self.model.load_weights(self.config.model_path)
def execute(cls, args: Args): model_spec = _extract_model_spec(args) model = get_model(args.model, model_spec.get_model) cumulative_time = 0.0 for i in range(args.num_iterations): start = time() model.predict(x=model_spec.xs, verbose=0) iteration_time = time() - start if args.iteration_time: print(f'Iteration {i} time: {iteration_time * 1e6}') cumulative_time += iteration_time print( f'Keras performance for model `{model_spec.name}` : {cumulative_time * 1e6}' )
def val(): """Validation.""" torch.backends.cudnn.benchmark = True # model model, model_wrapper = mc.get_model() ema = mc.setup_ema(model) criterion = torch.nn.CrossEntropyLoss(reduction='none').cuda() # TODO(meijieru): cal loss on all GPUs instead only `cuda:0` when non # distributed # check pretrained if FLAGS.pretrained: checkpoint = torch.load(FLAGS.pretrained, map_location=lambda storage, loc: storage) if ema: ema.load_state_dict(checkpoint['ema']) ema.to(get_device(model)) model_wrapper.load_state_dict(checkpoint['model']) logging.info('Loaded model {}.'.format(FLAGS.pretrained)) if udist.is_master(): logging.info(model_wrapper) # data (train_transforms, val_transforms, test_transforms) = \ dataflow.data_transforms(FLAGS) (train_set, val_set, test_set) = dataflow.dataset(train_transforms, val_transforms, test_transforms, FLAGS) _, calib_loader, _, test_loader = dataflow.data_loader( train_set, val_set, test_set, FLAGS) if udist.is_master(): logging.info('Start testing.') FLAGS._global_step = 0 test_meters = mc.get_meters('test') validate(0, calib_loader, test_loader, criterion, test_meters, model_wrapper, ema, 'test') return
def get_data(): model = common.get_model('NN-Lower') ds = open_data('training')\ .chunk({'time': 1})\ .pipe(assign_apparent_sources) outputs = map_dataset(ds, model.call_with_xr, 'time') for key in outputs: ds['F' + key + 'NN'] = outputs[key] output = xr.Dataset() output['net_moist_nn'] = integrate_q2(ds['FQTNN'], ds.layer_mass) output['net_heat_nn'] = integrate_q1(ds['FSLINN'], ds.layer_mass) output['net_moist'] = integrate_q2(ds['Q2'], ds.layer_mass) output['net_heat'] = integrate_q1(ds['Q1'], ds.layer_mass) output['Q1'] = ds['Q1'] output['Q2'] = ds['Q2'] output['Q1nn'] = ds['FSLINN'] output['Q2nn'] = ds['FQTNN'] return output
# collate_fn=collate_fn ) valid_triplets_loader = DataLoader(weak_valid_dl_triplet, batch_size=batch_size, shuffle=False, num_workers=cfg.num_workers, drop_last=True, collate_fn=collate_fn) test_triplets_loader = DataLoader(test_triplets, batch_size=batch_size, shuffle=False, num_workers=cfg.num_workers, drop_last=True, collate_fn=collate_fn) # ######### # # Model and optimizer # ######## if resume_training is None: model_triplet, state = get_model(state, f_args) optimizer, state = get_optimizer(model_triplet, state) LOG.info(model_triplet) pytorch_total_params = sum(p.numel() for p in model_triplet.parameters() if p.requires_grad) LOG.info("number of parameters in the model: {}".format(pytorch_total_params)) model_triplet.train() # scheduler = ReduceLROnPlateau(optimizer, 'min', factor=0.1, patience=5, verbose=True) LOG.info(optimizer) model_triplet = to_cuda_if_available(model_triplet) # ########## # # Callbacks # ########## if cfg.save_best: save_best_call = SaveBest(val_comp="sup")
def train_val_test(): """Train and val.""" torch.backends.cudnn.benchmark = True # For acceleration # model model, model_wrapper = mc.get_model() ema = mc.setup_ema(model) criterion = torch.nn.CrossEntropyLoss(reduction='mean').cuda() criterion_smooth = optim.CrossEntropyLabelSmooth( FLAGS.model_kwparams['num_classes'], FLAGS['label_smoothing'], reduction='mean').cuda() if model.task == 'segmentation': criterion = CrossEntropyLoss().cuda() criterion_smooth = CrossEntropyLoss().cuda() if FLAGS.dataset == 'coco': criterion = JointsMSELoss(use_target_weight=True).cuda() criterion_smooth = JointsMSELoss(use_target_weight=True).cuda() if FLAGS.get('log_graph_only', False): if udist.is_master(): _input = torch.zeros(1, 3, FLAGS.image_size, FLAGS.image_size).cuda() _input = _input.requires_grad_(True) if isinstance(model_wrapper, (torch.nn.DataParallel, udist.AllReduceDistributedDataParallel)): mc.summary_writer.add_graph(model_wrapper.module, (_input, ), verbose=True) else: mc.summary_writer.add_graph(model_wrapper, (_input, ), verbose=True) return # check pretrained if FLAGS.pretrained: checkpoint = torch.load(FLAGS.pretrained, map_location=lambda storage, loc: storage) if ema: ema.load_state_dict(checkpoint['ema']) ema.to(get_device(model)) # update keys from external models if isinstance(checkpoint, dict) and 'model' in checkpoint: checkpoint = checkpoint['model'] if (hasattr(FLAGS, 'pretrained_model_remap_keys') and FLAGS.pretrained_model_remap_keys): new_checkpoint = {} new_keys = list(model_wrapper.state_dict().keys()) old_keys = list(checkpoint.keys()) for key_new, key_old in zip(new_keys, old_keys): new_checkpoint[key_new] = checkpoint[key_old] if udist.is_master(): logging.info('remap {} to {}'.format(key_new, key_old)) checkpoint = new_checkpoint model_wrapper.load_state_dict(checkpoint) if udist.is_master(): logging.info('Loaded model {}.'.format(FLAGS.pretrained)) optimizer = optim.get_optimizer(model_wrapper, FLAGS) # check resume training if FLAGS.resume: checkpoint = torch.load(os.path.join(FLAGS.resume, 'latest_checkpoint.pt'), map_location=lambda storage, loc: storage) model_wrapper = checkpoint['model'].cuda() model = model_wrapper.module # model = checkpoint['model'].module optimizer = checkpoint['optimizer'] for state in optimizer.state.values(): for k, v in state.items(): if isinstance(v, torch.Tensor): state[k] = v.cuda() # model_wrapper.load_state_dict(checkpoint['model']) # optimizer.load_state_dict(checkpoint['optimizer']) if ema: # ema.load_state_dict(checkpoint['ema']) ema = checkpoint['ema'].cuda() ema.to(get_device(model)) last_epoch = checkpoint['last_epoch'] lr_scheduler = optim.get_lr_scheduler(optimizer, FLAGS, last_epoch=(last_epoch + 1) * FLAGS._steps_per_epoch) lr_scheduler.last_epoch = (last_epoch + 1) * FLAGS._steps_per_epoch best_val = extract_item(checkpoint['best_val']) train_meters, val_meters = checkpoint['meters'] FLAGS._global_step = (last_epoch + 1) * FLAGS._steps_per_epoch if udist.is_master(): logging.info('Loaded checkpoint {} at epoch {}.'.format( FLAGS.resume, last_epoch)) else: lr_scheduler = optim.get_lr_scheduler(optimizer, FLAGS) # last_epoch = lr_scheduler.last_epoch last_epoch = -1 best_val = 1. if not FLAGS.distill: train_meters = mc.get_meters('train', FLAGS.prune_params['method']) val_meters = mc.get_meters('val') else: train_meters = mc.get_distill_meters('train', FLAGS.prune_params['method']) val_meters = mc.get_distill_meters('val') if FLAGS.model_kwparams.task == 'segmentation': best_val = 0. if not FLAGS.distill: train_meters = mc.get_seg_meters('train', FLAGS.prune_params['method']) val_meters = mc.get_seg_meters('val') else: train_meters = mc.get_seg_distill_meters( 'train', FLAGS.prune_params['method']) val_meters = mc.get_seg_distill_meters('val') FLAGS._global_step = 0 if not FLAGS.resume and udist.is_master(): logging.info(model_wrapper) assert FLAGS.profiling, '`m.macs` is used for calculating penalty' # if udist.is_master(): # model.apply(lambda m: print(m)) if FLAGS.profiling: if 'gpu' in FLAGS.profiling: mc.profiling(model, use_cuda=True) if 'cpu' in FLAGS.profiling: mc.profiling(model, use_cuda=False) if FLAGS.dataset == 'cityscapes': (train_set, val_set, test_set) = seg_dataflow.cityscapes_datasets(FLAGS) segval = SegVal(num_classes=19) elif FLAGS.dataset == 'ade20k': (train_set, val_set, test_set) = seg_dataflow.ade20k_datasets(FLAGS) segval = SegVal(num_classes=150) elif FLAGS.dataset == 'coco': (train_set, val_set, test_set) = seg_dataflow.coco_datasets(FLAGS) # print(len(train_set), len(val_set)) # 149813 104125 segval = None else: # data (train_transforms, val_transforms, test_transforms) = dataflow.data_transforms(FLAGS) (train_set, val_set, test_set) = dataflow.dataset(train_transforms, val_transforms, test_transforms, FLAGS) segval = None (train_loader, calib_loader, val_loader, test_loader) = dataflow.data_loader(train_set, val_set, test_set, FLAGS) # get bn's weights if FLAGS.prune_params.use_transformer: FLAGS._bn_to_prune, FLAGS._bn_to_prune_transformer = prune.get_bn_to_prune( model, FLAGS.prune_params) else: FLAGS._bn_to_prune = prune.get_bn_to_prune(model, FLAGS.prune_params) rho_scheduler = prune.get_rho_scheduler(FLAGS.prune_params, FLAGS._steps_per_epoch) if FLAGS.test_only and (test_loader is not None): if udist.is_master(): logging.info('Start testing.') test_meters = mc.get_meters('test') validate(last_epoch, calib_loader, test_loader, criterion, test_meters, model_wrapper, ema, 'test') return # already broadcast by AllReduceDistributedDataParallel # optimizer load same checkpoint/same initialization if udist.is_master(): logging.info('Start training.') for epoch in range(last_epoch + 1, FLAGS.num_epochs): # train results = run_one_epoch(epoch, train_loader, model_wrapper, criterion_smooth, optimizer, lr_scheduler, ema, rho_scheduler, train_meters, phase='train') if (epoch + 1) % FLAGS.eval_interval == 0: # val results, model_eval_wrapper = validate(epoch, calib_loader, val_loader, criterion, val_meters, model_wrapper, ema, 'val', segval, val_set) if FLAGS.prune_params['method'] is not None and FLAGS.prune_params[ 'bn_prune_filter'] is not None: prune_threshold = FLAGS.model_shrink_threshold # 1e-3 masks = prune.cal_mask_network_slimming_by_threshold( get_prune_weights(model_eval_wrapper), prune_threshold ) # get mask for all bn weights (depth-wise) FLAGS._bn_to_prune.add_info_list('mask', masks) flops_pruned, infos = prune.cal_pruned_flops( FLAGS._bn_to_prune) log_pruned_info(mc.unwrap_model(model_eval_wrapper), flops_pruned, infos, prune_threshold) if not FLAGS.distill: if flops_pruned >= FLAGS.model_shrink_delta_flops \ or epoch == FLAGS.num_epochs - 1: ema_only = (epoch == FLAGS.num_epochs - 1) shrink_model(model_wrapper, ema, optimizer, FLAGS._bn_to_prune, prune_threshold, ema_only) model_kwparams = mb.output_network(mc.unwrap_model(model_wrapper)) if udist.is_master(): if FLAGS.model_kwparams.task == 'classification' and results[ 'top1_error'] < best_val: best_val = results['top1_error'] logging.info( 'New best validation top1 error: {:.4f}'.format( best_val)) save_status(model_wrapper, model_kwparams, optimizer, ema, epoch, best_val, (train_meters, val_meters), os.path.join(FLAGS.log_dir, 'best_model')) elif FLAGS.model_kwparams.task == 'segmentation' and FLAGS.dataset != 'coco' and results[ 'mIoU'] > best_val: best_val = results['mIoU'] logging.info('New seg mIoU: {:.4f}'.format(best_val)) save_status(model_wrapper, model_kwparams, optimizer, ema, epoch, best_val, (train_meters, val_meters), os.path.join(FLAGS.log_dir, 'best_model')) elif FLAGS.dataset == 'coco' and results > best_val: best_val = results logging.info('New Result: {:.4f}'.format(best_val)) save_status(model_wrapper, model_kwparams, optimizer, ema, epoch, best_val, (train_meters, val_meters), os.path.join(FLAGS.log_dir, 'best_model')) # save latest checkpoint save_status(model_wrapper, model_kwparams, optimizer, ema, epoch, best_val, (train_meters, val_meters), os.path.join(FLAGS.log_dir, 'latest_checkpoint')) return
args['glove'], args['embedding_size']) # create tester print("===> creating dataloaders ...") val_loader = common.get_data_loader(args['model'], 'test', d_word_index, args['batch_size'], args['max_sentence_length'], pdtb_category=args['pdtb_category']) # load model,optimizer and loss model, optimizer, criterion = common.get_model( model=args['model'], model_path=results_path, lr=args['learning_rate'], weight_decay=args['weight_decay'], pdtb_category=args['pdtb_category']) print(optimizer) print(criterion) if args['cuda']: torch.backends.cudnn.enabled = True cudnn.benchmark = True model.cuda() criterion = criterion.cuda() if args['model'] == 'grn16': common.test_grn16(val_loader, model, criterion, args['cuda'], args['print_freq']) elif args['model'] == 'keann':
d_word_index, args['batch_size'], args['max_sentence_length'], pdtb_category=args['pdtb_category']) print('===> dataloader creatin: {t:.3f}'.format(t=time.time() - end)) # create model print("===> creating rnn model ...") vocab_size = len(d_word_index) model, optimizer, criterion = common.get_model( model=args['model'], model_path=results_path, vocab_size=vocab_size, embedding_size=embedding_size, classes=args['classes'], rnn_model=args['rnn'], mean_seq=args['mean_seq'], hidden_size=args['hidden_size'], embed=embed, layers=args['layers'], lr=args['learning_rate'], weight_decay=args['weight_decay'], pdtb_category=args['pdtb_category']) print(model) print(optimizer) print(criterion) if args['cuda']: torch.backends.cudnn.enabled = True cudnn.benchmark = True model.cuda() criterion = criterion.cuda()
params_name = { "early_stopping": cfg.early_stopping, "conv_dropout": cfg.conv_dropout, "frames": cfg.frames_in_sec, } params_name.update(args.__dict__) base_model_name = get_model_name(params_name) # Model state = { "scaler": scaler.state_dict(), "many_hot_encoder": many_hot_encoder.state_dict(), "args": vars(args), } model, state = get_model(state, args) optimizer, state = get_optimizer(model, state) model = to_cuda_if_available(model) LOG.info(model) # ########## # # Callbacks # ########## if cfg.save_best: save_best_call = SaveBest(val_comp="sup") if cfg.early_stopping is not None: early_stopping_call = EarlyStopping(patience=cfg.early_stopping, val_comp="sup") # lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5) # x, y = next(iter(train_loader))
d_word_index, args.batch_size, args.max_sentence_length, pdtb_category=args.pdtb_category) print('===> dataloader creatin: {t:.3f}'.format(t=time.time() - end)) # create model print("===> creating rnn model ...") vocab_size = len(d_word_index) model, optimizer, criterion = common.get_model( model=args.model, model_path=results_path, vocab_size=vocab_size, embedding_size=embedding_size, classes=args.classes, rnn_model=args.rnn, mean_seq=args.mean_seq, hidden_size=args.hidden_size, embed=embed, layers=args.layers, lr=args.lr, weight_decay=args.weight_decay, pdtb_category=args.pdtb_category) print(model) print(optimizer) print(criterion) if args.cuda: torch.backends.cudnn.enabled = True cudnn.benchmark = True model.cuda() criterion = criterion.cuda()
def execute(cls, args: Args): model_spec = _extract_model_spec(args) model = get_model(args.model, model_spec.get_model) scores = model.evaluate(x=model_spec.xs, y=model_spec.ys, verbose=0) print( f'Keras accuracy for the model `{model_spec.name}` is {scores[1]}')
def execute(cls, args: Args): model_spec = _extract_model_spec(args) model = get_model(args.model, model_spec.get_model) model_file_path = get_model_file_path(model_name=args.model) save_model(model, model_file_path) print(f'Model has been saved to "{model_file_path}"')
from src.data import open_data import common import pandas as pd # bootstrap sample size n = 20 hatch_threshold = 10 # compute jacobians training = open_data('training') training['region'] = common.get_regions(training.y) tropics = training.isel(y=slice(30,34)).load() tropics['time_of_day'] = tropics.time % 1 p = tropics.p[0].values model = common.get_model('NN-All') samples = list(bootstrap_samples(tropics, n)) jacobians = [get_jacobian(model, sample) for sample in samples] # make plot fig, axs = plt.subplots( 4, 5, figsize=(common.textwidth, common.textwidth-2), sharex=True, sharey=True) plt.rcParams['hatch.color'] = '0.5' axs[0,0].invert_yaxis() axs[0,0].invert_xaxis() norm = SymLogNorm(1, 2, vmin=-1e5, vmax=1e5) for ax, jac in zip(axs.flat, jacobians): qt_qt = jac['QT']['QT'].detach().numpy() im = ax.pcolormesh(p, p, qt_qt, vmin=-2, vmax=2, cmap='RdBu_r', rasterized=True)
def train_val_test(): """Train and val.""" torch.backends.cudnn.benchmark = True # model model, model_wrapper = mc.get_model() ema = mc.setup_ema(model) criterion = torch.nn.CrossEntropyLoss(reduction='none').cuda() criterion_smooth = optim.CrossEntropyLabelSmooth( FLAGS.model_kwparams['num_classes'], FLAGS['label_smoothing'], reduction='none').cuda() # TODO(meijieru): cal loss on all GPUs instead only `cuda:0` when non # distributed if FLAGS.get('log_graph_only', False): if udist.is_master(): _input = torch.zeros(1, 3, FLAGS.image_size, FLAGS.image_size).cuda() _input = _input.requires_grad_(True) mc.summary_writer.add_graph(model_wrapper, (_input, ), verbose=True) return # check pretrained if FLAGS.pretrained: checkpoint = torch.load(FLAGS.pretrained, map_location=lambda storage, loc: storage) if ema: ema.load_state_dict(checkpoint['ema']) ema.to(get_device(model)) # update keys from external models if isinstance(checkpoint, dict) and 'model' in checkpoint: checkpoint = checkpoint['model'] if (hasattr(FLAGS, 'pretrained_model_remap_keys') and FLAGS.pretrained_model_remap_keys): new_checkpoint = {} new_keys = list(model_wrapper.state_dict().keys()) old_keys = list(checkpoint.keys()) for key_new, key_old in zip(new_keys, old_keys): new_checkpoint[key_new] = checkpoint[key_old] logging.info('remap {} to {}'.format(key_new, key_old)) checkpoint = new_checkpoint model_wrapper.load_state_dict(checkpoint) logging.info('Loaded model {}.'.format(FLAGS.pretrained)) optimizer = optim.get_optimizer(model_wrapper, FLAGS) # check resume training if FLAGS.resume: checkpoint = torch.load(os.path.join(FLAGS.resume, 'latest_checkpoint.pt'), map_location=lambda storage, loc: storage) model_wrapper.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) if ema: ema.load_state_dict(checkpoint['ema']) ema.to(get_device(model)) last_epoch = checkpoint['last_epoch'] lr_scheduler = optim.get_lr_scheduler(optimizer, FLAGS) lr_scheduler.last_epoch = (last_epoch + 1) * FLAGS._steps_per_epoch best_val = extract_item(checkpoint['best_val']) train_meters, val_meters = checkpoint['meters'] FLAGS._global_step = (last_epoch + 1) * FLAGS._steps_per_epoch if udist.is_master(): logging.info('Loaded checkpoint {} at epoch {}.'.format( FLAGS.resume, last_epoch)) else: lr_scheduler = optim.get_lr_scheduler(optimizer, FLAGS) # last_epoch = lr_scheduler.last_epoch last_epoch = -1 best_val = 1. train_meters = mc.get_meters('train') val_meters = mc.get_meters('val') FLAGS._global_step = 0 if not FLAGS.resume and udist.is_master(): logging.info(model_wrapper) if FLAGS.profiling: if 'gpu' in FLAGS.profiling: mc.profiling(model, use_cuda=True) if 'cpu' in FLAGS.profiling: mc.profiling(model, use_cuda=False) # data (train_transforms, val_transforms, test_transforms) = dataflow.data_transforms(FLAGS) (train_set, val_set, test_set) = dataflow.dataset(train_transforms, val_transforms, test_transforms, FLAGS) (train_loader, calib_loader, val_loader, test_loader) = dataflow.data_loader(train_set, val_set, test_set, FLAGS) if FLAGS.test_only and (test_loader is not None): if udist.is_master(): logging.info('Start testing.') test_meters = mc.get_meters('test') validate(last_epoch, calib_loader, test_loader, criterion, test_meters, model_wrapper, ema, 'test') return # already broadcast by AllReduceDistributedDataParallel # optimizer load same checkpoint/same initialization if udist.is_master(): logging.info('Start training.') for epoch in range(last_epoch + 1, FLAGS.num_epochs): # train results = run_one_epoch(epoch, train_loader, model_wrapper, criterion_smooth, optimizer, lr_scheduler, ema, train_meters, phase='train') # val results = validate(epoch, calib_loader, val_loader, criterion, val_meters, model_wrapper, ema, 'val') if results['top1_error'] < best_val: best_val = results['top1_error'] if udist.is_master(): save_status(model_wrapper, optimizer, ema, epoch, best_val, (train_meters, val_meters), os.path.join(FLAGS.log_dir, 'best_model.pt')) logging.info( 'New best validation top1 error: {:.4f}'.format(best_val)) if udist.is_master(): # save latest checkpoint save_status(model_wrapper, optimizer, ema, epoch, best_val, (train_meters, val_meters), os.path.join(FLAGS.log_dir, 'latest_checkpoint.pt')) wandb.log( { "Validation Accuracy": 1. - results['top1_error'], "Best Validation Accuracy": 1. - best_val }, step=epoch) # NOTE(meijieru): from scheduler code, should be called after train/val # use stepwise scheduler instead # lr_scheduler.step() return
parser.add_argument('--pdtb-category', default='Comparison', choices=['Comparison', 'Contingency', 'Temporal', 'Expansion', ''], help='PDTB category') args = parser.parse_args() d_word_index, results_path = common.get_word_index(args.model, args.glove, args.embedding_size) # create tester print("===> creating dataloaders ...") val_loader = common.get_data_loader(args.model, 'test', d_word_index, args.batch_size, args.max_sentence_length, pdtb_category=args.pdtb_category) # load model,optimizer and loss model, optimizer, criterion = common.get_model(model=args.model, model_path=results_path, lr=args.lr, weight_decay=args.weight_decay, pdtb_category=args.pdtb_category) print(optimizer) print(criterion) if args.cuda: torch.backends.cudnn.enabled = True cudnn.benchmark = True model.cuda() criterion = criterion.cuda() if args.model == 'grn16': common.test_grn16(val_loader, model, criterion, args.cuda, args.print_freq) elif args.model == 'keann': common.test_keann(val_loader, model, criterion, args.cuda, args.print_freq)
train_set_emb = DataLoadDf(train_weak_df, many_hot_encoder.encode_weak, transform=Compose(trans_emb)) valid_set_val = DataLoadDf(valid_weak_df, many_hot_encoder.encode_weak, transform=Compose(trans_emb)) test_set_val = DataLoadDf(test_df, many_hot_encoder.encode_weak, transform=Compose(trans_emb)) emb_state = { "scaler": scaler.state_dict(), "many_hot_encoder": many_hot_encoder.state_dict() } emb_model, emb_state = get_model(emb_state, args) emb_model = to_cuda_if_available(emb_model) # Classif_model if args.segment: X, y = train_set[0] else: X, y = next(iter(train_load)) X = to_cuda_if_available(X) emb = emb_model(X) LOG.info("shape input CNN: x {}, y {}".format(X.shape, y.shape)) LOG.info("shape after CNN: {}".format(emb.shape)) if args.n_layers_classif == 2: dimensions = [32, 16] elif args.n_layers_classif == 1: dimensions = [32]