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)
