def main(): # Init # Init env env = gym.make('CartPole-v0') # Init Hyperparam. discount_f = 1 num_episode = 64 num_iter = 100 reward_list = [] # Init net model # TODO: Find a method to get the shape of obs l_obs = 4 n_action = env.action_space.n net = Net(128, 128, l_obs, n_action) net.apply(model.weight_init) # Init optim optimizer = torch.optim.Adam(net.parameters(), lr=0.01) # iteration for i in range(num_iter): # episode rollout traj = model.Trajectory() for episode in range(num_episode): obs = env.reset() step = 0 next_obs = None step_reward = 0 total_reward = 0 done = False while not done: if next_obs is not None: obs = next_obs obs = torch.tensor(obs).float() action = action_decide(net, obs) next_obs, step_reward, done, info = env.step(action) total_reward += (discount_f ** step) * step_reward traj.add(obs, action, total_reward) if done: reward_list.append(total_reward) step += 1 train(net, optimizer, traj) return reward_list
def tunning_func(config): # Hyperparam selected for tunning: discount_f, num_episode, num_fc discount_f = config['discount_f'] num_fc = config['num_fc'] lr = config['lr'] env = gym.make(env_name) l_obs = 6 n_action = env.action_space.n env.close() net = Net(num_fc, num_fc, l_obs, n_action) net.apply(model.weight_init) # Init optim optimizer = torch.optim.Adam(net.parameters(), lr=lr) train(net, optimizer, discount_f) test(net)
def main(): # Init # Init env env = gym.make('CartPole-v0') # Init net model # TODO: Find a method to get the shape of obs l_obs = 4 n_action = env.action_space.n net = Net(128, 128, l_obs, n_action) net.apply(model.weight_init) # Init optim optimizer = torch.optim.Adam(net.parameters(), lr=0.01) # episode start for i_episode in range(num_episode): obs = env.reset() next_obs = None reward = 0 total_reward = 0 done = False traj = Trajectory() while not done: if next_obs is not None: obs = next_obs obs = torch.tensor(obs).float() action = action_decide(net, obs) next_obs, reward, done, info = env.step(action) traj.add(obs, action, reward) total_reward += reward if i_episode % 100 == 0: env.render() if done: train(net, optimizer, traj) reward_list.append(total_reward) env.close() return reward_list
clear() parser = get_args() model_save_path =parser.save_path if not os.path.isdir(model_save_path): os.mkdir(model_save_path) data_path = parser.data_path assert data_path and os.path.isdir(data_path), 'Wrong Data path' model = Net() if parser.parallel: model=torch.nn.DataParallel(model).cuda() else: model=model.cuda() model.apply(initialize_weights) print("Weights initialized by kaiming initialization") optimizer = optim.Adam(model.parameters(), lr=float(parser.lr),betas=(float(parser.beta1),float(parser.beta2))) first=0 if parser.pre_trained: pre=1 assert os.path.exists(parser.pre_trained_path), 'Wrong path for pre-trained model' model_dict = model.state_dict() state_dict = torch.load(parser.pre_trained_path) state_dict = {k: v for k, v in state_dict.items() if k in model_dict} model_dict.update(state_dict) model.load_state_dict(state_dict)
### Data Initialization and Loading train_ids = load_data.train_ids num_train = len(train_ids) num_valid = num_train // 10 # integer division num_train -= num_valid train_indices = np.arange(num_train) valid_indices = np.arange(num_train, num_train + num_valid) from model import Net, weight_init ### Neural Network and Optimizer # We define neural net in model.py so that it can be reused by the evaluate.py script model = Net() model.apply(weight_init) optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) ''' for parameter in model.parameters(): print(parameter) ''' def train(epoch, train_loader): model.train() train_data_loss_in = [] train_num = 0 for batch_idx, (data, target) in enumerate(train_loader): train_num += 1 data, target = Variable(data), Variable(target) optimizer.zero_grad()
def main(config): if config.model_path is None: config.model_path = 'model' os.system('mkdir {0}'.format(config.model_path)) config.manualSeed = random.randint(1, 10000) # fix seed logging.info("Random Seed: %f"%(config.manualSeed)) random.seed(config.manualSeed) np.random.seed(config.manualSeed) torch.manual_seed(config.manualSeed) train_dataset = ScitsrDataset(config.train_data) dev_dataset = ScitsrDataset(config.dev_data) train_loader = DataLoader(train_dataset, batch_size=config.batch_size, shuffle=True) device = torch.device("cpu") model = Net(config.num_node_features, config.num_class) model.cuda() model.apply(weights_init) # criterion = torch.nn.NLLLoss() criterion = torch.nn.CrossEntropyLoss() if config.cuda: model.cuda() criterion = criterion.cuda() # loss averager loss_avg = utils.averager() optimizer = optim.Adam(model.parameters(), lr=config.lr, betas=(config.beta1, 0.999)) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.1) def evaluate(net, dataset, criterion, max_iter=100): for p in net.parameters(): p.requires_grad = False net.eval() data_loader = DataLoader(dataset, batch_size=config.batch_size) val_iter = iter(data_loader) i = 0 n_correct = 0 n_total = 0 table_correct = 0 table_total = 0 loss_avg = utils.averager() # max_iter = min(max_iter, len(data_loader)) max_iter = len(data_loader) for i in range(max_iter): data = val_iter.next() i += 1 out_pred = net(data) loss = criterion(out_pred, data.y.cuda()) loss_avg.add(loss) _, out_pred = out_pred.max(1) label = data.y.detach().cpu().numpy() out_pred = out_pred.detach().cpu().numpy() if (label == out_pred).all(): table_correct = table_correct + 1 table_total = table_total + 1 n_correct = n_correct + (label == out_pred).sum() n_total = n_total + label.shape[0] # print("correct:",n_correct,label.shape[0]) accuracy = n_correct / float(n_total) table_accuracy = table_correct / float(table_total) logging.info('Test cell loss: %f, accuray: %f' % (loss_avg.val(), accuracy)) logging.info('Test one table loss: %f, accuray: %f' % (loss_avg.val(), table_accuracy)) return loss_avg def train(): for epoch in range(config.num_epoch): train_iter = iter(train_loader) i = 0 while i < len(train_loader): for p in model.parameters(): p.requires_grad = True model.train() data = train_iter.next() out_pred = model(data) loss = criterion(out_pred, data.y.cuda()) model.zero_grad() loss.backward() optimizer.step() loss_avg.add(loss) i += 1 if i % config.displayInterval == 0: logging.info('[%d/%d][%d/%d] Loss: %f' % (epoch, config.num_epoch, i, len(train_loader), loss_avg.val())) loss_avg.reset() if epoch % config.valInterval == 0: loss_val = evaluate(model, dev_dataset, criterion) scheduler.step(loss_val.val()) if epoch % config.saveInterval == 0: torch.save(model.state_dict(), '{0}/net_{1}_{2}.pth'.format(config.model_path, epoch, i)) # for k,v in crnn.state_dict().items(): # print(k) train()
def main(): cudnn.benchmark = True train_data = Dataset_cave_train('./data/train') print('number of train data: ', len(train_data)) val_data = Dataset_cave_val('./data/test') print('number of validate data: ', len(val_data)) # Model model = Net(HSI_num_residuals=args.HSI_num_residuals, RGB_num_residuals=args.RGB_num_residuals) # multi-GPU setup device = torch.device("cuda:0, 1" if torch.cuda.is_available() else "cpu") model = nn.DataParallel(model) model = model.to(device=device, dtype=torch.float) # float32 model.apply(weights_init_kaiming) # Parameters, Loss and Optimizer start_epoch = 0 end_epoch = 501 init_lr = 0.0002 iteration = 0 criterion = MyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=init_lr, betas=(0.9, 0.999), eps=1e-08, weight_decay=0) # scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=10, verbose=False, # threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08) model_path = args.model_path if not os.path.exists(model_path): os.makedirs(model_path) loss_csv = open(os.path.join(model_path, 'loss.csv'), 'w+') log_dir = os.path.join(model_path, 'train.log') logger = initialize_logger(log_dir) # Resume resume_file = '' if resume_file: if os.path.isfile(resume_file): print("=> loading checkpoint '{}'".format(resume_file)) checkpoint = torch.load(resume_file) # start_epoch = checkpoint['epoch'] # iteration = checkpoint['iter'] model.load_state_dict(checkpoint['state_dict']) # optimizer.load_state_dict(checkpoint['optimizer']) for epoch in range(start_epoch + 1, end_epoch): train_data = Dataset_cave_train('./data/train') train_data_loader = DataLoader( dataset=train_data, num_workers=8, batch_size=16, shuffle=True, pin_memory=True, ) val_data = Dataset_cave_val('./data/test') val_data_loader = DataLoader(dataset=val_data, num_workers=8, batch_size=16, shuffle=False, pin_memory=True) start_time = time.time() train_loss, iteration = train(train_data_loader, model, criterion, optimizer, iteration, device) val_loss = validate(val_data_loader, model, criterion, device) # Save model if epoch % 100 == 0: save_checkpoint(model_path, epoch, iteration, model, optimizer) # # Update learning rate for param_group in optimizer.param_groups: lr = param_group['lr'] # scheduler.step(val_loss) # print loss end_time = time.time() epoch_time = end_time - start_time print( "Epoch [%d], Iter[%d], Time:%.9f, learning rate : %.9f, Train Loss: %.9f Test Loss: %.9f " % (epoch, iteration, epoch_time, lr, train_loss, val_loss)) # save loss record_loss(loss_csv, epoch, iteration, epoch_time, lr, train_loss, val_loss) # 调用record_方法:将epoch等6个指标写到csv文件中 logger.info( "Epoch [%d], Iter[%d], Time:%.9f, learning rate : %.9f, Train Loss: %.9f Test Loss: %.9f " % (epoch, iteration, epoch_time, lr, train_loss, val_loss))
def kfold_nn(train_df, test_df, stratified=False, num_folds=5, debug=False, name="", need_result=False, fold_random_state=42): print("Starting Neural Net. Train shape: {}, test shape: {}".format( train_df.shape, test_df.shape)) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False np.random.seed(0) torch.manual_seed(0) batchsize = 1024 FOLDs = KFold(n_splits=num_folds, shuffle=True, random_state=fold_random_state) oof_xgb = np.zeros(len(train_df)) sub_preds = np.zeros(len(test_df)) feats = [f for f in train_df.columns if f not in FEATS_EXCLUDED] feats = [ f for f in feats if len(train_df[f].unique()) > 1 and len(test_df[f].unique()) > 1 ] for col in sorted(feats): print(col) print("### use feature number:", len(feats)) params = {"input_dim": len(feats), "output_dim": 1} criterion = nn.MSELoss() folder_name = "nn_subm_cv_normed/" test_pickle_name = f"{folder_name}/test_feats.pickle" if os.path.exists(test_pickle_name): with open(test_pickle_name, "rb") as pkl: test_df[feats] = pickle.load(pkl) else: test_df[feats] = preprocess_for_nn(test_df[feats]) if os.path.exists(folder_name) is False: os.mkdir(folder_name) with open(test_pickle_name, "wb") as pkl: pickle.dump(test_df[feats], pkl) test_iter = DataLoader(torch.FloatTensor(test_df[feats].values), batch_size=batchsize, shuffle=False) losses = {"train": [], "valid": []} transformed_folder_path = "./transformed_normed" if os.path.exists(transformed_folder_path) is False: os.mkdir(transformed_folder_path) for fold_, (trn_idx, val_idx) in enumerate( FOLDs.split(train_df[feats], train_df["target"])): train_path = os.path.join( transformed_folder_path, "trn_total{}_fold:{}.csv".format(num_folds, fold_ + 1)) valid_path = os.path.join( transformed_folder_path, "val_total{}_fold:{}.csv".format(num_folds, fold_ + 1)) flag_data = os.path.exists(train_path) if flag_data: print("load file from pickle ...") with open(train_path, "rb") as pkl: trn = pickle.load(pkl) with open(valid_path, "rb") as pkl: val = pickle.load(pkl) print("finish!") else: print("make transformed data and save it ...") trn = train_df[feats + ["target"]].iloc[trn_idx] val = train_df[feats + ["target"]].iloc[val_idx] trn[feats], val[feats] = preprocess_for_nn(trn[feats], val[feats]) if os.path.exists(transformed_folder_path) is False: os.mkdir(transformed_folder_path) with open(train_path, "wb") as pkl: pickle.dump(trn, pkl) with open(valid_path, "wb") as pkl: pickle.dump(val, pkl) print("finish!") # trn = train_df[feats+["target"]].iloc[trn_idx] # val = train_df[feats+["target"]].iloc[val_idx] # trn[feats], val[feats] = preprocess_for_nn(trn[feats], val[feats]) print("start training fold no {}".format(fold_)) net = Net(**params).cuda() net.apply(init_weights) train_iter = DataLoader(torch.FloatTensor(trn.values), batch_size=batchsize, shuffle=True) valid_iter = DataLoader(torch.FloatTensor(val.values), batch_size=batchsize, shuffle=False) valid_iter_2 = DataLoader(torch.FloatTensor(trn.values), batch_size=batchsize, shuffle=False) optimizer = optim.Adam(net.parameters(), lr=1e-3, weight_decay=1e-4) net, t_loss, v_loss, outputs, min_val_loss = train_nn( net, criterion=criterion, train_data=train_iter, valid_data=valid_iter, optimizer=optimizer, max_iter=20, valid_data2=valid_iter_2, ) net.cuda() oof_xgb[val_idx] = outputs sub_preds += predict(net, test_iter) print("check eval") evaluator(net, criterion, valid_iter, valid_iter_2) score = rmse(val["target"], oof_xgb[val_idx]) print('no {}-fold loss: {:.6f}'.format(fold_ + 1, score)) losses["train"].append(t_loss) losses["valid"].append(v_loss) # raise NotImplementedError sub_preds /= num_folds cv_score = np.sqrt(mean_squared_error(oof_xgb, train_df["target"])) print("cross validation score:{:.6f}".format(cv_score)) train_df["oof_preds"] = oof_xgb save_folder_name = "./{}/cv={:.6f}".format(folder_name, cv_score) if os.path.exists(save_folder_name) is False: os.mkdir(save_folder_name) train_df.to_csv(save_folder_name + "/train_feat.csv", index=False) subm_path = "{}/subm_cv={:.6f}.csv".format(save_folder_name, cv_score) test_df["target"] = sub_preds test_df[["card_id", "target"]].to_csv(subm_path, index=False)
class Solver(object): def __init__(self, config, source_loader, target_loader, target_val_loader): self.source_loader = source_loader self.target_loader = target_loader self.target_val_loader = target_val_loader self.net = None self.net_optimizer = None self.net_d = None self.net_optimizer_d = None self.beta1 = config.beta1 self.beta2 = config.beta2 self.train_iters = config.train_iters self.pretrain_iters = config.pretrain_iters self.batch_size = config.batch_size self.lr = config.lr self.lr_d = config.lr_d self.alpha_s = config.alpha_s self.alpha_t = config.alpha_t self.beta_c = config.beta_c self.beta_sep = config.beta_sep self.beta_p = config.beta_p self.log_step = config.log_step self.model_path = config.model_path self.num_classes = config.num_classes self.build_model() def build_model(self): """Builds a generator and a discriminator.""" self.net = Net() self.net_d = Net_D() net_params = list(self.net.parameters()) net_d_params = list(self.net_d.parameters()) self.net_optimizer = optim.Adam(net_params, self.lr, [self.beta1, self.beta2]) self.net_optimizer_d = optim.Adam(net_d_params, self.lr_d, [self.beta1, self.beta2]) if torch.cuda.is_available(): self.net.cuda() self.net_d.cuda() def to_var(self, x): """Converts numpy to variable.""" if torch.cuda.is_available(): x = x.cuda() return Variable(x, requires_grad=False) def to_data(self, x): """Converts variable to numpy.""" if torch.cuda.is_available(): x = x.cpu() return x.data.numpy() def reset_grad(self): """Zeros the gradient buffers.""" self.net_optimizer.zero_grad() self.net_optimizer_d.zero_grad() def separability_loss(self, labels, latents, imbalance_parameter=1): criteria = torch.nn.modules.loss.CosineEmbeddingLoss() loss_up = 0 one_cuda = torch.ones(1).cuda() mean = torch.mean(latents, dim=0).cuda().view(1, -1) loss_down = 0 for i in range(self.num_classes): indexes = labels.eq(i) mean_i = torch.mean(latents[indexes], dim=0).view(1, -1) if str(mean_i.norm().item()) != 'nan': for latent in latents[indexes]: loss_up += criteria(latent.view(1, -1), mean_i, one_cuda) loss_down += criteria(mean, mean_i, one_cuda) loss = (loss_up / loss_down) * imbalance_parameter return loss def initialisation(self): self.net.apply(xavier_weights_init) self.net_d.apply(xavier_weights_init) source_iter = iter(self.source_loader) target_iter = iter(self.target_loader) target_val_iter = iter(self.target_val_loader) source_per_epoch = len(source_iter) target_per_epoch = len(target_iter) targetval_per_epoch = len(target_val_iter) print(source_per_epoch, target_per_epoch, targetval_per_epoch) criterion = nn.CrossEntropyLoss() f_labels = torch.LongTensor(128) f_labels[...] = 10 t_labels = torch.LongTensor(128) t_labels[...] = 1 # pretrain log_pre = 50 source_iter = iter(self.source_loader) target_iter = iter(self.target_loader) return criterion, source_per_epoch, target_per_epoch, target_iter, source_iter, log_pre def train(self): criterion, source_per_epoch, target_per_epoch, target_iter, source_iter, log_pre = self.initialisation( ) pre_train = not os.path.exists( os.path.join(self.model_path, 'pre_train.pth')) print("Pretrain:\n*********") if pre_train: for step in range(self.pretrain_iters + 1): # ============ Initialization ============# # refresh if (step + 1) % (source_per_epoch) == 0: source_iter = iter(self.source_loader) if (step + 1) % (target_per_epoch) == 0: target_iter = iter(self.target_loader) # load the data source, s_labels = source_iter.next() target, t_labels = target_iter.next() target_rgb = target target, t_labels = self.to_var(target_rgb), self.to_var( t_labels).long().squeeze() source, s_labels = self.to_var(source), self.to_var( s_labels).long().squeeze() # ============ Training ============ # self.reset_grad() # forward latent, c = self.net(source) # loss loss_source_class = criterion(c, s_labels) # one step loss_source_class.backward() self.net_optimizer.step() self.reset_grad() # ============ Validation ============ # if (step + 1) % log_pre == 0: _, c_source = self.net(source) _, c_target = self.net(target) print("[%d/20000] classification loss: %.4f" % (step + 1, loss_source_class.item())) print("source accuracy %.4f; target accuracy %.4f" % (accuracy(s_labels, c_source), accuracy(t_labels, c_target))) self.save_model() else: self.load_model() # ============ Initialization ============ # source_iter = iter(self.source_loader) target_iter = iter(self.target_loader) maxacc = 0.0 maximum_acc = 0.0 max_iter = 0 net_params = list(self.net.parameters()) net_d_params = list(self.net_d.parameters()) self.net_optimizer = optim.Adam(net_params, self.lr, [self.beta1, self.beta2]) self.net_optimizer_d = optim.Adam(net_d_params, self.lr_d, [self.beta1, self.beta2]) print("Second:\n******") self.validate() for step in range(self.train_iters): # ============ Initialization ============# # refresh if (step + 1) % (target_per_epoch) == 0: target_iter = iter(self.target_loader) if (step + 1) % (source_per_epoch) == 0: source_iter = iter(self.source_loader) # load the data source, s_labels = source_iter.next() source, s_labels = self.to_var(source), self.to_var( s_labels).long().squeeze() # must squeeze target, t_labels = target_iter.next() target_rgb = target target, t_labels = self.to_var(target_rgb), self.to_var( t_labels).long().squeeze() # ============ train D ============# self.reset_grad() latent_source, c = self.net(source) d = self.net_d(latent_source) loss_d_s1 = F.binary_cross_entropy( d, torch.ones_like(d, dtype=torch.float32)) loss_d_s0 = F.binary_cross_entropy( d, torch.zeros_like(d, dtype=torch.float32)) loss_c_source = criterion(c, s_labels) latent_target, c = self.net(target) d = self.net_d(latent_target) loss_d_t0 = F.binary_cross_entropy( d, torch.zeros_like(d, dtype=torch.float32)) loss_p = loss_d_s0 loss_d = loss_d_s1 + loss_d_t0 # ============ train pseudo labeling ============# chosen_target, pseudo_labels, indexes, imbalance_parameter = pseudo_labeling( target, c) if chosen_target is not None: loss_c_target = criterion(c[indexes], pseudo_labels) latent_target = latent_target[indexes] # ============ class loss ============# loss_sep = self.separability_loss( torch.cat((s_labels, pseudo_labels)), torch.cat((latent_source, latent_target)), imbalance_parameter=imbalance_parameter) else: loss_c_target = 0 loss_sep = 0 loss = self.beta_c * (self.alpha_s * loss_c_source + self.alpha_t * loss_c_target) + \ self.beta_p * loss_p + \ self.beta_sep * loss_sep loss.backward(retain_graph=True) self.net_optimizer.step() loss_d.backward() self.net_optimizer_d.step() self.reset_grad() # ============ Validation ============ # if (step + 1) % self.log_step == 0: print("max accuracy:", colored(maximum_acc, "green"), "iteration", max_iter) _, c_source = self.net(source) _, c_target = self.net(target) print("source accuracy %.4f; target accuracy %.4f" % (accuracy(s_labels, c_source), accuracy(t_labels, c_target))) acc = self.validate() if acc > maximum_acc: maximum_acc = acc max_iter = step if acc > maxacc: maxacc = acc torch.save( self.net, "./model_c_" + str(step) + '_' + str(acc) + ".pth") torch.save( self.net_d, "./model_d_" + str(step) + '_' + str(acc) + ".pth") self.reset_grad() # ============ Save the model ============ # torch.save(self.net, "./model_c_final.pth") torch.save(self.net_d, "./model_d_final.pth") def validate(self, ): class_correct = [0] * self.num_classes class_total = [0.] * self.num_classes classes = [str(i) for i in range(self.num_classes)] self.net.eval() # prep model for evaluation for data, target in self.target_val_loader: # forward pass: compute predicted outputs by passing inputs to the model data, target = self.to_var(data), self.to_var( target).long().squeeze() data = data.cuda() target = target.cuda() latent, output = self.net(data) _, pred = torch.max(output, 1) correct = np.squeeze(pred.eq(target.data.view_as(pred))) # calculate test accuracy for each object class for i in range(len(target.data)): label = target.data[i] class_correct[label] += correct[i].item() class_total[label] += 1 for i in range(self.num_classes): if class_total[i] > 0: print('Test Accuracy of %5s: %2d%% (%2d/%2d)' % (str(i), 100 * class_correct[i] / class_total[i], np.sum(class_correct[i]), np.sum(class_total[i]))) else: print('Test Accuracy of %5s: N/A (no training examples)' % (classes[i])) print("\nTest Accuracy (Overall): ", end="") print(colored( '%2d%% ' % (100. * np.sum(class_correct) / np.sum(class_total)), "red"), end="") print("(", end="") print(colored(str(int(np.sum(class_correct))), "red"), end=" ") print('/%2d)' % (np.sum(class_total))) self.net.train() return 100. * np.sum(class_correct) / np.sum(class_total) def save_model(self): torch.save(self.net, os.path.join(self.model_path, 'pre_train.pth')) def load_model(self): self.net = torch.load(os.path.join(self.model_path, 'pre_train.pth'))
lr = 0.01 epoch = 100 out_model_fn = './model/%s/' % (saveName) if not os.path.exists(out_model_fn): os.makedirs(out_model_fn) use_cuda = torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") t_kwargs = {'batch_size': batch_size, 'pin_memory': True} tr_loader = torch.utils.data.DataLoader(Data2Torch(device, 'tr'), shuffle=True, **t_kwargs) va_loader = torch.utils.data.DataLoader(Data2Torch(device, 'te'), shuffle=True, **t_kwargs) model = Net().to(device) model.apply(model_init) mp = np.array([ 794532, 230484, 99407, 99132, 24426, 14954, 11468, 8696, 8310, 4914, 3006 ]) mmp = mp.astype(np.float32) / mp.sum() cc = ((mmp.mean() / mmp) * ((1 - mmp) / (1 - mmp.mean())))**0.3 inverse_feq = torch.from_numpy(cc) print(inverse_feq) Trer = Trainer(model, lr, epoch, out_model_fn, 1, 1) Trer.fit(tr_loader, inverse_feq, device)
]), } train_dataset = VideoDataset(df_train, FRAME_SAMPLE_NUM, IMG_EXT, INPUT_SIZE, transform=data_transforms["train"]) valid_dataset = VideoDataset(df_valid, FRAME_SAMPLE_NUM, IMG_EXT, INPUT_SIZE, transform=data_transforms["valid"]) train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=4, pin_memory=True) valid_dataloader = torch.utils.data.DataLoader(valid_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=4) dataloaders_dict = {"train":train_dataloader, "valid":valid_dataloader} print(">Model Network Initializing") device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model_net = Net(NUM_CLASSES, BATCH_SIZE, FRAME_SAMPLE_NUM, INPUT_SIZE).to(device) model_net.apply(init_weights) if LOAD_CHECKPOINT_PATH != "none": print(">Trained model loading from", LOAD_CHECKPOINT_PATH) checkpoint = torch.load(LOAD_CHECKPOINT_PATH) model_net.load_state_dict(checkpoint['model_state_dict']) if LOAD_OPTIM: print(">optimizer loading from", LOAD_CHECKPOINT_PATH) optimizer_net.load_state_dict(checkpoint['optimizer_state_dict']) if MULTI_GPU: model_net = torch.nn.DataParallel(model_net) if NUM_CLASSES != NEW_NUM_CLASSES: if MULTI_GPU: model_net.module.final_layer = nn.Linear(512, NEW_NUM_CLASSES).to(device)