def main(config):
if config.mode == 'train':
train_loader, dataset = get_loader(config.batch_size,
num_thread=config.num_thread)
# run = "nnet"
# if not os.path.exists("%s/run-%s" % (config.save_fold, run)):
# os.mkdir("%s/run-%s" % (config.save_fold, run))
# os.mkdir("%s/run-%s/logs" % (config.save_fold, run))
# os.mkdir("%s/run-%s/models" % (config.save_fold, run))
# config.save_fold = "%s/run-%s" % (config.save_fold, run)
# train = Solver(train_loader, None, config)
run = strftime('V_%m-%d_%H-%M-%S', gmtime())
if not os.path.exists("%s/%s" % (config.save_fold, run)):
os.mkdir("%s/%s" % (config.save_fold, run))
os.mkdir("%s/%s/logs" % (config.save_fold, run))
os.mkdir("%s/%s/models" % (config.save_fold, run))
config.save_fold = "%s/%s" % (config.save_fold, run)
temp_path = "%s/temp_see" % (config.save_fold)
train = Solver(train_loader, None, config, temp_path=temp_path)
train.train()
elif config.mode == 'test':
test_loader, dataset = get_loader(config.test_batch_size,
mode='test',
num_thread=config.num_thread)
test = Solver(None, test_loader, config, dataset.save_folder())
test.test(test_mode=config.test_mode)
else:
raise IOError("illegal input!!!")
def main(config):
if config.mode == 'train':
train_loader = get_loader(config.train_path, config.label_path, config.img_size, config.batch_size,
num_thread=config.num_thread)
if config.val:
val_loader = get_loader(config.val_path, config.val_label, config.img_size, config.batch_size,
num_thread=config.num_thread)
run = 0
while os.path.exists("%s/run-%d" % (config.save_fold, run)): run += 1
os.mkdir("%s/run-%d" % (config.save_fold, run))
os.mkdir("%s/run-%d/logs" % (config.save_fold, run))
# os.mkdir("%s/run-%d/images" % (config.save_fold, run))
os.mkdir("%s/run-%d/models" % (config.save_fold, run))
config.save_fold = "%s/run-%d" % (config.save_fold, run)
if config.val:
train = Solver(train_loader, val_loader, None, config)
else:
train = Solver(train_loader, None, None, config)
train.train()
elif config.mode == 'test':
test_loader = get_loader(config.test_path, config.test_label, config.img_size, config.batch_size, mode='test',
num_thread=config.num_thread)
if not os.path.exists(config.test_fold): os.mkdir(config.test_fold)
test = Solver(None, None, test_loader, config)
test.test(100)
else:
raise IOError("illegal input!!!")
def main():
random_seeding()
parser = argparse.ArgumentParser()
parser.add_argument('-src_data', type=str, default='data/sent_dic.pkl')
parser.add_argument('-trg_data', type=str, default='data/trg.txt')
parser.add_argument('-test_src_data',
type=str,
default='data/test_sent_dic.pkl')
parser.add_argument('-test_trg_data',
type=str,
default='data/test_trg.txt')
parser.add_argument('-root_data', type=str, default='data/root.pkl')
parser.add_argument('-test_root_data',
type=str,
default='data/test_root.pkl')
parser.add_argument('-epochs', type=int, default=100)
parser.add_argument('-d_model', type=int, default=300)
parser.add_argument('-n_layers', type=int, default=4)
parser.add_argument('-heads', type=int, default=4)
parser.add_argument('-dropout', type=int, default=0.1)
parser.add_argument('-batchsize', type=int, default=64)
parser.add_argument('-lr', type=int, default=0.001)
parser.add_argument('-max_strlen', type=int, default=120)
opt = parser.parse_args()
# load vocab
with open('./vocab/src_vocab.pkl', 'rb') as f:
SRC = pickle.load(f)
with open('./vocab/trg_vocab.pkl', 'rb') as f:
TRG = pickle.load(f)
# get model
transformer, eventer = get_model(SRC, TRG, None, opt.d_model, opt.n_layers,
opt.heads, opt.dropout)
total_params = sum(p.numel() for p in transformer.parameters()
if p.requires_grad)
print("transformer trainable parameters: ", total_params)
total_params = sum(p.numel() for p in eventer.parameters()
if p.requires_grad)
print("eventer trainable parameters: ", total_params)
optimizer = torch.optim.Adam(itertools.chain(transformer.parameters(),
eventer.parameters()),
lr=opt.lr,
betas=(0.9, 0.98),
eps=1e-9)
criterion = nn.CrossEntropyLoss(ignore_index=0)
dataset = get_loader(opt.src_data, opt.trg_data, opt.root_data, SRC, TRG,
opt.batchsize)
test_dataset = get_loader(opt.test_src_data, opt.test_trg_data,
opt.test_root_data, SRC, TRG, 1, False)
train_model(transformer, eventer, dataset, test_dataset, opt.epochs,
criterion, optimizer, SRC, TRG)
def main():
opt = opts.parse_opt()
opt.src_data = '../data/visualstorytelling/train.pkl'
opt.test_src_data = '../data/visualstorytelling/test.pkl'
dataset = get_loader(opt.src_data, opt.batch_size, train=True)
test_dataset = get_loader(opt.test_src_data, opt.batch_size, train=False, shuffle=False)
# get model
bart = BART(opt)
train_model(opt, bart, dataset, test_dataset, 10)
def k_fold_cross_validation(net, optimizer, criterion, train_img_list, k,
present_time):
transform_train, transform_test = get_train_transform(
), get_test_transform()
valid_img_num = math.ceil(len(train_img_list) / k)
total_best_valid_acc, total_best_valid_loss = 0, 0
for val_idx in range(
k): # Which part of training set should be validation set
net.load_state_dict(
torch.load(f"./weights/{present_time}/init_weight.pth"))
train_imgs, valid_imgs = get_cross_valid_img_list(
val_idx, valid_img_num, train_img_list)
train_loader = get_loader(train_imgs, transform_train)
valid_loader = get_loader(valid_imgs, transform_test)
train_acc_list, train_loss_list, valid_acc_list, valid_loss_list = list(
), list(), list(), list()
best_valid_loss, best_valid_epoch, non_improve_count = 10000, 0, 0
for epoch in range(120):
print(f"\n({val_idx})Epoch: {epoch}")
train_acc, train_loss = train(net, optimizer, criterion, epoch,
train_loader)
valid_acc, valid_loss = test(net, criterion, epoch, valid_loader)
# 以下的 list 是為了畫圖用
train_acc_list.append(train_acc)
train_loss_list.append(train_loss)
valid_acc_list.append(valid_acc)
valid_loss_list.append(valid_loss)
if (valid_loss < best_valid_loss):
best_valid_loss = valid_loss
best_valid_epoch = epoch
non_improve_count = 0
else:
non_improve_count += 1
if (non_improve_count >= 10):
break
total_best_valid_acc += valid_acc_list[best_valid_epoch]
total_best_valid_loss += valid_loss_list[best_valid_epoch]
plot_figure(train_acc_list, valid_acc_list, train_loss_list,
valid_loss_list, val_idx, present_time)
print("\n----------")
print(
f"valid acc: {total_best_valid_acc / k:.2f}, valid loss: {total_best_valid_loss / k:.2f}"
)
def main(args):
dataset_configs = DatasetParams(args.dataset_config_file)
dataset_params_1 = dataset_configs.get_params(args.dataset_1)
dataset_params_2 = dataset_configs.get_params(args.dataset_2)
for p in (dataset_params_1, dataset_params_2):
for d in p:
# Tell dataset to output id in integer or other simple format:
d.config_dict['return_simple_image_id'] = True
data_loader_1, _ = get_loader(dataset_params_1,
vocab=None,
transform=None,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
ext_feature_sets=None,
skip_images=True,
iter_over_images=True)
data_loader_2, _ = get_loader(dataset_params_2,
vocab=None,
transform=None,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
ext_feature_sets=None,
skip_images=True,
iter_over_images=True)
show_progress = sys.stderr.isatty()
print("Reading image ids from dataset {}".format(args.dataset_1))
ids_1 = [
img_ids for _, _, _, img_ids, _ in tqdm(data_loader_1,
disable=not show_progress)
]
set_1 = set(chain(*ids_1))
print("Reading image ids from dataset {}".format(args.dataset_2))
ids_2 = [
img_ids for _, _, _, img_ids, _ in tqdm(data_loader_2,
disable=not show_progress)
]
set_2 = set(chain(*ids_2))
intersection = set_1.intersection(set_2)
len_intersect = len(intersection)
print("There are {} images shared between {} and {}".format(
len_intersect, args.dataset_1, args.dataset_2))
def main(config):
torch.manual_seed(config.seed)
torch.cuda.manual_seed(config.seed)
# if config.mode == 'train':
train_loader = get_loader(config.train_img_path,
config.train_label_path,
config.img_size,
config.batch_size,
filename=config.train_file,
num_thread=config.num_thread)
test_dataset = ImageData(config.test_img_path,
config.test_label_path,
filename=config.test_file,
test=True,
require_name=True)
run = 0
while os.path.exists("%s/run-%d" % (config.save_fold, run)):
run += 1
os.mkdir("%s/run-%d" % (config.save_fold, run))
os.mkdir("%s/run-%d/logs" % (config.save_fold, run))
# os.mkdir("%s/run-%d/images" % (config.save_fold, run))
os.mkdir("%s/run-%d/models" % (config.save_fold, run))
config.save_fold = "%s/run-%d" % (config.save_fold, run)
train = Solver(train_loader, test_dataset, config)
if config.mode == 'train':
train.train()
elif config.mode == 'test':
train.test(100)
else:
raise IOError("illegal input!!!")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-beam_size', type=int, default=4)
parser.add_argument('-max_len', type=int, default=80)
parser.add_argument('-d_model', type=int, default=300)
parser.add_argument('-n_layers', type=int, default=4)
parser.add_argument('-src_lang', default='en')
parser.add_argument('-trg_lang', default='en')
parser.add_argument('-heads', type=int, default=4)
parser.add_argument('-dropout', type=int, default=0.1)
parser.add_argument('-load_epoch', type=int, default=10)
opt = parser.parse_args()
assert opt.beam_size > 0
assert opt.max_len > 10
# load vocab
with open("vocab/vocab.pkl", 'rb') as f:
vocab = pickle.load(f)
# opt.load_epoch = None
for load_epoch in [30]:
transformer = get_model(251, load_epoch, opt.d_model, opt.n_layers, opt.heads, opt.dropout)
test_dataset = get_loader("data/new_keyword_test.json", 1, train=False)
# evaluate
# eval(transformer, test_dataset)
# generate
# greedy_generate(model, SRC, TRG)
print('epoch', load_epoch)
generate(transformer, vocab, 4)
def main():
torch.manual_seed(1)
np.random.seed(0)
torch.cuda.manual_seed(1)
torch.cuda.manual_seed_all(1)
opt = edict()
opt.nGPU = 1
opt.batchsize = 1
opt.cuda = True
cudnn.benchmark = True
print('========================LOAD DATA============================')
data_name = 'widerfacetest'
test_loader = get_loader(data_name, opt.batchsize)
net_G_low2high = GEN_DEEP()
net_G_low2high = net_G_low2high.cuda()
a = torch.load('model.pkl')
net_G_low2high.load_state_dict(a)
net_G_low2high = net_G_low2high.eval()
index = 0
test_file = 'test_res'
if not os.path.exists(test_file):
os.makedirs(test_file)
for idx, data_dict in enumerate(test_loader):
print(idx)
index = index + 1
data_low = data_dict['img16']
data_high = data_dict['img64']
img_name = data_dict['imgpath'][0].split('/')[-1]
data_input_low, batchsize_high = to_var(data_low)
data_input_high, _ = to_var(data_high)
data_high_output = net_G_low2high(data_input_low)
path = os.path.join(test_file, img_name.split('.')[0] + '.jpg')
vutils.save_image(data_high_output.data, path, normalize=True)
def train():
print('start training ...........')
batch_size = 16
num_epochs = 50
learning_rate = 0.1
label_converter = LabelConverter(char_set=string.ascii_lowercase + string.digits)
vocab_size = label_converter.get_vocab_size()
device = torch.device("cuda:0" if (torch.cuda.is_available()) else "cpu")
model = CRNN(vocab_size=vocab_size).to(device)
# model.load_state_dict(torch.load('output/weight.pth', map_location=device))
train_loader, val_loader = get_loader('data/CAPTCHA Images/', batch_size=batch_size)
optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9, nesterov=True)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
# scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, 10, 2)
train_losses, val_losses = [], []
for epoch in range(num_epochs):
train_epoch_loss = fit(epoch, model, optimizer, label_converter, device, train_loader, phase='training')
val_epoch_loss = fit(epoch, model, optimizer, label_converter, device, val_loader, phase='validation')
print('-----------------------------------------')
if epoch == 0 or val_epoch_loss <= np.min(val_losses):
torch.save(model.state_dict(), 'output/weight.pth')
train_losses.append(train_epoch_loss)
val_losses.append(val_epoch_loss)
write_figure('output', train_losses, val_losses)
write_log('output', epoch, train_epoch_loss, val_epoch_loss)
scheduler.step(val_epoch_loss)
def main():
torch.manual_seed(1)
np.random.seed(0)
torch.cuda.manual_seed(1)
torch.cuda.manual_seed_all(1)
opt = edict()
opt.nGPU = 1
opt.batchsize = 1
opt.cuda = True
cudnn.benchmark = True
print("========================LOAD DATA============================")
data_name = "widerfacetest"
test_loader = get_loader(data_name, opt.batchsize)
net_G_low2high = GEN_DEEP()
net_G_low2high = net_G_low2high.cuda()
a = torch.load("model.pkl")
net_G_low2high.load_state_dict(a)
net_G_low2high = net_G_low2high.eval()
test_file = "test_res"
if not os.path.exists(test_file):
os.makedirs(test_file)
for idx, data_dict in enumerate(test_loader):
data_low = data_dict["img16"]
data_high = data_dict["img64"]
img_name = data_dict["imgpath"][0].split("/")[-1]
data_input_low, batchsize_high = to_var(data_low)
data_input_high, _ = to_var(data_high)
data_high_output = net_G_low2high(data_input_low)
path = os.path.join(test_file, img_name.split(".")[0] + ".png")
vutils.save_image(data_high_output.data, path, normalize=True)
def train(root, device, model, epochs, bs, lr):
print('start training ...........')
train_loader, val_loader = get_loader(root=root,
batch_size=bs,
shuffle=True)
optimizer = optim.Adam(model.parameters(), lr=lr)
criterion = HDRLoss(device)
train_losses, val_losses = [], []
for epoch in range(epochs):
train_epoch_loss = fit(epoch,
model,
optimizer,
criterion,
device,
train_loader,
phase='training')
val_epoch_loss = fit(epoch,
model,
optimizer,
criterion,
device,
val_loader,
phase='validation')
print('-----------------------------------------')
if epoch == 0 or val_epoch_loss <= np.min(val_losses):
torch.save(model.state_dict(), 'output/weight.pth')
train_losses.append(train_epoch_loss)
val_losses.append(val_epoch_loss)
write_figures('output', train_losses, val_losses)
write_log('output', epoch, train_epoch_loss, val_epoch_loss)
def main():
# random_seeding()
parser = argparse.ArgumentParser()
parser.add_argument('-src_data', type=str, default='../data/concept_selection/train.pkl')
parser.add_argument('-test_src_data', type=str, default='../data/concept_selection/test.pkl')
parser.add_argument('-epochs', type=int, default=101)
parser.add_argument('-d_model', type=int, default=300)
parser.add_argument('-n_layers', type=int, default=4)
parser.add_argument('-heads', type=int, default=4)
parser.add_argument('-dropout', type=int, default=0.1)
parser.add_argument('-batchsize', type=int, default=64)
parser.add_argument('-lr', type=int, default=0.0004)
parser.add_argument('-max_strlen', type=int, default=700)
opt = parser.parse_args()
with open('vocab/vocab.pkl','rb') as f:
vocab = pickle.load(f)
# get model
transformer = get_model(len(vocab), None, opt.d_model, opt.n_layers, opt.heads, opt.dropout)
total_params = sum(p.numel() for p in transformer.parameters() if p.requires_grad)
print("transformer trainable parameters: ", total_params)
optimizer = torch.optim.Adam(transformer.parameters(), lr=opt.lr)
criterion = nn.MSELoss()
dataset = get_loader(opt.src_data, vocab, opt.batchsize, train=True)
train_model(transformer, dataset, opt.epochs, criterion, optimizer)
def train_attention_captioner():
print("Training The Attention Capitoner ... ")
# Create model directory
if not os.path.exists(path_trained_model):
os.makedirs(path_trained_model)
# Image preprocessing, first resize the input image then do normalization for the pretrained resnet
transform = transforms.Compose([
transforms.Resize((input_resnet_size, input_resnet_size),
interpolation=Image.ANTIALIAS),
transforms.RandomCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
# Loading pickle dictionary
with open(dict_path, 'rb') as file:
dictionary = pickle.load(file)
# Build data loader
data_loader = get_loader(imgs_path,
data_caps,
dictionary,
transform,
BATCH_SIZE,
shuffle=True,
num_workers=2)
# Building the Models
encoder = EncoderCNN(word_embedding_size).to(device)
attn_decoder = AttnDecoderRNN(word_embedding_size, len(dictionary[0]))
# Loss and optimizer
criterion = nn.CrossEntropyLoss()
params = list(attn_decoder.parameters()) + list(
encoder.linear.parameters()) + list(encoder.bn.parameters())
optimizer = torch.optim.Adam(params, lr=LEARN_RATE)
word2idx = dictionary[0]
# Initiazling the decoder hidden and output
decoder_input = torch.tensor([[word2idx['START']]]).to(device)
decoder_hidden = torch.zeros(word_embedding_size).to(device)
total_steps = len(data_loader)
for epcoh in range(NUM_EPOCHS):
for i, (images, captions, lengths) in enumerate(data_loader):
print(images.Size, captions.Size, lengths.Size)
# Set mini-batch dataset
images = images.to(device)
captions = captions.to(device)
targets = pack_padded_sequence(captions, lengths,
batch_first=True)[0]
features = encoder(images)
decoder_output, decoder_hidden, attn_weights = attn_decoder(
decoder_input, decoder_hidden, features)
def train(self):
style_img = self.load_style()
if self.gpu:
self.style_net = self.style_net.gpu()
self.loss_net = self.loss_net.gpu()
style_img = style_img.gpu()
adam = optim.Adam(self.style_net.parameters(), lr=self.lr)
loader = get_loader(1, self.data_path, self.img_shape, self.transform)
print('Data Load Success!!')
print('Training Start!!')
for count in range(self.epoch):
for step, frames in enumerate(loader):
for i in range(1, len(frames)):
x_t = frames[i]
x_t1 = frames[i - 1]
h_xt = self.style_net(x_t)
h_xt1 = self.style_net(x_t1)
s_xt = self.loss_net(x_t, self.style_layer)
s_xt1 = self.loss_net(x_t1, self.style_layer)
s_hxt = self.loss_net(h_xt, self.style_layer)
s_hxt1 = self.loss_net(h_xt1, self.style_layer)
s = self.loss_net(style, self.style_layer)
# ContentLoss, conv4_2
content_t = ContentLoss(self.gpu)(s_xt[3], s_hxt[3])
content_t1 = ContentLoss(self.gpu)(s_xt1[3], s_hxt1[3])
content_loss = content_t + content_t1
# StyleLoss
style_t = None
style_t1 = None
tv_loss = None
for layer in range(len(self.style_layer)):
style_t += StyleLoss(self.gpu)(s, s_hxt[layer])
style_t1 += StyleLoss(self.gpu)(s, s_hxt1[layer])
# TVLoss
tv_loss = TVLoss(s_hxt[layer])
style_loss = style_t + style_t1
# Optical flow
flow, mask = opticalflow(h_xt.data.numpy(),
h_xt1.data.numpy())
# Temporal Loss
temporal_loss = TemporalLoss(self.gpu)(h_xt, flow, mask)
# Spatial Loss
spatial_loss = self.s_a * content_loss + self.s_b * style_loss + self.s_r * tv_loss
Loss = spatial_loss + self.t_l * temporal_loss
Loss.backward(retain_graph=True)
adam.step()
def main():
# Training settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size',
type=int,
default=64,
metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size',
type=int,
default=1000,
metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs',
type=int,
default=10,
metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr',
type=float,
default=0.01,
metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--momentum',
type=float,
default=0.5,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--cuda',
action='store_true',
default=True,
help='disables CUDA training')
parser.add_argument('--seed',
type=int,
default=1,
metavar='S',
help='random seed (default: 1)')
args = parser.parse_args()
if torch.cuda.is_available():
if not args.cuda:
print("you should use CUDA/GPU to train the model")
torch.manual_seed(args.seed)
device = torch.device("cuda" if args.cuda else "cpu")
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
train_loader, test_loader = get_loader(args, kwargs)
model = Net().to(device)
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum)
train(args, model, device, train_loader, test_loader, optimizer)
def main(args):
backbone_names = args.backbones.split('+')
dataset_names = args.datasets.split('+')
for dataset in dataset_names:
for backbone in backbone_names:
print("Working on [DATASET: %s] with [BACKBONE: %s]" %
(dataset, backbone))
# Configure testset path
test_rgb_path = os.path.join(args.input_root, dataset, 'RGB')
test_dep_path = os.path.join(args.input_root, dataset, 'depth')
res_path = os.path.join(args.save_root, 'BiANet_' + backbone,
dataset)
os.makedirs(res_path, exist_ok=True)
test_loader = get_loader(test_rgb_path,
test_dep_path,
224,
1,
num_thread=8,
pin=True)
# Load model and parameters
exec('from models import BiANet_' + backbone)
model = eval('BiANet_' + backbone).BiANet()
pre_dict = torch.load(
os.path.join(args.param_root, 'BiANet_' + backbone + '.pth'))
device = torch.device("cuda")
model.to(device)
if backbone == 'vgg16':
model = torch.nn.DataParallel(model, device_ids=[0])
model.load_state_dict(pre_dict)
model.eval()
# Test Go!
tensor2pil = transforms.ToPILImage()
with torch.no_grad():
for batch in test_loader:
rgbs = batch[0].to(device)
deps = batch[1].to(device)
name = batch[2][0]
imsize = batch[3]
scaled_preds = model(rgbs, deps)
res = scaled_preds[-1]
res = nn.functional.interpolate(res,
size=imsize,
mode='bilinear',
align_corners=True).cpu()
res = res.squeeze(0)
res = tensor2pil(res)
res.save(os.path.join(res_path, name[:-3] + 'png'))
print('Outputs were saved at:' + args.save_root)
def evaluate(self):
model = load_ensemble_from_checkpoints(
self.train_results["checkpoints"].checkpoints)
results = evaluate(model,
get_loader(get_dataset("val")),
device=self.device)
labels, preds = results["labels"], results["predictions"]
print("AVG AUC", mt.roc_auc_score(labels, preds))
return labels, preds
def get_eval_loaders():
# We can extend this dict to evaluate on multiple datasets.
eval_loaders = {
'TVL': get_loader(
is_train=False,
root=args.eval, mv_dir=args.eval_mv,
args=args),
}
return eval_loaders
def _train(args):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
# Data
print('==> Preparing data..')
trainloader, testloader = dataset.get_loader()
# Model
print('==> Building model..')
teacher_net = VGG('VGG16')
teacher_net = teacher_net.to(device)
if device == 'cuda':
teacher_net = torch.nn.DataParallel(teacher_net)
cudnn.benchmark = True
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!'
checkpoint = torch.load('./checkpoint/{}.pth'.format(
args.teacher_model_name))
teacher_net.load_state_dict(checkpoint['net'])
student_net = StudentNet()
student_net = student_net.to(device)
if device == 'cuda':
student_net = torch.nn.DataParallel(student_net)
cudnn.benchmark = True
criterion = _make_criterion(alpha=args.alpha, T=args.T, mode=args.kd_mode)
if args.optimizer == 'sgd':
optimizer = optim.SGD(student_net.parameters(),
lr=args.lr,
momentum=0.9)
elif args.optimizer == 'sgd-cifar10':
optimizer = optim.SGD(student_net.parameters(), lr=0.1, momentum=0.9)
elif args.optimizer == 'adam':
optimizer = optim.Adam(student_net.parameters(), lr=args.lr)
else:
raise NotImplementedError()
for epoch_idx in range(1, args.n_epoch + 1):
print('\nEpoch: %d' % epoch_idx)
__train_epoch(student_net, teacher_net, trainloader, device, criterion,
optimizer)
__test_epoch(student_net, testloader, device, criterion)
if args.optimizer == 'sgd-cifar10':
if epoch_idx == 150:
optimizer = optim.SGD(student_net.parameters(),
lr=0.01,
momentum=0.9)
elif epoch_idx == 250:
optimizer = optim.SGD(student_net.parameters(),
lr=0.001,
momentum=0.9)
def main(config):
if config.mode == 'train':
train_loader = get_loader(config)
if not os.path.exists("%s/demo-%s" %
(config.save_folder, time.strftime("%d"))):
os.mkdir("%s/demo-%s" % (config.save_folder, time.strftime("%d")))
config.save_folder = "%s/demo-%s" % (config.save_folder,
time.strftime("%d"))
train = Solver(train_loader, None, config)
train.train()
elif config.mode == 'test':
test_loader = get_loader(config, mode='test')
if not os.path.exists(config.test_folder):
os.makedirs(config.test_folder)
test = Solver(None, test_loader, config)
test.test()
else:
raise IOError("illegal input!!!")
def main(config):
if config.mode == 'train':
train_loader, dataset = get_loader(config.batch_size, num_thread=config.num_thread)
run = "nnet"
if not os.path.exists("%s/run-%s" % (config.save_fold, run)):
os.mkdir("%s/run-%s" % (config.save_fold, run))
os.mkdir("%s/run-%s/logs" % (config.save_fold, run))
os.mkdir("%s/run-%s/models" % (config.save_fold, run))
config.save_fold = "%s/run-%s" % (config.save_fold, run)
train = Solver(train_loader, None, config)
train.train()
elif config.mode == 'test':
test_loader, dataset = get_loader(config.test_batch_size, mode='test',num_thread=config.num_thread, test_mode=config.test_mode, sal_mode=config.sal_mode)
test = Solver(None, test_loader, config, dataset.save_folder())
test.test(test_mode=config.test_mode)
elif config.mode =='application':
test_loader, dataset = get_loader(config.test_batch_size, mode='test', num_thread=config.num_thread,
test_mode=config.test_mode, sal_mode=config.sal_mode)
test = Solver(None, test_loader, config, dataset.save_folder())
test.application()
def main(opt):
# model
utils.ensure_dir(opt.checkpoint)
model = get_model(opt)
model = nn.DataParallel(model).cuda()
utils.load_checkpoint(model, opt.model)
# dataloader
val_loader = get_loader(opt, train=False, shuffle=False)['loader']
_ = validate(val_loader, model, opt)
def __init__(self,
finetune=False,
max_train_samples=None,
lr=0.00001,
epochs=3,
arch="resnet",
layers=18,
model=None,
output_path="./models/model",
uncertainty_strategy='best',
side=None):
print("Training using options", "arch", arch, "finetune", finetune,
"layers", layers)
self.output_path = output_path
self.side = side
if model is None:
self.model = get_model(finetune=finetune,
arch="resnet",
layers=layers)
else:
self.model = model
params = self.model.parameters(
) if finetune else self.model.fc.parameters()
self.optimizer = optim.Adam(params, lr=lr)
self.max_train_samples = max_train_samples
self.criterion = nn.BCEWithLogitsLoss()
self.dataloaders = {
"train":
get_loader(
get_dataset("train",
uncertainty_strategy=uncertainty_strategy,
side=side)),
"val":
get_loader(get_dataset("val", side=side))
}
self.device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
self.model.to(self.device)
self.epochs = epochs
self.train_results = None
def run_loaders(args):
for split in ['train', 'valid']:
# Stanford loader
print(f'Testing Stanford {split} loader')
loader_SU = get_loader(stanford_frac=1,
nih_frac=0,
split=split,
shuffle=True,
args=args)
test_loader(loader_SU)
# Stanford loader STUDY
print(f'Testing Stanford {split} loader')
loader_SU_study = get_loader(stanford_frac=1,
nih_frac=0,
split=split,
shuffle=True,
args=args,
study_level=True)
test_loader(loader_SU_study)
# NIH loader
print(f'Testing NIH {split} loader')
loader_NIH = get_loader(stanford_frac=0,
nih_frac=1,
split=split,
shuffle=True,
args=args)
#test_loader(loader_NIH)
# NIH & Stanford combined loaders
print(f'Testing NIH & SU combo {split} loader')
loader_combo = get_loader(stanford_frac=1,
nih_frac=1,
split=split,
shuffle=True,
args=args)
test_loader(loader_combo)
def main(hyp):
model = load_model(hyp)
model.eval()
train_loader, len_data = get_loader(hyp, mode='train')
if has_threshold == False:
threshold = compute_threshold(model, train_loader, len_data)
else:
#threshold = -6.2835
threshold = -0.6870
print('threshold: ', threshold)
test_loader, len_data = get_loader(hyp, mode='test')
scores = np.zeros(shape=(len_data, 2))
step = 0
with torch.no_grad():
for x, y in test_loader:
enc, dec, z, gamma = model(x)
m_prob, m_mean, m_cov = model.get_gmm_param(gamma, z)
for i in range(z.shape[0]):
zi = z[i].unsqueeze(1)
sample_energy = model.sample_energy(m_prob, m_mean, m_cov, zi,
gamma.shape[1],
gamma.shape[0])
se = sample_energy.detach().item()
scores[step] = [int(y[i]), int(se > threshold)]
step += 1
accuracy = accuracy_score(scores[:, 0], scores[:, 1])
precision, recall, fscore, support = precision_recall_fscore_support(
scores[:, 0], scores[:, 1], average='binary')
print('Accuracy: %.4f Precision: %.4f Recall: %.4f F-score: %.4f' %
(accuracy, precision, recall, fscore))
def test_net(net):
for test_dir_img in test_lists:
test_loader = get_loader(test_dir_img,
img_size,
1,
mode='test',
num_thread=1)
print('''
Starting testing:
dataset: {}
Testing size: {}
'''.format(
test_dir_img.split('/')[-1], len(test_loader.dataset)))
for i, data_batch in enumerate(test_loader):
print('{}/{}'.format(i, len(test_loader.dataset)))
images, depths, image_w, image_h, image_path = data_batch
images, depths = Variable(images.cuda()), Variable(depths.cuda())
outputs_image, outputs_depth = net(images, depths)
_, _, _, _, _, imageBran_output = outputs_image
_, _, _, _, _, depthBran_output = outputs_depth
image_w, image_h = int(image_w[0]), int(image_h[0])
output_imageBran = F.sigmoid(imageBran_output)
output_depthBran = F.sigmoid(depthBran_output)
output_imageBran = output_imageBran.data.cpu().squeeze(0)
output_depthBran = output_depthBran.data.cpu().squeeze(0)
transform = trans.Compose(
[transforms.ToPILImage(),
trans.Scale((image_w, image_h))])
outputImageBranch = transform(output_imageBran)
outputDepthBranch = transform(output_depthBran)
dataset = image_path[0].split('RGBdDataset_processed')[1].split(
'/')[1]
filename = image_path[0].split('/')[-1].split('.')[0]
# save image branch output
save_test_path = save_test_path_root + dataset + '/' + test_model + '/'
if not os.path.exists(save_test_path):
os.makedirs(save_test_path)
outputImageBranch.save(
os.path.join(save_test_path, filename + '.png'))
def __init__(self, config):
self.config = config
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
self.train_data = Dataset(num_of_frame=config.num_of_frame,
root=config.data_path,
mode='train')
self.train_loader = get_loader(dataset=self.train_data,
batch_size=config.batch_size,
shuffle=True,
drop_last=True)
self.val_data = Dataset(num_of_frame=config.num_of_frame,
root=config.data_path,
mode='val')
self.val_loader = get_loader(dataset=self.val_data,
batch_size=config.batch_size,
shuffle=True,
drop_last=True)
# self.test_data
self.lipnet = LipNet(config.vocab_size).to(self.device)
self.ctc_loss = CTCLoss()
self.optim = torch.optim.Adam(self.lipnet.parameters(),
config.learning_rate)
def run(self):
# try:
data_loader = get_loader('custom')
loader = data_loader(filepath=(self.left_path, self.right_path))
test_loader = data.DataLoader(loader,
batch_size=1,
shuffle=False,
num_workers=1)
model = AtrousNet(192).cuda()
model = nn.DataParallel(model)
model_name = 'net/KITTI2012-RAP.tar'
checkpoint = torch.load(model_name)
model.load_state_dict(checkpoint['state_dict'])
model.eval()
is_evalAl = True if (len(test_loader) > 1) else False
for i, datafile in enumerate(test_loader):
top_pad, left_pad, img_l, img_r, file_name = datafile
top_pad = top_pad[0]
left_pad = left_pad[0]
img_l, img_r = Variable(img_l.squeeze(0), volatile=True).cuda(), \
Variable(img_r.squeeze(0), volatile=True).cuda()
with torch.no_grad():
out = model(img_l, img_r)
out = out[:, top_pad:, :-left_pad]
pred_disp = out.data.cpu().numpy()
_, h, w = pred_disp.shape
pred_disp = np.reshape(pred_disp, (h, w))
pred_disp = (pred_disp * 255).astype('uint16') #(np.uint8)
# v_max = pred_disp.max()
# v_min = pred_disp.min()
# pred_disp = cv2.convertScaleAbs(pred_disp, 255/(v_max-v_min))
# color_disp = cv2.applyColorMap(pred_disp, cv2.COLORMAP_JET)
idx = i if is_evalAl else self.idx
skimage.io.imsave(self.disp_path[i], pred_disp)
self.signals.result.emit(i)
# except:
# pass#traceback.print_exc()
# finally:
self.signals.finished.emit()
def get_data_loader(args):
check_dataset(args)
dataset_configs = dl.DatasetParams(args.dataset_config_file)
dataset_params = dataset_configs.get_params(args.dataset)
# Get data loader
data_loader, _ = dl.get_loader(dataset_params, None, None, 128, shuffle=False,
num_workers=args.num_workers, skip_images=True,
unique_ids=True)
assert len(data_loader) != 0, 'ERROR: No captions found, please specify a dataset that has captions defined.'
assert args.dataset != 'coco', 'HINT: instead of "coco" use "coco:train2014"'
return data_loader
