def main():
args = parser.parse_args()
print_arguments(args)
if not os.path.exists(args.cleaned_model_dir):
os.makedirs(args.cleaned_model_dir)
items = os.listdir(args.ema_model_dir)
for item in items:
if item.find('ema') > -1:
item_clean = item.replace('_ema_0', '')
shutil.copyfile(os.path.join(args.ema_model_dir, item),
os.path.join(args.cleaned_model_dir, item_clean))
elif item.find('mean') > -1 or item.find('variance') > -1:
shutil.copyfile(os.path.join(args.ema_model_dir, item),
os.path.join(args.cleaned_model_dir, item))
def main(args):
'''
Main function that constructs, trains and evaluates the model
:param args: Input arguments
:return:
'''
if args.verbose:
print_arguments(args=args)
try:
model = construct_model(args=args)
model_trained = train_model(model=model, args=args)
evaluate_model(model=model_trained, args=args)
except:
print('Error occured in training or evaluation!!')
def main():
args = parser.parse_args()
print_arguments(args)
in_path = args.images_path
print('cutting......')
# in_path = 'input.png'
cut_path = 'cut_map'
comb_path = 'comb_map'
outname = in_path + '_predict.png'
h_step,w_step,h_rest,w_rest,img_shape,img_exp_shape,data_list = image_cut(in_path,cut_path)
check_gpu(args.use_gpu)
print('predicting......')
infer(args,cut_path,data_list,comb_path)
print('combining......')
image_comb(h_step,w_step,h_rest,w_rest,img_shape,img_exp_shape,outname,comb_path)
evaluate(exe, test_program, test_pyreader, test_ret)
if args.do_infer:
# create dict
id2word_dict = dict([(str(word_id), word)
for word, word_id in reader.vocab.items()])
id2label_dict = dict([(str(label_id), label)
for label, label_id in reader.label_map.items()])
Dataset = namedtuple("Dataset", ["id2word_dict", "id2label_dict"])
dataset = Dataset(id2word_dict, id2label_dict)
infer_pyreader.start()
while True:
try:
(words, crf_decode) = exe.run(
infer_program,
fetch_list=[infer_ret["words"], infer_ret["crf_decode"]],
return_numpy=False)
# User should notice that words had been clipped if long than args.max_seq_len
results = utils.parse_result(words, crf_decode, dataset)
for result in results:
print(result)
except fluid.core.EOFException:
infer_pyreader.reset()
break
if __name__ == "__main__":
utils.print_arguments(args)
main(args)
paddle.gather(old_log_policies, batch_indices))
advantage = paddle.gather(advantages, batch_indices)
actor_loss = paddle.clip(ratio, 1.0 - args.epsilon,
1.0 + args.epsilon) * advantage
actor_loss = paddle.concat([
paddle.unsqueeze(ratio * advantage, axis=0),
paddle.unsqueeze(actor_loss, axis=0)
])
actor_loss = -paddle.mean(paddle.min(actor_loss, axis=0))
# 计算critic损失
critic_loss = F.smooth_l1_loss(paddle.gather(R, batch_indices),
value.squeeze())
entropy_loss = paddle.mean(new_m.entropy())
# 计算全部损失
total_loss = actor_loss + critic_loss - args.beta * entropy_loss
# 计算梯度
total_loss.backward()
optimizer.step()
optimizer.clear_grad()
paddle.save(
model.state_dict(),
"{}/model_{}.pdparams".format(args.saved_path, args.game))
print("Episode: {}. Total loss: {:.4f}".format(curr_episode,
total_loss.numpy()[0]))
if __name__ == "__main__":
args = get_args()
print_arguments(args)
train(args)
parser.add_argument("-j",
"--num_workers",
default=4,
type=int,
help="reader worker number")
parser.add_argument("-p",
"--pretrain_weights",
default=None,
type=str,
help="path to pretrained weights")
parser.add_argument("-r",
"--resume",
default=None,
type=str,
help="path to model weights")
parser.add_argument("-w",
"--weights",
default=None,
type=str,
help="path to weights for evaluation")
parser.add_argument(
"-s",
"--save_dir",
default=None,
type=str,
help="directory path for checkpoint saving, default ./yolo_checkpoint")
FLAGS = parser.parse_args()
print_arguments(FLAGS)
assert FLAGS.data, "error: must provide data path"
main()
def main():
args = parser.parse_args()
print_arguments(args)
check_gpu(args.use_gpu)
eval(args)
def main():
args = parser.parse_args()
print_arguments(args)
infer(args)
def main():
tstart = time.time()
parser = argparse.ArgumentParser(description='xxx')
# Data parameters
parser.add_argument('--seed',
default=0,
type=int,
help='(default=%(default)d)')
parser.add_argument('--device', default='cuda:0', type=str, help='gpu id')
parser.add_argument('--approach',
default='lwf',
type=str,
help='approach used')
parser.add_argument('--experiment', default='MI', type=str)
parser.add_argument('--data_dir',
default='data',
type=str,
help='data directory')
parser.add_argument('--ntasks', default=10, type=int)
parser.add_argument('--pc-valid', default=0.02, type=float)
parser.add_argument('--workers', default=4, type=int)
# Training parameters
parser.add_argument('--output', default='', type=str, help='')
parser.add_argument('--checkpoint_dir',
default='checkpoints/',
type=str,
help='')
parser.add_argument('--nepochs', default=200, type=int, help='')
parser.add_argument('--sbatch', default=64, type=int, help='')
parser.add_argument('--lr', default=0.05, type=float, help='')
parser.add_argument('--momentum', default=0.9, type=float)
parser.add_argument('--weight-decay', default=0.0, type=float)
parser.add_argument('--resume', default='no', type=str, help='resume?')
parser.add_argument('--sti', default=0, type=int, help='starting task?')
parser.add_argument('--mul', default=2, type=int)
args = parser.parse_args()
utils.print_arguments(args)
#####################################################################################
# Seed
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(args.seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
print('Using device:', args.device)
checkpoint = utils.make_directories(args)
args.checkpoint = checkpoint
print()
# Args -- Experiment
from dataloaders.miniimagenet import DatasetGen
# Args -- Approach
if args.approach == 'ewc':
from approaches import ewc as approach
elif args.approach == 'sgd':
from approaches import sgd as approach
elif args.approach == 'sgd-frozen':
from approaches import sgd_frozen as approach
elif args.approach == 'imm-mode':
from approaches import imm_mode as approach
elif args.approach == 'lwf':
from approaches import lwf as approach
else:
raise NotImplementedError("approach currently not implemented")
# Args -- Network
if args.approach != 'hat':
from networks import alexnet as network
else:
from networks import alexnet_hat as network
########################################################################################
print()
print("Starting this run on :")
print(datetime.now().strftime("%Y-%m-%d %H:%M"))
# Load
print('Load data...')
# prepare data for each task
datagen = DatasetGen(args)
for task_id in range(args.ntasks):
datagen.get(task_id)
print('\nTask info =', datagen.taskcla)
args.num_tasks = len(datagen.taskcla)
args.inputsize, args.taskcla = datagen.inputsize, datagen.taskcla
# Inits
print('Inits...')
model = network.Net(args).to(args.device)
# print number of parameters
count = 0
for p in model.parameters():
count += np.prod(p.size())
print('model size in MB: ', count * 4 / (1024 * 1024))
print('-' * 100)
appr = approach.Appr(model, args=args)
print('-' * 100)
if args.resume == 'yes':
checkpoint = torch.load(
os.path.join(args.checkpoint, 'model_{}.pth.tar'.format(args.sti)))
model.load_state_dict(checkpoint['model_state_dict'])
model = model.to(device=args.device)
else:
args.sti = 0
# Loop tasks
acc = np.zeros((len(args.taskcla), len(args.taskcla)), dtype=np.float32)
lss = np.zeros((len(args.taskcla), len(args.taskcla)), dtype=np.float32)
for task, ncla in args.taskcla[args.sti:]:
data_t = datagen.dataloaders[task]
print('*' * 100)
print('Task {:2d} ({:s})'.format(task, data_t['name']))
print('*' * 100)
# Train
appr.train(task, data_t['train'], data_t['valid'])
print('-' * 100)
appr.save_model(task)
# Test
for u in range(task + 1):
data_u = datagen.dataloaders[u]
test_loss, test_acc = appr.eval(u, data_u['test'])
print(
'>>> Test on task {:2d} - {:15s}: loss={:.3f}, acc={:5.3f}% <<<'
.format(u, data_u['name'], test_loss, 100 * test_acc))
acc[task, u] = test_acc
lss[task, u] = test_loss
# Save
print('Save at ' + args.checkpoint)
np.savetxt(
os.path.join(args.checkpoint,
'{}_{}.txt'.format(args.approach, args.seed)), acc,
'%.5f')
utils.print_log_acc_bwt(args, acc, lss)
print('[Elapsed time = {:.1f} h]'.format(
(time.time() - tstart) / (60 * 60)))
baselines_output_folder = None
embedding_stats = test_embeddings.run_test(
model,
train_dataloader.dataset,
val_dataloader.dataset,
test_dataloader.dataset,
epochs=100,
batch_size=16,
lr=1e-3,
embedding_dim=args.embedding_dim,
es_tmpdir=args.es_tmpdir,
hidden_dim=args.embedding_dim,
early_stopping=True,
output_folder=baselines_output_folder,
device=args.device)
cv_baselines_test_stats.update(embedding_stats)
print("\n\n############## Baseline Multitask GCN ##############")
ut.print_cv_stats(cv_test_stats)
if args.test_emb:
cv_baselines_test_stats.print_stats()
return cv_test_stats, model
if __name__ == "__main__":
args = parse_arguments("ConcurrentMultiTaskGCN")
ut.set_seeds()
ut.print_arguments(args)
cv_stats, model = run(args)
def main():
args = parser.parse_args()
print_arguments(args)
eval(args)
def main():
# create an argument parser
parser = argparse.ArgumentParser()
parser.add_argument('-r',
'--root_directory',
help='Root directory for EXPERIMENTS data')
parser.add_argument(
'-f',
'--figures_directory',
help=
'Figures directory in root directory for CorMap Analysis (default=Figures)',
type=str,
default='Figures')
parser.add_argument('--skip',
help='Frames need to be skipped (default=1)',
type=int,
default=0)
parser.add_argument('--crop',
help='Whether to crop curves (default=False)',
type=str2bool,
default=False)
parser.add_argument('--crop_qmin',
help='min q for cropping',
type=float,
default=0.0)
parser.add_argument('--crop_qmax',
help='max q for cropping',
type=float,
default=-1.0)
parser.add_argument('--scale',
help='Whether to scale curves (default=False)',
type=str2bool,
default=False)
parser.add_argument('--scale_qmin',
help='min q for scaling',
type=float,
default=0.0)
parser.add_argument('--scale_qmax',
help='max q for scaling',
type=float,
default=-1.0)
# parse arguments
args = parser.parse_args()
print_arguments(args.__dict__)
root_directory = os.path.realpath(args.root_directory)
figures_directory = os.path.join(root_directory, args.figures_directory)
skip = args.skip
scale = args.scale
scale_qmin = args.scale_qmin
scale_qmax = args.scale_qmax
crop = args.crop
crop_qmin = args.crop_qmin
crop_qmax = args.crop_qmax
# run
plot_CorMapAnalysis(root_directory,
skip=skip,
scale=scale,
scale_qmin=scale_qmin,
scale_qmax=scale_qmax,
crop=crop,
crop_qmin=crop_qmin,
crop_qmax=crop_qmax,
save_figures=True,
figures_directory=figures_directory)
def main():
tstart = time.time()
parser = argparse.ArgumentParser(description='BLIP Image Classification')
# Data parameters
parser.add_argument('--seed',
default=0,
type=int,
help='(default=%(default)d)')
parser.add_argument('--device', default='cuda:0', type=str, help='gpu id')
parser.add_argument('--experiment',
default='mnist5',
type=str,
help='experiment dataset',
required=True)
parser.add_argument('--data_path',
default='../data/',
type=str,
help='gpu id')
# Training parameters
parser.add_argument('--approach',
default='blip',
type=str,
help='continual learning approach')
parser.add_argument('--output', default='', type=str, help='')
parser.add_argument('--checkpoint_dir',
default='../checkpoints/',
type=str,
help='')
parser.add_argument('--nepochs', default=200, type=int, help='')
parser.add_argument('--sbatch', default=64, type=int, help='')
parser.add_argument('--lr', default=0.05, type=float, help='')
parser.add_argument('--momentum', default=0, type=float, help='')
parser.add_argument('--weight-decay', default=0.0, type=float, help='')
parser.add_argument('--resume', default='no', type=str, help='resume?')
parser.add_argument('--sti', default=0, type=int, help='starting task?')
# Model parameters
parser.add_argument('--ndim',
default=1200,
type=int,
help='hidden dimension for 2 layer MLP')
parser.add_argument('--mul',
default=1.0,
type=float,
help='multiplier of model width')
# BLIP specific parameters
parser.add_argument('--max-bit',
default=20,
type=int,
help='maximum number of bits for each parameter')
parser.add_argument('--F-prior',
default=1e-15,
type=float,
help='scaling factor of F_prior')
args = parser.parse_args()
utils.print_arguments(args)
#####################################################################################
# Seed
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(args.seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
print('Using device:', args.device)
checkpoint = utils.make_directories(args)
args.checkpoint = checkpoint
print()
# Args -- Experiment
if args.experiment == 'mnist2':
from dataloaders import mnist2 as dataloader
elif args.experiment == 'mnist5':
from dataloaders import mnist5 as dataloader
elif args.experiment == 'pmnist':
from dataloaders import pmnist as dataloader
elif args.experiment == 'cifar':
from dataloaders import cifar as dataloader
elif args.experiment == 'mixture5':
from dataloaders import mixture5 as dataloader
else:
raise NotImplementedError('dataset currently not implemented')
# Args -- Approach
if args.approach == 'blip':
from approaches import blip as approach
else:
raise NotImplementedError('approach currently not implemented')
# Args -- Network
if args.experiment == 'mnist2' or args.experiment == 'pmnist' or args.experiment == 'mnist5':
from networks import q_mlp as network
else:
from networks import q_alexnet as network
########################################################################################
print()
print("Starting this run on :")
print(datetime.now().strftime("%Y-%m-%d %H:%M"))
# Load
print('Load data...')
data, taskcla, inputsize = dataloader.get(data_path=args.data_path,
seed=args.seed)
print('Input size =', inputsize, '\nTask info =', taskcla)
args.num_tasks = len(taskcla)
args.inputsize, args.taskcla = inputsize, taskcla
# Inits
print('Inits...')
model = network.Net(args).to(args.device)
print('-' * 100)
appr = approach.Appr(model, args=args)
print('-' * 100)
if args.resume == 'yes':
checkpoint = torch.load(
os.path.join(args.checkpoint, 'model_{}.pth.tar'.format(args.sti)))
model.load_state_dict(checkpoint['model_state_dict'])
model = model.to(device=args.device)
else:
args.sti = 0
# Loop tasks
acc = np.zeros((len(taskcla), len(taskcla)), dtype=np.float32)
lss = np.zeros((len(taskcla), len(taskcla)), dtype=np.float32)
num_task = len(taskcla)
for t, ncla in taskcla[args.sti:]:
print('*' * 100)
print('Task {:2d} ({:s})'.format(t, data[t]['name']))
print('*' * 100)
# Get data
xtrain = data[t]['train']['x'].to(args.device)
ytrain = data[t]['train']['y'].to(args.device)
xvalid = data[t]['valid']['x'].to(args.device)
yvalid = data[t]['valid']['y'].to(args.device)
task = t
# Train
appr.train(task, xtrain, ytrain, xvalid, yvalid)
print('-' * 100)
# BLIP specifics post processing
estimate_fisher(task, args.device, model, xtrain, ytrain)
for m in model.features.modules():
if isinstance(m, Linear_Q) or isinstance(m, Conv2d_Q):
# update bits according to information gain
m.update_bits(task=task, C=0.5 / math.log(2))
# do quantization
m.sync_weight()
# update Fisher in the buffer
m.update_fisher(task=task)
# save the model after the update
appr.save_model(task)
# Test
for u in range(t + 1):
xtest = data[u]['test']['x'].to(args.device)
ytest = data[u]['test']['y'].to(args.device)
test_loss, test_acc = appr.eval(u, xtest, ytest, debug=True)
print(
'>>> Test on task {:2d} - {:15s}: loss={:.3f}, acc={:5.3f}% <<<'
.format(u, data[u]['name'], test_loss, 100 * test_acc))
acc[t, u] = test_acc
lss[t, u] = test_loss
utils.used_capacity(model, args.max_bit)
# Save
print('Save at ' + args.checkpoint)
np.savetxt(
os.path.join(
args.checkpoint,
'{}_{}_{}.txt'.format(args.experiment, args.approach,
args.seed)), acc, '%.5f')
utils.print_log_acc_bwt(args, acc, lss)
print('[Elapsed time = {:.1f} h]'.format(
(time.time() - tstart) / (60 * 60)))
def main():
tstart = time.time()
parser = argparse.ArgumentParser(description='BLIP mini-ImageNet')
# Data parameters
parser.add_argument('--seed',
default=0,
type=int,
help='(default=%(default)d)')
parser.add_argument('--device', default='cuda:0', type=str, help='gpu id')
parser.add_argument('--experiment', default='MI', type=str)
parser.add_argument('--data_dir',
default='data',
type=str,
help='data directory')
parser.add_argument('--ntasks', default=10, type=int)
parser.add_argument('--pc-valid', default=0.02, type=float)
parser.add_argument('--workers', default=4, type=int)
# Training parameters
parser.add_argument('--approach', default='blip', type=str)
parser.add_argument('--output', default='', type=str, help='')
parser.add_argument('--checkpoint_dir',
default='checkpoints/',
type=str,
help='')
parser.add_argument('--nepochs', default=200, type=int, help='')
parser.add_argument('--sbatch', default=64, type=int, help='')
parser.add_argument('--lr', default=0.05, type=float, help='')
parser.add_argument('--momentum', default=0.9, type=float)
parser.add_argument('--weight-decay', default=0.0, type=float)
parser.add_argument('--resume', default='no', type=str, help='resume?')
parser.add_argument('--sti', default=0, type=int, help='starting task?')
# model parameters
parser.add_argument('--mul', default=1.0, type=float)
parser.add_argument('--arch', default='alexnet', type=str)
# BLIP parameters
parser.add_argument('--max-bit', default=20, type=int, help='')
parser.add_argument('--F-prior', default=1e-15, type=float, help='')
args = parser.parse_args()
utils.print_arguments(args)
#####################################################################################
# Seed
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(args.seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
print('Using device:', args.device)
checkpoint = utils.make_directories(args)
args.checkpoint = checkpoint
print()
# Args -- Experiment
from dataloaders.miniimagenet import DatasetGen
# Args -- Approach
from approaches import blip as approach
# Args -- Network
if args.arch == 'alexnet':
from networks import q_alexnet as network
elif args.arch == 'resnet':
from networks import q_resnet as network
else:
raise NotImplementedError("network currently not implemented")
########################################################################################
print()
print("Starting this run on :")
print(datetime.now().strftime("%Y-%m-%d %H:%M"))
# Load
print('Load data...')
# prepare data for each task
datagen = DatasetGen(args)
for task_id in range(args.ntasks):
datagen.get(task_id)
print('\nTask info =', datagen.taskcla)
args.num_tasks = len(datagen.taskcla)
args.inputsize, args.taskcla = datagen.inputsize, datagen.taskcla
# Inits
print('Inits...')
model = network.Net(args).to(args.device)
# print number of parameters
count = 0
for p in model.parameters():
count += np.prod(p.size())
print('model size in MB: ', count * 4 / (1024 * 1024))
print('-' * 100)
appr = approach.Appr(model, args=args)
print('-' * 100)
if args.resume == 'yes':
checkpoint = torch.load(
os.path.join(args.checkpoint, 'model_{}.pth.tar'.format(args.sti)))
model.load_state_dict(checkpoint['model_state_dict'])
model = model.to(device=args.device)
else:
args.sti = 0
# Loop tasks
acc = np.zeros((len(args.taskcla), len(args.taskcla)), dtype=np.float32)
lss = np.zeros((len(args.taskcla), len(args.taskcla)), dtype=np.float32)
for task, ncla in args.taskcla[args.sti:]:
data_t = datagen.dataloaders[task]
print('*' * 100)
print('Task {:2d} ({:s})'.format(task, data_t['name']))
print('*' * 100)
# Train
appr.train(task, data_t['train'], data_t['valid'])
print('-' * 100)
estimate_fisher(task, args.device, model, data_t['fisher'])
for m in model.modules():
if isinstance(m, Linear_Q) or isinstance(m, Conv2d_Q):
# update bits according to information gain
m.update_bits(task=task, C=0.5 / math.log(2))
# do quantization
m.sync_weight()
# update Fisher in the buffer
m.update_fisher(task=task)
# save the model after the update
appr.save_model(task)
# Test
for u in range(task + 1):
data_u = datagen.dataloaders[u]
test_loss, test_acc = appr.eval(u, data_u['test'])
print(
'>>> Test on task {:2d} - {:15s}: loss={:.3f}, acc={:5.3f}% <<<'
.format(u, data_u['name'], test_loss, 100 * test_acc))
acc[task, u] = test_acc
lss[task, u] = test_loss
utils.used_capacity(model, args.max_bit)
# Save
print('Save at ' + args.checkpoint)
np.savetxt(
os.path.join(
args.checkpoint,
'{}_{}_{}_{}.txt'.format(args.approach, args.arch, args.seed,
str(args.F_prior))), acc, '%.5f')
utils.print_log_acc_bwt(args, acc, lss)
print('[Elapsed time = {:.1f} h]'.format(
(time.time() - tstart) / (60 * 60)))
