def train_cnn():
modeltype = 'cnn'
train_batch_size = 2
sequence_length = 1
directory_type = 'DPM'
pixel = Pixel('pixel.pkl')
train_dataloader, train_data_size, val_dataloader, val_data_size = \
get_train_data(train_batch_size, sequence_length, directory_type, pixel)
cnnmodel = CNN()
if torch.cuda.is_available(): cnnmodel = cnnmodel.cuda()
for i, batch in enumerate(train_dataloader):
frame1 = Variable(torch.stack(batch[0])).squeeze(1)
frame2 = Variable(torch.stack(batch[1]))
labels = Variable(torch.LongTensor(batch[2]))
print(frame1.size())
print(frame2.size())
print(labels)
print(cnnmodel(frame1).size())
break
def __init__(self, VAL_FOLD, FOLD_NAME):
self.MODEL_SAVE = False
self.RESTORE = False
self.OLD_EPOCH = 0
if not self.RESTORE:
# Set up log directory
self.LOG_FOLDER = './log/' + FOLD_NAME + '/'
if not os.path.exists(self.LOG_FOLDER):
os.makedirs(self.LOG_FOLDER)
# Set up model directory individually
self.SESSION_DIR = self.LOG_FOLDER + str(VAL_FOLD) + '/'
if not os.path.exists(self.SESSION_DIR):
os.makedirs(self.SESSION_DIR)
else:
self.RESTORE_DATE = '20180422'
self.OLD_EPOCH = 2
self.LOG_FOLDER = './log/' + self.RESTORE_DATE + '/'
self.SESSION_DIR = self.LOG_FOLDER + str(VAL_FOLD) + '/'
# training
self.LEARNING_RATE = 0.001
self.SCENES = ['scene1']
# LSTM
self.NUM_HIDDEN = 512
self.NUM_LSTM = 3
# MLP
self.NUM_NEURON = 256
self.NUM_MLP = 3
# dropout
self.OUTPUT_THRESHOLD = 0.5
self.INPUT_KEEP_PROB = 1.0
self.OUTPUT_KEEP_PROB = 0.9
self.BATCH_SIZE = 70
self.EPOCHS = 300
self.FORGET_BIAS = 0.9
self.TIMELENGTH = 1000
self.MAX_GRAD_NORM = 5.0
self.NUM_CLASSES = 13
# Get rectangle
self.VAL_FOLD = VAL_FOLD
self.TRAIN_SET, self.PATHS = get_train_data(self.VAL_FOLD, self.SCENES,
self.EPOCHS,
self.TIMELENGTH)
self.VALID_SET = get_valid_data(self.VAL_FOLD, self.SCENES, 1,
self.TIMELENGTH)
self.TOTAL_SAMPLES = len(self.PATHS)
self.NUM_TRAIN = len(self.TRAIN_SET)
self.NUM_TEST = len(self.VALID_SET)
self.SET = {'train': self.TRAIN_SET, 'test': self.VALID_SET}
def train_motion(use_pickle=True):
modeltype = 'motion'
train_batch_size = 64
sequence_length = 6
directory_type = 'DPM'
pixel = Pixel('pixel.pkl')
if use_pickle: pixel.load()
pretrained = PreTrainedResnet({'intermediate_layers': ['fc']})
if torch.cuda.is_available():
pretrained = pretrained.cuda()
train_dataloader, train_data_size, val_dataloader, val_data_size = \
get_train_data(train_batch_size, sequence_length, directory_type, pixel, pretrained)
save_dir = 'models/{}/'.format(modeltype)
valfile = open('val.txt', 'a')
dict_args = {
'input_dim': 4,
'rnn_hdim': 200,
'rnn_type': 'LSTM',
'feature_dim': 100,
}
motmodel = MotionModel(dict_args)
num_epochs = 300
learning_rate = 1.0
criterion = nn.NLLLoss()
optimizer = optim.Adadelta(motmodel.parameters(),
lr=learning_rate,
rho=0.95,
eps=1e-06,
weight_decay=0)
if torch.cuda.is_available():
motmodel = motmodel.cuda()
criterion = criterion.cuda()
for epoch in range(num_epochs):
for i, batch in enumerate(train_dataloader):
trackcoords = Variable(torch.stack(batch[3]))
detectioncoord = Variable(torch.stack(batch[4]))
labels = Variable(torch.LongTensor(batch[2]))
if torch.cuda.is_available():
trackcoords = trackcoords.cuda()
detectioncoord = detectioncoord.cuda()
labels = labels.cuda()
motmodel = motmodel.train()
output, _ = motmodel(trackcoords, detectioncoord)
output = functional.log_softmax(output, dim=-1)
loss = criterion(output, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
nn.utils.clip_grad_norm(motmodel.parameters(), 5.0)
if ((i + 1) % 10 == 0):
print('Epoch: [{0}/{1}], Step: [{2}/{3}], Loss: {4}'.format( \
epoch+1, num_epochs, i+1, train_data_size//train_batch_size, loss.data[0]))
#Saving the model
if (epoch % 1 == 0):
if not os.path.isdir(
os.path.join(save_dir, "epoch{}".format(epoch))):
os.makedirs(os.path.join(save_dir, "epoch{}".format(epoch)))
filename = modeltype + '.pth'
file = open(
os.path.join(save_dir, "epoch{}".format(epoch), filename),
'wb')
torch.save(
{
'state_dict': motmodel.state_dict(),
'dict_args': dict_args
}, file)
print('Saving the model to {}'.format(save_dir +
"epoch{}".format(epoch)))
file.close()
#Validation accuracy
if (epoch % 1 == 0):
num_correct = 0.0
num_total = 0.0
for j, batch in enumerate(val_dataloader):
trackcoords = Variable(torch.stack(batch[3]))
detectioncoord = Variable(torch.stack(batch[4]))
labels = Variable(torch.LongTensor(batch[2]))
if torch.cuda.is_available():
trackcoords = trackcoords.cuda()
detectioncoord = detectioncoord.cuda()
labels = labels.cuda()
motmodel = motmodel.eval()
output, _ = motmodel(trackcoords, detectioncoord)
predictions = output.max(dim=-1)[1]
num_correct += (predictions == labels).sum().data[0]
num_total += len(labels)
accuracy = float(num_correct / num_total)
print('Epoch {} Accuracy {} \n'.format(epoch, accuracy))
valfile.write('Epoch {} Accuracy {} \n'.format(epoch, accuracy))
valfile.close()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--num_lights', type=int, default=1053)
parser.add_argument('--num_samples', type=int, default=5)
parser.add_argument('--degree', type=int, default=45, choices=[45, 90])
parser.add_argument(
'--sampler',
type=str,
default='original',
choices=['original', 'gaussian', 'categorical', 'basicAdaptive'])
parser.add_argument('--methods',
type=str,
default='sum',
choices=['sum', 'sample'])
parser.add_argument('--lr', type=float, default=0.0001)
parser.add_argument('--num_workers', type=int, default=2)
parser.add_argument('--num_scene', type=int, default=4)
parser.add_argument('--num_gt', type=int, default=18)
parser.add_argument('--path', type=str, default='exp')
parser.add_argument('--num_epochs', type=int, default=16)
parser.add_argument('--dataset_path',
type=str,
default='/home/hza/data/rendering/cropped.hdf5')
args = parser.parse_args()
if args.degree is not None:
degree = args.degree / 180. * np.pi
args.num_lights = (angles <= degree).sum()
global Light
Light = Light[np.where(angles <= degree)]
print('NUM_LIGHT:', args.num_lights)
net = RelightNetwork(args.num_lights,
args.num_samples,
type_sampler=args.sampler,
sample_methods=args.methods,
Light=Light).cuda()
optim = torch.optim.Adam(net.parameters(), args.lr)
def zipper(net, optim):
return {'optim': optim, 'net': net}
resume_if_exists(args.path, zipper(net, optim))
## todo: tensorboard for relightling effects
data = get_train_data(num_workers=args.num_workers,
batch_size=args.num_scene,
path=args.dataset_path,
degree=args.degree,
num_split=args.num_gt)
viewer = Visualizer(args.path)
for epochs in range(args.num_epochs):
b = data.__iter__()
num_batchs = len(b)
for j in tqdm.trange(num_batchs):
ids = (epochs + float(j) / num_batchs)
T = 1 + 5 * (ids + 0.0)**2.0
#T = 1 + 1000 * (ids+ 0.0) ** 2.0
tmp = next(b)
inps = tmp[0].cuda()
inps = (inps.permute(0, 1, 4, 2, 3).float() - 127.5) / 127.5
ws = []
gts = []
light_ids = tmp[1].numpy()
for scene_id in range(len(inps)):
w = []
gt = []
for k in range(args.num_gt):
#sampled = np.random.randint(args.num_lights)
sampled = light_ids[scene_id][k]
w.append(Light[sampled])
gt.append(inps[scene_id][sampled])
ws.append(torch.stack(w, dim=0))
gts.append(torch.stack(gt, dim=0))
gts = torch.stack(gts, dim=0)
ws = torch.stack(ws, dim=0)
optim.zero_grad()
out, logp = net(inps, ws, alpha=T)
gts = gts.view(gts.size(0) * gts.size(1), *gts.size()[2:])
loss = ((out - gts)**2).mean(dim=3).mean(dim=2).mean(
dim=1) #nn.functional.mse_loss(out, gts)
adv = loss.detach().reshape(len(inps), -1).sum(dim=1)
prob_loss = (adv * logp).mean()
total_loss = loss.mean() + prob_loss
total_loss.backward()
optim.step()
if j % 100 == 0:
toshow = torch.cat((gts, out),
dim=3).detach().cpu().detach().numpy()
toshow = np.minimum(toshow, 1)
toshow = np.maximum(toshow, -1)
toshow = (toshow * 127.5 + 127.5).astype(np.uint8)
#if j % 3000 == 0:
if args.sampler == 'original':
mask = [
nn.functional.softmax(net.sample.mask * T,
dim=0).cpu().detach().numpy()
]
else:
mask = net.sample.extra_output
imgs = []
for mask in mask:
#inds = mask.argmax(axis=0)
#values = [mask[inds[i], i] for i in range(inds.shape[0])]
tmp = []
for j in range(mask.shape[1]):
tmp.append(viewDirection(mask[:, j], args.degree, 31))
tmp = np.concatenate(tmp, axis=1)
imgs.append(tmp)
imgs = np.float32(np.concatenate(imgs))
viewer({
'img': toshow,
'loss': loss.mean().cpu().detach().numpy(),
'prob_loss': prob_loss.cpu().detach().numpy(),
'attention': imgs[None, None, :]
})
dict = zipper(net, optim)
save(args.path, dict, epochs)
def train_driver(model_name,
pretrained,
load_choice,
models_path,
train_data_path,
val_data_path,
num_epochs,
batch_size,
image_size,
num_workers,
use_num_worker_mult=True):
"""Loads and trains the selected model.
Attributes:
model (models): The model to be trained.
model_epoch (int): The last epoch of the loaded model.
dataloaders (dict): Dictionary of {train:training dataloader, val:validation dataloader}
loss_function (loss): The loss function.
optimizer (optim): The optimizer.
is_inception (bool): True if the model is the Inception network.
device (device): The GPU device to train on.
Args:
model_name (str): The name of the model.
pretrained (bool): True to load a pretrained model, False to load an untrained model.
load_choice (int): The model version to be loaded. -1 for a new model.
models_path (str): The folder path where saved models are stored.
train_data_path (str): The folder path where training images are stored.
val_data_path (str): The folder path where validation images are stored.
num_epochs (int): The number of epochs to train for.
batch_size (int): The number of images per batch.
image_size (int): The size for all images to be resized to.
num_workers (int): The number of workers for DataLoader.
use_num_worker_mult (bool): If False, number of workers = num_workers.
If True, number of workers = num_workers times number of CPU cores.
"""
if use_num_worker_mult:
cpu_cores = int(multiprocessing.cpu_count())
num_workers = num_workers * cpu_cores
print(f"Number of CPU cores: {cpu_cores}")
print(f"Number of workers: {num_workers}")
train_loader, val_loader, num_classes = dataloader.get_train_data(
train_data_path,
val_data_path,
batch_size=batch_size,
image_size=image_size,
num_workers=num_workers)
dataloaders = {'train': train_loader, 'val': val_loader}
model, model_epoch = get_model(model_name, pretrained, load_choice,
num_classes, models_path)
print(f"Previous epoch: {model_epoch}")
if model is not None:
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
if device != "cpu":
if torch.cuda.device_count() > 1:
print(f"{torch.cuda.device_count()}GPUs detected.")
model = torch.nn.DataParallel(model)
model = model.to(device)
print(f"Device: {device}")
loss_function = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
train_model(model,
model_name,
models_path,
model_epoch,
dataloaders,
loss_function,
optimizer,
num_epochs,
device,
is_inception=(model_name == "inception"))