def main():
"""Trains a CNN."""
model_fname = 'cnn_model.npz'
stats_fname = 'cnn_stats.npz'
# Hyper-parameters. Modify them if needed.
eps = [0.01] #[0.001, 0.01, 0.1, 0.5, 1.0]
momentum = [0.9] #[0.0, 0.45, 0.9]
num_epochs = 30
filter_size = 5
num_filters_1 = 5
num_filters_2 = 2
batch_size = [100] #[500, 1000]
# Input-output dimensions.
num_channels = 1
num_outputs = 7
# Initialize model.
model = InitCNN(num_channels, filter_size, num_filters_1, num_filters_2,
num_outputs)
# Uncomment to reload trained model here.
# model = Load(model_fname)
# Check gradient implementation.
print('Checking gradients...')
x = np.random.rand(10, 48, 48, 1) * 0.1
CheckGrad(model, CNNForward, CNNBackward, 'W3', x)
CheckGrad(model, CNNForward, CNNBackward, 'b3', x)
CheckGrad(model, CNNForward, CNNBackward, 'W2', x)
CheckGrad(model, CNNForward, CNNBackward, 'b2', x)
CheckGrad(model, CNNForward, CNNBackward, 'W1', x)
CheckGrad(model, CNNForward, CNNBackward, 'b1', x)
print("passed grad check")
model = InitCNN(num_channels, filter_size, num_filters_1, num_filters_2,
num_outputs)
dir = str(0.01) + "\\" + str(0.9) + "\\" + str(100) + "\\"
if os.path.exists(dir):
filelist = [f for f in os.listdir(".") if f.endswith(".bak")]
for f in filelist:
os.remove(f)
else:
os.makedirs(dir)
model, stats = Train(model, CNNForward, CNNBackward, CNNUpdate, eps[0],
momentum[0], num_epochs, batch_size[0])
# Uncomment if you wish to save the model.
Save(dir + model_fname, model)
# Uncomment if you wish to save the training statistics.
Save(dir + stats_fname, stats)
SavePlot(0, dir + "cross_entropy.png")
SavePlot(1, dir + "accuracy.png")
'''
def main():
"""Trains a NN."""
model_fname = 'nn_model.npz'
stats_fname = 'nn_stats.npz'
# Hyper-parameters. Modify them if needed.
num_hiddens = [0, 0] #[150,20] [6,2] [200, 140]
eps = [0.01] #[0.001, 0.01, 0.1, 0.5, 1.0]
momentum = [0.0] #[0.0, 0.45, 0.9]
num_epochs = 1000
batch_size = [100] #[1, 10, 100, 500, 1000]
# Input-output dimensions.
num_inputs = 2304
num_outputs = 7
# Initialize model.
model = InitNN(num_inputs, num_hiddens, num_outputs)
# Uncomment to reload trained model here.
# model = Load(model_fname)
# Check gradient implementation.
print('Checking gradients...')
x = np.random.rand(10, 48 * 48) * 0.1
CheckGrad(model, NNForward, NNBackward, 'W1', x)
CheckGrad(model, NNForward, NNBackward, 'b1', x)
print("passed grad check")
for e in eps:
for m in momentum:
for b in batch_size:
model = InitNN(num_inputs, num_hiddens, num_outputs)
# Train model.
dir = str(e) + "\\" + str(m) + "\\" + str(b) + "\\"
if os.path.exists(dir):
filelist = [
f for f in os.listdir(".") if f.endswith(".bak")
]
for f in filelist:
os.remove(f)
else:
os.makedirs(dir)
model, stats = Train(model, NNForward, NNBackward, NNUpdate, e,
m, num_epochs, b)
# Uncomment if you wish to save the model.
Save(dir + model_fname, model)
# Uncomment if you wish to save the training statistics.
Save(dir + stats_fname, stats)
SavePlot(0, dir + "cross_entropy.png")
SavePlot(1, dir + "accuracy.png")
def main():
'''parameter initialization'''
args = parser.parse_args()
exp_name_dir = util.experiment_name_dir(args.experiment_name)
'''model on gpu'''
model = TrackerSiamRPN()
model.net.init_weights()
'''setup train data loader'''
name = 'VID'
assert name in ['VID', 'GOT-10k', 'All']
if name == 'GOT-10k':
root_dir = args.train_path
seq_dataset = GOT10k(root_dir, subset='val')
elif name == 'VID':
root_dir = '/home/arbi/desktop/ILSVRC2017_VID'
seq_dataset = ImageNetVID(root_dir, subset=('train', 'val'))
elif name == 'All':
root_dir_vid = '/home/arbi/desktop/ILSVRC2017_VID'
seq_datasetVID = ImageNetVID(root_dir_vid, subset=('train'))
root_dir_got = args.train_path
seq_datasetGOT = GOT10k(root_dir_got, subset='train')
seq_dataset = util.data_split(seq_datasetVID, seq_datasetGOT)
print('seq_dataset', len(seq_dataset))
train_data = TrainDataLoader(seq_dataset, name)
train_loader = DataLoader(dataset=train_data,
batch_size=64,
shuffle=True,
num_workers=16,
pin_memory=True)
'''setup val data loader'''
name = 'GOT-10k'
assert name in ['VID', 'GOT-10k', 'All']
if name == 'GOT-10k':
root_dir = args.train_path
seq_dataset_val = GOT10k(root_dir, subset='val')
elif name == 'VID':
root_dir = '/home/arbi/desktop/ILSVRC2017_VID'
seq_dataset_val = ImageNetVID(root_dir, subset=('val'))
elif name == 'All':
root_dir_vid = '/home/arbi/desktop/ILSVRC2017_VID/ILSVRC'
seq_datasetVID = ImageNetVID(root_dir_vid, subset=('val'))
root_dir_got = args.train_path
seq_datasetGOT = GOT10k(root_dir_got, subset='val')
seq_dataset_val = util.data_split(seq_datasetVID, seq_datasetGOT)
print('seq_dataset_val', len(seq_dataset_val))
val_data = TrainDataLoader(seq_dataset_val, name)
val_loader = DataLoader(dataset=val_data,
batch_size=8,
shuffle=False,
num_workers=16,
pin_memory=True)
'''load weights'''
if not args.checkpoint_path == None:
assert os.path.isfile(
args.checkpoint_path), '{} is not valid checkpoint_path'.format(
args.checkpoint_path)
checkpoint = torch.load(args.checkpoint_path, map_location='cpu')
if 'model' in checkpoint.keys():
model.net.load_state_dict(
torch.load(args.checkpoint_path, map_location='cpu')['model'])
else:
model.net.load_state_dict(
torch.load(args.checkpoint_path, map_location='cpu'))
#model.net.load_state_dict(torch.load(args.checkpoint_path, map_location=lambda storage, loc: storage))
print('You are loading the model.load_state_dict')
elif config.pretrained_model:
#print("init with pretrained checkpoint %s" % config.pretrained_model + '\n')
#print('------------------------------------------------------------------------------------------------ \n')
checkpoint = torch.load(config.pretrained_model)
# change name and load parameters
checkpoint = {
k.replace('features.features', 'featureExtract'): v
for k, v in checkpoint.items()
}
model_dict = model.net.state_dict()
model_dict.update(checkpoint)
model.net.load_state_dict(model_dict)
torch.cuda.empty_cache()
'''train phase'''
train_closses, train_rlosses, train_tlosses = AverageMeter(), AverageMeter(
), AverageMeter()
val_closses, val_rlosses, val_tlosses = AverageMeter(), AverageMeter(
), AverageMeter()
train_val_plot = SavePlot(exp_name_dir, 'train_val_plot')
for epoch in range(config.epoches):
model.net.train()
if config.fix_former_3_layers:
if 1 > 1:
util.freeze_layers(model.net.module)
else:
util.freeze_layers(model.net)
print('Train epoch {}/{}'.format(epoch + 1, config.epoches))
train_loss = []
with tqdm(total=config.train_epoch_size) as progbar:
for i, dataset in enumerate(train_loader):
closs, rloss, loss = model.step(epoch, dataset, train=True)
closs_ = closs.cpu().item()
if np.isnan(closs_):
sys.exit(0)
train_closses.update(closs.cpu().item())
train_rlosses.update(rloss.cpu().item())
train_tlosses.update(loss.cpu().item())
progbar.set_postfix(closs='{:05.3f}'.format(train_closses.avg),
rloss='{:05.3f}'.format(train_rlosses.avg),
tloss='{:05.3f}'.format(train_tlosses.avg))
progbar.update()
train_loss.append(train_tlosses.avg)
if i >= config.train_epoch_size - 1:
'''save plot'''
#train_val_plot.update(train_tlosses.avg, train_label = 'total loss')
'''save model'''
model.save(model, exp_name_dir, epoch)
break
train_loss = np.mean(train_loss)
'''val phase'''
val_loss = []
with tqdm(total=config.val_epoch_size) as progbar:
print('Val epoch {}/{}'.format(epoch + 1, config.epoches))
for i, dataset in enumerate(val_loader):
val_closs, val_rloss, val_tloss = model.step(epoch,
dataset,
train=False)
closs_ = val_closs.cpu().item()
if np.isnan(closs_):
sys.exit(0)
val_closses.update(val_closs.cpu().item())
val_rlosses.update(val_rloss.cpu().item())
val_tlosses.update(val_tloss.cpu().item())
progbar.set_postfix(closs='{:05.3f}'.format(val_closses.avg),
rloss='{:05.3f}'.format(val_rlosses.avg),
tloss='{:05.3f}'.format(val_tlosses.avg))
progbar.update()
val_loss.append(val_tlosses.avg)
if i >= config.val_epoch_size - 1:
break
val_loss = np.mean(val_loss)
train_val_plot.update(train_loss, val_loss)
print('Train loss: {}, val loss: {}'.format(train_loss, val_loss))
def main(args):
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
Net = DDNet(device)
Net.to(device)
train_data_roots = ('/media/nlpr/zwzhou/数据资源/MOT16/train',
'/media/nlpr/zwzhou/数据资源/MOT15/train')
train_subsets = (('MOT16-02', 'MOT16-04', 'MOT16-05', 'MOT16-10',
'MOT16-11', 'MOT16-13'),
('ADL-Rundle-6', 'ETH-Bahnhof', 'ETH-Pedcross2',
'ETH-Sunnyday', 'KITTI-13', 'KITTI-17', 'PETS09-S2L1',
'TUD-Stadtmitte', 'Venice-2'))
mot_dataset = DDDataset(train_data_roots, train_subsets)
mot_dataloader = DataLoader(mot_dataset,
batch_size=config.train_batch_size,
shuffle=True,
pin_memory=True,
num_workers=32,
drop_last=True,
collate_fn=collate_fn)
# resume
if args.ckp is not None:
assert os.path.isfile(args.ckp)
Net.load_state_dict(torch.load(args.ckp, map_location='cpu'))
torch.cuda.empty_cache()
print('Train net from: %s' % args.ckp)
if args.val_data_root is not None:
val_data_roots = ('/media/nlpr/zwzhou/数据资源/MOT16/train',
'/media/nlpr/zwzhou/数据资源/MOT15/train')
val_subsets = (('MOT16-09', ), ('TUD-Campus', 'ADL-Rundle-8'))
val_dataset = DDDataset(val_data_roots, val_subsets, transform=False)
val_dataloader = DataLoader(val_dataset,
batch_size=config.train_batch_size,
shuffle=False,
pin_memory=True,
num_workers=16,
drop_last=False,
collate_fn=collate_fn)
val_avg_loss, val_avg_closs, val_avg_rloss, val_avg_dloss = AverageMeter(
), AverageMeter(), AverageMeter(), AverageMeter()
train_val_plot = SavePlot('debug', 'train_val_plot')
avg_loss, avg_closs, avg_rloss, avg_dloss = AverageMeter(), AverageMeter(
), AverageMeter(), AverageMeter()
print('Training without RAMModule ...')
for epoch in range(config.epoches):
Net.train()
print('Train epoch {}/{}'.format(epoch + 1, config.epoches))
train_loss = []
with tqdm(total=len(mot_dataloader)) as progbar:
for _, batch in enumerate(mot_dataloader):
closs, rloss, dloss, loss = Net.step(batch)
closs_ = closs.cpu().item()
if np.isnan(closs_): sys.exit(0)
avg_closs.update(closs.cpu().item())
avg_rloss.update(rloss.cpu().item())
avg_dloss.update(dloss.cpu().item())
avg_loss.update(loss.cpu().item())
progbar.set_postfix(closs='{:05.5f}'.format(avg_closs.avg),
rloss='{:05.5f}'.format(avg_rloss.avg),
sloss='{:05.5f}'.format(avg_dloss.avg),
tloss='{:05.3f}'.format(avg_loss.avg))
progbar.update()
train_loss.append(avg_loss.avg)
train_loss = np.mean(train_loss)
if args.val_data_root is not None:
# 验证集
Net.eval()
val_loss = []
print('Validation epoch {}/{}'.format(epoch + 1, config.epoches))
with tqdm(total=len(val_dataloader)) as progbar:
for _, batch in enumerate(val_dataloader):
closs, rloss, dloss, loss = Net.step(batch, train=False)
closs_ = closs.cpu().item()
if np.isnan(closs_): sys.exit(0)
val_avg_closs.update(closs.cpu().item())
val_avg_rloss.update(rloss.cpu().item())
val_avg_dloss.update(dloss.cpu().item())
val_avg_loss.update(loss.cpu().item())
progbar.set_postfix(
closs='{:05.5f}'.format(val_avg_closs.avg),
rloss='{:05.5f}'.format(val_avg_rloss.avg),
sloss='{:05.5f}'.format(val_avg_dloss.avg),
tloss='{:05.3f}'.format(val_avg_loss.avg))
progbar.update()
val_loss.append(val_avg_loss.avg)
val_loss = np.mean(val_loss)
train_val_plot.update(train_loss, val_loss)
print('Train loss: {}, val loss: {}'.format(train_loss, val_loss))
'''save model'''
Net.save(Net, 'weights', 100)
def main():
"""Trains a NN."""
model_fname = 'nn_model.npz'
stats_fname = 'nn_stats.npz'
# Hyper-parameters. Modify them if needed.
num_hiddens = [16, 32] #[150,20] [6,2] [200, 140]
eps = [0.01] #[0.001, 0.01, 0.1, 0.5, 1.0]
momentum = [0.9] #[0.0, 0.45, 0.9]
num_epochs = 1000
batch_size = [100] #[1, 10, 100, 500, 1000]
# Input-output dimensions.
num_inputs = 2304
num_outputs = 7
# Initialize model.
model = InitNN(num_inputs, num_hiddens, num_outputs)
# Uncomment to reload trained model here.
model = Load(
"C:\\Users\\Adam\\Documents\\Masters\\Machine Learning\\A2\\NN\\NN_Results\\0.01\\0.0\\100\\nn_model.npz"
)
# Check gradient implementation.
print('Checking gradients...')
x = np.random.rand(10, 48 * 48) * 0.1
CheckGrad(model, NNForward, NNBackward, 'W3', x)
CheckGrad(model, NNForward, NNBackward, 'b3', x)
CheckGrad(model, NNForward, NNBackward, 'W2', x)
CheckGrad(model, NNForward, NNBackward, 'b2', x)
CheckGrad(model, NNForward, NNBackward, 'W1', x)
CheckGrad(model, NNForward, NNBackward, 'b1', x)
print("passed grad check")
inputs_train, inputs_valid, inputs_test, target_train, target_valid, target_test = LoadData(
'../toronto_face.npz')
#print(inputs_test.shape)
Evaluate(inputs_test, target_test, model, NNForward, 1)
for e in eps:
for m in momentum:
for b in batch_size:
model = InitNN(num_inputs, num_hiddens, num_outputs)
# Train model.
dir = str(e) + "\\" + str(m) + "\\" + str(b) + "\\"
if os.path.exists(dir):
filelist = [
f for f in os.listdir(".") if f.endswith(".bak")
]
for f in filelist:
os.remove(f)
else:
os.makedirs(dir)
model, stats = Train(model, NNForward, NNBackward, NNUpdate, e,
m, num_epochs, b)
# Uncomment if you wish to save the model.
Save(dir + model_fname, model)
# Uncomment if you wish to save the training statistics.
Save(dir + stats_fname, stats)
SavePlot(0, dir + "cross_entropy.png")
SavePlot(1, dir + "accuracy.png")
def main():
'''parameter initialization'''
args = parser.parse_args()
exp_name_dir = util.experiment_name_dir(args.experiment_name)
'''model on gpu'''
model = TrackerSiamRPN()
'''setup train data loader'''
name = 'GOT-10k'
assert name in ['VID', 'GOT-10k', 'All']
if name == 'GOT-10k':
root_dir = args.train_path
seq_dataset = GOT10k(root_dir, subset='train')
elif name == 'VID':
root_dir = '/store_ssd/ILSVRC'
seq_dataset = ImageNetVID(root_dir, subset=('train'))
elif name == 'All':
root_dir_vid = '/store_ssd/ILSVRC'
seq_datasetVID = ImageNetVID(root_dir_vid, subset=('train'))
root_dir_got = args.train_path
seq_datasetGOT = GOT10k(root_dir_got, subset='train')
seq_dataset = util.data_split(seq_datasetVID, seq_datasetGOT)
print('seq_dataset', len(seq_dataset))
train_z_transforms = transforms.Compose([ToTensor()])
train_x_transforms = transforms.Compose([
RandomCrop([config.detection_img_size, config.detection_img_size],
config.max_translate),
RandomScale(config.scale_resize),
ToTensor()
])
train_data = TrainDataLoader(seq_dataset, train_z_transforms,
train_x_transforms, name)
anchors = train_data.anchors
train_loader = DataLoader(dataset=train_data,
batch_size=config.train_batch_size,
shuffle=True,
num_workers=config.train_num_workers,
pin_memory=True)
'''setup val data loader'''
name = 'GOT-10k'
assert name in ['VID', 'GOT-10k', 'All']
if name == 'GOT-10k':
root_dir = args.train_path
seq_dataset_val = GOT10k(root_dir, subset='val')
elif name == 'VID':
root_dir = '/store_ssd/ILSVRC'
seq_dataset_val = ImageNetVID(root_dir, subset=('val'))
elif name == 'All':
root_dir_vid = '/store_ssd/ILSVRC'
seq_datasetVID = ImageNetVID(root_dir_vid, subset=('val'))
root_dir_got = args.train_path
seq_datasetGOT = GOT10k(root_dir_got, subset='val')
seq_dataset_val = util.data_split(seq_datasetVID, seq_datasetGOT)
print('seq_dataset_val', len(seq_dataset_val))
valid_z_transforms = transforms.Compose([ToTensor()])
valid_x_transforms = transforms.Compose([ToTensor()])
val_data = TrainDataLoader(seq_dataset_val, valid_z_transforms,
valid_x_transforms, name)
val_loader = DataLoader(dataset=val_data,
batch_size=config.valid_batch_size,
shuffle=False,
num_workers=config.valid_num_workers,
pin_memory=True)
'''load weights'''
if not args.checkpoint_path == None and args.epoch_i > 0:
checkpoint_path = os.path.join(args.checkpoint_path,
'model_e{}.pth'.format(args.epoch_i))
assert os.path.isfile(
checkpoint_path), '{} is not valid checkpoint_path'.format(
checkpoint_path)
checkpoint = torch.load(checkpoint_path, map_location='cpu')
if 'model' in checkpoint.keys():
model.net.load_state_dict(
torch.load(checkpoint_path, map_location='cpu')['model'])
else:
model.net.load_state_dict(
torch.load(checkpoint_path, map_location='cpu'))
torch.cuda.empty_cache()
print('You are loading the model.load_state_dict')
elif config.pretrained_model:
checkpoint = torch.load(config.pretrained_model)
# change name and load parameters
checkpoint = {
k.replace('features.features', 'featureExtract'): v
for k, v in checkpoint.items()
}
model_dict = model.net.state_dict()
model_dict.update(checkpoint)
model.net.load_state_dict(model_dict)
#torch.cuda.empty_cache()
print('You are loading the pretrained model')
'''train phase'''
train_closses, train_rlosses, train_tlosses = AverageMeter(), AverageMeter(
), AverageMeter()
val_closses, val_rlosses, val_tlosses = AverageMeter(), AverageMeter(
), AverageMeter()
train_val_plot = SavePlot(exp_name_dir, 'train_val_plot')
model.adjust_lr(args.epoch_i)
for epoch in range(args.epoch_i, config.epoches):
model.net.train()
if config.fix_former_3_layers:
util.freeze_layers(model.net)
print('Train epoch {}/{}'.format(epoch + 1, config.epoches))
train_loss = []
with tqdm(total=config.train_epoch_size) as progbar:
for i, dataset in enumerate(train_loader):
closs, rloss, loss = model.step(epoch,
dataset,
anchors,
i,
train=True)
closs_ = closs.cpu().item()
if np.isnan(closs_):
sys.exit(0)
train_closses.update(closs.cpu().item())
train_rlosses.update(rloss.cpu().item())
train_tlosses.update(loss.cpu().item())
progbar.set_postfix(closs='{:05.3f}'.format(train_closses.avg),
rloss='{:05.5f}'.format(train_rlosses.avg),
tloss='{:05.3f}'.format(train_tlosses.avg))
progbar.update()
train_loss.append(train_tlosses.avg)
if i >= config.train_epoch_size - 1:
'''save model'''
model.save(model, exp_name_dir, epoch)
break
train_loss = np.mean(train_loss)
'''val phase'''
val_loss = []
with tqdm(total=config.val_epoch_size) as progbar:
print('Val epoch {}/{}'.format(epoch + 1, config.epoches))
for i, dataset in enumerate(val_loader):
val_closs, val_rloss, val_tloss = model.step(epoch,
dataset,
anchors,
train=False)
closs_ = val_closs.cpu().item()
if np.isnan(closs_):
sys.exit(0)
val_closses.update(val_closs.cpu().item())
val_rlosses.update(val_rloss.cpu().item())
val_tlosses.update(val_tloss.cpu().item())
progbar.set_postfix(closs='{:05.3f}'.format(val_closses.avg),
rloss='{:05.5f}'.format(val_rlosses.avg),
tloss='{:05.3f}'.format(val_tlosses.avg))
progbar.update()
val_loss.append(val_tlosses.avg)
if i >= config.val_epoch_size - 1:
break
val_loss = np.mean(val_loss)
train_val_plot.update(train_loss, val_loss)
print('Train loss: {}, val loss: {}'.format(train_loss, val_loss))