def main(size, k, steps, output_path):
# utils.random_seed(2**7)
utils.random_seed(2**10)
size = size, size
camera = Camera(vector(0, 0, -1))
objects = ObjectList(randomize_objects())
with Pool(os.cpu_count()) as pool:
image = pool.imap(
partial(
render_row,
size=size,
camera=camera,
objects=objects,
k=k,
max_steps=steps,
),
range(size[0]),
)
image = list(tqdm(image, total=size[0]))
image = torch.stack(image, 1)
image = image.clamp(0, 1)
image = image.flip(1)
image = to_pil_image(image)
os.makedirs(output_path, exist_ok=True)
image.save(
os.path.join(output_path, "{}_{}_{}.png".format(size[0], k, steps)))
plt.imshow(image)
plt.show()
def train(pretext_model="Pretext_1593000476"):
# Reproducibility를 위한 모든 random seed 고정
random_seed()
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument("--epochs", type=int, default=110)
arg_parser.add_argument("--lr", type=float, default=0.001)
arg_parser.add_argument("--batch_size", type=int, default=8)
arg_parser.add_argument("--num_instances", type=int, default=16)
arg_parser.add_argument("--pretrained_weight", type=str, default=f"results/train/weights/{pretext_model}.pt")
args = arg_parser.parse_args()
train_meta = pd.read_csv("/datasets/objstrgzip/03_face_verification_angle/train/train_meta.csv")
num_classes = len(set(train_meta["face_id"].values))
# 모델 로드
model = Triarchy(args, num_classes, train=True)
# Train dataset의 표정 및 camera angle을 학습하도록 한 pretext model 가중치 로드
pretrained_weight = torch.load(args.pretrained_weight)
pretrained_weight.pop("fc.weight")
pretrained_weight.pop("fc.bias")
model.load_state_dict(pretrained_weight, strict=False)
# Trainer 인스턴스 생성 및 학습
trainer = Trainer(model, args)
trainer.train()
return trainer.model_name
def get_vae(vae_type: str, device, seed=defaults.seed, **kwargs):
assert vae_type.lower() in ['b', 'h'] #'h' for original vae
use_cuda = False if device == 'cpu' else True
random_seed(seed, use_cuda)
model = BetaVAE_H(**kwargs) if vae_type is 'h' else BetaVAE_B(**kwargs)
model.name = f'{get_cls_name(model)}_seed:{seed}'
model = model.to(device)
return model
def render_row(i, size, camera: Camera, objects: ObjectList, k, max_steps):
utils.random_seed(i)
row = torch.zeros(3, size[1], dtype=torch.float)
for j in range(size[1]):
for _ in range(k):
y = (i + random.random()) / size[0]
x = (j + random.random()) / size[1]
ray = camera.ray_to_position(x, y)
row[:, j] += ray_trace(ray, objects, max_steps=max_steps)
row[:, j] /= k
return row
def make_env(name):
env = gym.make(name)
env = gym.wrappers.Monitor(env,
'videos/',
force=True,
video_callable=lambda e: False)
env.seed(utils.random_seed())
return env
def main(config_path, **kwargs):
config = load_config(config_path, **kwargs)
del kwargs
random_seed(config.seed)
eval_transform = build_transforms(config)
eval_dataset = Dataset2020Test(os.path.join(config.dataset_path, "2020"),
transform=eval_transform)
eval_data_loader = torch.utils.data.DataLoader(
eval_dataset,
batch_size=config.eval.batch_size // 2,
shuffle=False,
drop_last=False,
num_workers=config.workers,
)
all_logits = Concat(1)
for fold in range(1, FOLDS + 1):
model = Model(config.model).to(DEVICE)
saver = Saver({
"model": model,
})
restore_path = os.path.join(config.experiment_path, "F{}".format(fold),
"checkpoint_best.pth")
saver.load(restore_path, keys=["model"])
logits, all_ids = predict_fold(model, eval_data_loader, fold=fold)
all_logits.update(logits.cpu())
all_logits = all_logits.compute()
print(all_logits.shape)
all_probs = all_logits.sigmoid().mean(1)
print(all_probs.shape, len(all_ids))
submission = pd.DataFrame({
"image_name": all_ids,
"target": all_probs.data.cpu().numpy(),
}).set_index("image_name")
submission.to_csv(os.path.join(config.experiment_path, "submission.csv"))
def make_atari_env(name, history_len):
from gym.envs.atari.atari_env import AtariEnv
from gym.wrappers.monitor import Monitor
env = AtariEnv(game=name, frameskip=4, obs_type='image')
env = Monitor(env, 'videos/', force=True, video_callable=lambda e: False)
env = wrappers.wrap_deepmind(env)
env = wrappers.HistoryWrapper(env, history_len)
env.seed(utils.random_seed())
return env
def main(args):
random_seed(args.seed)
if torch.cuda.is_available():
if not args.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda")
args.device = torch.device("cuda" if args.cuda else "cpu")
most_common_first_words = get_popular_first_words(args)
tokenizer = AutoTokenizer.from_pretrained(args.model_path)
model = AutoModelWithLMHead.from_pretrained(args.model_path,
pad_token_id=tokenizer.eos_token_id
).to(args.device)
model.eval()
print('loaded model')
soft = torch.nn.Softmax(0)
generated_strings = list()
for word_id, word in tqdm.tqdm(enumerate(most_common_first_words)):
input_ids = tokenizer.encode(word, return_tensors='pt')
input_ids = input_ids.repeat(
args.sentences_per_unique_start, 1).to(
args.device)
output = model.generate(
input_ids,
do_sample=args.do_sample,
max_length=args.max_length,
min_length=args.min_length,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
temperature=args.temperature,
)
utt = [tokenizer.decode(i, skip_special_tokens=True) for i in output]
generated_strings.extend(utt)
json.dump(generated_strings, Path(args.out_path).open('w'))
def main_worker(gpu, args, result_dir):
torch.backends.cudnn.benchmark = True
random_seed(args.seed)
torch.cuda.set_device(gpu)
train_dataset, test_dataset, train_loader, test_loader = parse_dataset(
args.dataset, args.batch_size)
model = parse_model(args.model, train_dataset)
model = model.cuda(gpu)
print('number of prarmeters:',
sum([p.numel() for p in model.parameters()]))
optimizer = parse_algo(args.algo,
model,
wd=args.wd,
lr=args.lr,
momentum=args.momentum,
gamma=args.gamma,
b0=args.b0)
loss = parse_loss(args.loss)
epochs = parse_epochs(args.epochs)
logger = Logger(os.path.join(result_dir, 'log.txt'))
for arg in vars(args):
logger.print(arg, '=', getattr(args, arg))
train_logger = TableLogger(os.path.join(result_dir, 'train.log'),
['epoch', 'loss', 'acc'])
test_logger = TableLogger(os.path.join(result_dir, 'test.log'),
['epoch', 'loss', 'acc'])
for epoch in range(0, epochs[-1]):
adjust_lr(args.lr, args.gamma, epochs, epoch, optimizer)
train(model, loss, epoch, train_loader, optimizer, logger,
train_logger, gpu, args.print_freq)
if test_dataset is not None:
test(model, loss, epoch, test_loader, logger, test_logger, gpu,
args.print_freq)
def main_worker(gpu, parallel, args, result_dir):
if parallel:
args.rank = args.rank + gpu
torch.distributed.init_process_group(backend='nccl',
init_method=args.dist_url,
world_size=args.world_size,
rank=args.rank)
torch.backends.cudnn.benchmark = True
random_seed(args.seed +
args.rank) # make data aug different for different processes
torch.cuda.set_device(gpu)
assert args.batch_size % args.world_size == 0
from dataset import load_data, get_statistics, default_eps, input_dim
train_loader, test_loader = load_data(args.dataset,
'data/',
args.batch_size // args.world_size,
parallel,
augmentation=True,
classes=None)
mean, std = get_statistics(args.dataset)
num_classes = len(train_loader.dataset.classes)
from model.bound_module import Predictor, BoundFinalIdentity
from model.mlp import MLPFeature, MLP
from model.conv import ConvFeature, Conv
model_name, params = parse_function_call(args.model)
if args.predictor_hidden_size > 0:
model = locals()[model_name](input_dim=input_dim[args.dataset],
**params)
predictor = Predictor(model.out_features, args.predictor_hidden_size,
num_classes)
else:
model = locals()[model_name](input_dim=input_dim[args.dataset],
num_classes=num_classes,
**params)
predictor = BoundFinalIdentity()
model = Model(model, predictor, eps=0)
model = model.cuda(gpu)
if parallel:
model = torch.nn.parallel.DistributedDataParallel(model,
device_ids=[gpu])
loss_name, params = parse_function_call(args.loss)
loss = Loss(globals()[loss_name](**params), args.kappa)
output_flag = not parallel or gpu == 0
if output_flag:
logger = Logger(os.path.join(result_dir, 'log.txt'))
for arg in vars(args):
logger.print(arg, '=', getattr(args, arg))
logger.print(train_loader.dataset.transform)
logger.print(model)
logger.print('number of params: ',
sum([p.numel() for p in model.parameters()]))
logger.print('Using loss', loss)
train_logger = TableLogger(os.path.join(result_dir, 'train.log'),
['epoch', 'loss', 'acc'])
test_logger = TableLogger(os.path.join(result_dir, 'test.log'),
['epoch', 'loss', 'acc'])
else:
logger = train_logger = test_logger = None
optimizer = AdamW(model,
lr=args.lr,
weight_decay=args.wd,
betas=(args.beta1, args.beta2),
eps=args.epsilon)
if args.checkpoint:
assert os.path.isfile(args.checkpoint)
if parallel:
torch.distributed.barrier()
checkpoint = torch.load(
args.checkpoint,
map_location=lambda storage, loc: storage.cuda(gpu))
state_dict = checkpoint['state_dict']
if next(iter(state_dict))[0:7] == 'module.' and not parallel:
new_state_dict = OrderedDict([(k[7:], v)
for k, v in state_dict.items()])
state_dict = new_state_dict
elif next(iter(state_dict))[0:7] != 'module.' and parallel:
new_state_dict = OrderedDict([('module.' + k, v)
for k, v in state_dict.items()])
state_dict = new_state_dict
model.load_state_dict(state_dict)
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded '{}'".format(args.checkpoint))
if parallel:
torch.distributed.barrier()
if args.eps_test is None:
args.eps_test = default_eps[args.dataset]
if args.eps_train is None:
args.eps_train = args.eps_test
args.eps_train /= std
args.eps_test /= std
up = torch.FloatTensor((1 - mean) / std).view(-1, 1, 1).cuda(gpu)
down = torch.FloatTensor((0 - mean) / std).view(-1, 1, 1).cuda(gpu)
attacker = AttackPGD(model,
args.eps_test,
step_size=args.eps_test / 4,
num_steps=20,
up=up,
down=down)
args.epochs = [int(epoch) for epoch in args.epochs.split(',')]
schedule = create_schedule(args, len(train_loader), model, loss, optimizer)
if args.visualize and output_flag:
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter(result_dir)
else:
writer = None
for epoch in range(args.start_epoch, args.epochs[-1]):
if parallel:
train_loader.sampler.set_epoch(epoch)
train_loss, train_acc = train(model, loss, epoch, train_loader,
optimizer, schedule, logger,
train_logger, gpu, parallel,
args.print_freq)
test_loss, test_acc = test(model, loss, epoch, test_loader, logger,
test_logger, gpu, parallel, args.print_freq)
if writer is not None:
writer.add_scalar('curve/p', get_p_norm(model), epoch)
writer.add_scalar('curve/train loss', train_loss, epoch)
writer.add_scalar('curve/test loss', test_loss, epoch)
writer.add_scalar('curve/train acc', train_acc, epoch)
writer.add_scalar('curve/test acc', test_acc, epoch)
if epoch % 50 == 49:
if logger is not None:
logger.print(
'Generate adversarial examples on training dataset and test dataset (fast, inaccurate)'
)
robust_train_acc = gen_adv_examples(model,
attacker,
train_loader,
gpu,
parallel,
logger,
fast=True)
robust_test_acc = gen_adv_examples(model,
attacker,
test_loader,
gpu,
parallel,
logger,
fast=True)
if writer is not None:
writer.add_scalar('curve/robust train acc', robust_train_acc,
epoch)
writer.add_scalar('curve/robust test acc', robust_test_acc,
epoch)
if epoch % 5 == 4:
certified_acc = certified_test(model, args.eps_test, up, down,
epoch, test_loader, logger, gpu,
parallel)
if writer is not None:
writer.add_scalar('curve/certified acc', certified_acc, epoch)
if epoch > args.epochs[-1] - 3:
if logger is not None:
logger.print("Generate adversarial examples on test dataset")
gen_adv_examples(model, attacker, test_loader, gpu, parallel,
logger)
certified_test(model, args.eps_test, up, down, epoch, test_loader,
logger, gpu, parallel)
schedule(args.epochs[-1], 0)
if output_flag:
logger.print(
"Calculate certified accuracy on training dataset and test dataset"
)
certified_test(model, args.eps_test, up, down, args.epochs[-1],
train_loader, logger, gpu, parallel)
certified_test(model, args.eps_test, up, down, args.epochs[-1],
test_loader, logger, gpu, parallel)
if output_flag:
torch.save(
{
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
}, os.path.join(result_dir, 'model.pth'))
if writer is not None:
writer.close()
tokenizer=tokenizer,
train_examples=train_examples,
dev_examples=dev_examples,
pattern=config.pattern,
train_enhancement=augment_examples if config.data_augment else None,
test_examples=None)
logging.info("dev_evaluate: {}".format(dev_evaluate))
if config.pattern == 'full_train':
model_save(config, model_example)
return dev_evaluate
if __name__ == '__main__':
config = RobertaPairConfig()
random_seed(config.seed)
logging_filename = None
if config.is_logging2file is True:
file = time.strftime('%Y-%m-%d_%H-%M-%S') + '.log'
logging_filename = os.path.join(config.logging_dir, file)
if not os.path.exists(config.logging_dir):
os.makedirs(config.logging_dir)
logging.basicConfig(filename=logging_filename, format='%(levelname)s: %(message)s', level=logging.INFO)
roberta_pair_task(config)
if __name__ == '__main__':
arguments = docopt(__doc__, version='0.1.1rc')
max_steps = humanfriendly.parse_size(arguments['--max_steps'])
modes = {0: arguments['--left'], 1: arguments['--right']}
trainall = arguments['--trainall']
agents = {0: arguments['<left>'], 1: arguments['<right>']}
names = {0: arguments['--left_name'], 1: arguments['--right_name']}
game = arguments['<game>']
animation = arguments['--animation']
numplots = int(arguments['--numplots'])
seed = int(arguments['--seed'])
verbose = arguments['--verbose']
utils.random_seed(seed)
if trainall:
modes[0] = modes[1] = True
G = create_game(game, max_steps)
def done(*args):
if args and len(args):
print('Caught signal {}'.format(args[0]))
G.done()
os.makedirs('data/', exist_ok=True)
for j in range(2):
if modes[j]:
save_agent(
G.players[j],
def main(**kwargs):
config = C(
random_seed=42,
learning_rate=1e-4,
horizon=32,
discount=0.99,
num_episodes=100000,
num_workers=32,
entropy_weight=1e-2,
log_interval=100,
)
for k in kwargs:
config[k] = kwargs[k]
utils.random_seed(config.random_seed)
writer = SummaryWriter(config.experiment_path)
# build env
env = VecEnv([build_env for _ in range(config.num_workers)])
env = wrappers.TensorboardBatchMonitor(env,
writer,
log_interval=config.log_interval,
fps_mul=0.5)
env = wrappers.Torch(env)
# build agent and optimizer
agent = Agent(env.observation_space, env.action_space)
optimizer = torch.optim.Adam(agent.parameters(),
config.learning_rate * config.num_workers,
betas=(0.0, 0.999))
# train
metrics = {
"episode/return": Stack(),
"episode/length": Stack(),
"rollout/reward": Stack(),
"rollout/value_target": Stack(),
"rollout/value": Stack(),
"rollout/td_error": Stack(),
"rollout/entropy": Stack(),
"rollout/actor_loss": Stack(),
"rollout/critic_loss": Stack(),
"rollout/loss": Stack(),
}
episode = 0
opt_step = 0
pbar = tqdm(total=config.num_episodes)
env.seed(config.random_seed)
obs = env.reset()
action = torch.zeros(config.num_workers, dtype=torch.int)
memory = agent.zero_memory(config.num_workers)
while episode < config.num_episodes:
memory = tuple(x.detach() for x in memory)
history = collect_rollout()
rollout = history.build()
_, value_prime, _ = agent(obs_prime, action, memory_prime)
# value_target = utils.n_step_bootstrapped_return(
# reward_t=rollout.reward,
# done_t=rollout.done,
# value_prime=value_prime.detach(),
# gamma=config.discount,
# )
value_target = utils.generalized_advantage_estimation(
reward_t=rollout.reward,
value_t=rollout.value.detach(),
value_prime=value_prime.detach(),
done_t=rollout.done,
gamma=config.discount,
lambda_=0.96,
)
value_target += rollout.value.detach()
td_error = value_target - rollout.value
critic_loss = td_error.pow(2)
actor_loss = (-rollout.log_prob * td_error.detach() -
config.entropy_weight * rollout.entropy)
loss = actor_loss + 0.5 * critic_loss
optimizer.zero_grad()
loss.sum(1).mean().backward()
# nn.utils.clip_grad_norm_(agent.parameters(), 0.01)
optimizer.step()
opt_step += 1
metrics["rollout/reward"].update(rollout.reward.detach())
metrics["rollout/value"].update(rollout.value.detach())
metrics["rollout/value_target"].update(value_target.detach())
metrics["rollout/td_error"].update(td_error.detach())
metrics["rollout/entropy"].update(rollout.entropy.detach())
metrics["rollout/actor_loss"].update(actor_loss.detach())
metrics["rollout/critic_loss"].update(critic_loss.detach())
metrics["rollout/loss"].update(loss.detach())
if opt_step % 10 == 0:
# td_error_std_normalized = td_error.std() / value_target.std()
print("log rollout")
total_norm = torch.norm(
torch.stack([
torch.norm(p.grad.detach(), 2.0)
for p in agent.parameters()
]), 2.0)
writer.add_scalar(f"rollout/grad_norm",
total_norm,
global_step=episode)
for k in [
"rollout/reward",
"rollout/value_target",
"rollout/value",
"rollout/td_error",
]:
v = metrics[k].compute_and_reset()
writer.add_scalar(f"{k}/mean", v.mean(), global_step=episode)
writer.add_histogram(f"{k}/hist", v, global_step=episode)
for k in [
"rollout/entropy",
"rollout/actor_loss",
"rollout/critic_loss",
"rollout/loss",
]:
v = metrics[k].compute_and_reset()
writer.add_scalar(f"{k}/mean", v.mean(), global_step=episode)
writer.flush()
# writer.add_scalar(
# "rollout/td_error_std_normalized", td_error_std_normalized, global_step=episode
# )
# writer.add_histogram("rollout/reward", rollout.reward, global_step=episode)
env.close()
writer.close()
requirements = {
'--bptt': Use(int),
'--batch-size': Use(int),
'--embed': Use(int),
'--hidden': Use(int),
'--lr': Use(float),
'--epoch': Use(int),
'--clip': Use(float),
'--device': Or(None, Use(int)),
'--seed': Use(int),
object: object,
}
args = Schema(requirements).validate(args)
seed = args['--seed']
random_seed(seed)
root = args['--root']
bptt = args['--bptt']
batch_size = args['--batch-size']
train_loader, valid_loader, test_loader, num_labels = prepare_data(
root, bptt, batch_size)
num_embeds = args['--embed']
num_hidden = args['--hidden']
lr = args['--lr']
model, criterion, optimizer = prepare_model(num_labels, num_embeds,
num_hidden, lr)
num_epochs = args['--epoch']
clip = args['--clip']
parser.add_argument('--seed', type=int, default=42)
args = parser.parse_args()
return args
def main(args):
if args.distribution_type == 'gauss':
mu = torch.ones(args.dim)
sigma = torch.randn(args.dim, args.dim)
sigma = torch.mm(sigma, sigma.t())
sigma.add_(torch.eye(args.dim))
potential = GaussPotential(mu, sigma)
trajs, potential_grads = [], []
for _ in trange(args.n_trajs):
traj, pot_grad = RWM(potential, args.gamma, args.n_burn, args.n_sample)
trajs.append(traj)
potential_grads.append(pot_grad)
trajs = torch.stack(trajs, dim=0)
potential_grads = torch.stack(potential_grads, dim=0)
Path(args.save_path).parent.mkdir(exist_ok=True, parents=True)
pickle.dump([trajs, potential_grads], Path(args.save_path).open('wb'))
if __name__ == '__main__':
args = parse_arguments()
random_seed(args.seed)
main(args)
if __name__ == '__main__':
arguments = docopt(__doc__, version='0.1.1rc')
max_steps = humanfriendly.parse_size(arguments['--max_steps'])
modes = {0: arguments['--left'], 1: arguments['--right']}
trainall = arguments['--trainall']
agents = {0: arguments['<left>'], 1: arguments['<right>']}
names = {0: arguments['--left_name'], 1: arguments['--right_name']}
game = arguments['<game>']
animation = arguments['--animation']
numplots = int(arguments['--numplots'])
seed = int(arguments['--seed'])
verbose = arguments['--verbose']
utils.random_seed(seed)
if trainall:
modes[0] = modes[1] = True
G = create_game(game, max_steps)
def done(*args):
if args and len(args):
print('Caught signal {}'.format(args[0]))
G.done()
os.makedirs('data/', exist_ok=True)
for j in range(2):
if modes[j]:
save_agent(G.players[j],
'data/{}.pickle'.format(G.players[j].full_name(G)))
# log_scale = np.logspace(1,0,num = 10)/10
log_scale = range(0,500,50)
for i in log_scale:
NovelThresh = i
print(i)
max_steps = i
# title = '' + str(Epsilon) + str(NovelThresh) + str(NovelCoeff)
title = 'RandomAcion2'
for run in range(num_runs):
# initialize all the values for each run
grid.env_init()
agent.agent_init(Epsilon,NovelCoeff,NovelThresh)
print('Run:', run)
# random.seed() # This line makes true random action selection.
utils.random_seed(run)
# TODO: Make a way for the figures to be stored over multiple runs.
for episode in range(num_episodes):
'''
Initialize for each episode
'''
im_diff = [0]
is_terminal = False
start_state = grid.env_start()
l_action = agent.agent_start(start_state)
step_count = 0
# print('Episode:', episode)
average_reward_per_episode = 0
prev_mean_val = 0
while not is_terminal:
import os
import torch
import random
import json
from torchtext import data
from config import configs
from utils import random_seed
import re
pattern = re.compile(
r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',
re.S)
_ = random_seed(configs['seed'])
tokenizer = configs['tokenizer']
pad_index = configs['pad_index']
root_path = configs['root_path']
pretrained_weights = configs['pretrained_weights']
data_size = configs['data_size']
def DataSelection(input_file, output_file):
w = open(output_file, "w")
w_c, r_c = 0, 0
for line in open(input_file, "r"):
r_c += 1
line_dict = json.loads(line)
if (line_dict["is_answerable"] == 1) and (line_dict["questionType"] == "descriptive") and \
(len(line_dict["review_snippets"]) == 10):
new_q = pattern.sub("", line_dict["questionText"])
if len(new_q.split(" ")) <= 2:
continue
line_dict["questionText"] = new_q
Copyright (c) 2020 Palo Alto Networks
"""
import os
import utils
import mnist
import numpy as np
from progress.bar import Bar
from PIL import Image, ImageDraw
from random import randint, uniform, seed
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from scipy.ndimage import median_filter, gaussian_filter, binary_dilation
seed(utils.random_seed())
np.random.seed(utils.random_seed())
if not os.path.isdir("data"):
os.mkdir("data")
# Size of validation and test sets
VAL_SIZE = 10000
TEST_SIZE = 10000
# Number of training, validation, test noise images to add
N_TRAIN_NOISE_IMAGES = 50000
N_VAL_NOISE_IMAGES = 10000
N_TEST_NOISE_IMAGES = 10000
# Minimum confidence of the RF used during stroke noise generation
RF_CONF = 0.3
def main(config_path, **kwargs):
config = load_config(config_path, **kwargs)
del kwargs
random_seed(config.seed)
box_coder = BoxCoder(config.model.levels)
train_transform = T.Compose([
Resize(config.resize_size),
RandomCrop(config.crop_size),
RandomFlipLeftRight(),
ApplyTo(
"image",
T.Compose([
T.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3),
T.ToTensor(),
T.Normalize(mean=MEAN, std=STD),
]),
),
FilterBoxes(),
BuildTargets(box_coder),
])
eval_transform = T.Compose([
Resize(config.resize_size),
RandomCrop(config.crop_size),
ApplyTo(
"image",
T.Compose([
T.ToTensor(),
T.Normalize(mean=MEAN, std=STD),
]),
),
FilterBoxes(),
BuildTargets(box_coder),
])
if config.dataset == "coco":
Dataset = CocoDataset
else:
raise AssertionError("invalid config.dataset {}".format(
config.dataset))
train_dataset = Dataset(config.dataset_path,
subset="train",
transform=train_transform)
eval_dataset = Dataset(config.dataset_path,
subset="eval",
transform=eval_transform)
class_names = train_dataset.class_names
train_data_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.train.batch_size,
drop_last=True,
shuffle=True,
num_workers=config.workers,
collate_fn=collate_fn,
worker_init_fn=worker_init_fn,
)
if config.train_steps is not None:
train_data_loader = DataLoaderSlice(train_data_loader,
config.train_steps)
eval_data_loader = torch.utils.data.DataLoader(
eval_dataset,
batch_size=config.eval.batch_size,
drop_last=False,
shuffle=True,
num_workers=config.workers,
collate_fn=collate_fn,
worker_init_fn=worker_init_fn,
)
model = FCOS(config.model, num_classes=Dataset.num_classes)
if config.model.freeze_bn:
model = BatchNormFreeze(model)
model = model.to(DEVICE)
optimizer = build_optimizer(model.parameters(), config)
saver = Saver({"model": model, "optimizer": optimizer})
start_epoch = 0
if config.restore_path is not None:
saver.load(config.restore_path, keys=["model"])
if os.path.exists(os.path.join(config.experiment_path, "checkpoint.pth")):
start_epoch = saver.load(
os.path.join(config.experiment_path, "checkpoint.pth"))
scheduler = build_scheduler(optimizer, config, len(train_data_loader),
start_epoch)
for epoch in range(start_epoch, config.train.epochs):
train_epoch(
model=model,
optimizer=optimizer,
scheduler=scheduler,
data_loader=train_data_loader,
box_coder=box_coder,
class_names=class_names,
epoch=epoch,
config=config,
)
gc.collect()
# eval_epoch(
# model=model,
# data_loader=eval_data_loader,
# box_coder=box_coder,
# class_names=class_names,
# epoch=epoch,
# config=config)
gc.collect()
saver.save(os.path.join(config.experiment_path, "checkpoint.pth"),
epoch=epoch + 1)
def main(config_path, **kwargs):
config = load_config(config_path, **kwargs)
config.experiment_path = os.path.join(config.experiment_path, "F{}".format(config.fold))
del kwargs
random_seed(config.seed)
train_transform, eval_transform = build_transforms(config)
train_dataset = ConcatDataset(
[
Dataset2020KFold(
os.path.join(config.dataset_path, "2020"),
train=True,
fold=config.fold,
transform=train_transform,
),
Dataset2019(os.path.join(config.dataset_path, "2019"), transform=train_transform),
]
)
eval_dataset = Dataset2020KFold(
os.path.join(config.dataset_path, "2020"),
train=False,
fold=config.fold,
transform=eval_transform,
)
train_data_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.train.batch_size,
shuffle=True,
drop_last=True,
num_workers=config.workers,
)
eval_data_loader = torch.utils.data.DataLoader(
eval_dataset,
batch_size=config.eval.batch_size,
shuffle=False,
drop_last=False,
num_workers=config.workers,
)
model = Model(config.model).to(DEVICE)
optimizer = build_optimizer(model.parameters(), config)
scheduler = build_scheduler(optimizer, config, len(train_data_loader))
saver = Saver(
{
"model": model,
"optimizer": optimizer,
"scheduler": scheduler,
}
)
if config.restore_path is not None:
saver.load(config.restore_path, keys=["model"])
best_score = 0.0
for epoch in range(1, config.train.epochs + 1):
optimizer.train()
train_epoch(model, train_data_loader, optimizer, scheduler, epoch=epoch, config=config)
score = eval_epoch(model, eval_data_loader, epoch=epoch, config=config)
# saver.save(os.path.join(config.experiment_path, 'eval', 'checkpoint_{}.pth'.format(epoch)), epoch=epoch)
if score > best_score:
best_score = score
saver.save(
os.path.join(config.experiment_path, "checkpoint_best.pth".format(epoch)),
epoch=epoch,
)
optimizer.eval()
score = eval_epoch(model, eval_data_loader, epoch=epoch, config=config, suffix="ema")
# saver.save(os.path.join(config.experiment_path, 'eval', 'ema', 'checkpoint_{}.pth'.format(epoch)), epoch=epoch)
if score > best_score:
best_score = score
saver.save(
os.path.join(config.experiment_path, "checkpoint_best.pth".format(epoch)),
epoch=epoch,
)
pass
if len(candidates) == 0:
break
top_beams = sorted(candidates.items(), key=lambda x: -x[1][1])[:beam_size] # beam_score sorting
for top_beam_i, top_beam in enumerate(top_beams):
top_candidates[top_beam_i] = top_beam[1]
outputs.append(top_candidates[0][0])
return outputs
if __name__ == "__main__":
# ----Hyperparameters & PTEncoder----
pretrained_config = AutoConfig.from_pretrained(configs['pretrained_weights'], output_hidden_states=True)
pretrained_encoder = AutoModel.from_pretrained(configs['pretrained_weights'], config=pretrained_config).cuda()
tokenizer = configs['tokenizer']
multi_gpu = random_seed(configs['seed'])
epochs = configs['epochs']
task = configs['task']
if 'fp16' in configs:
fp16 = configs['fp16']
else:
fp16 = None
# ----Loading data and initializing model----
logger.info('Loading data...')
running_data = AmazonQA()
logger.info(
"Size of train, valid and test data: %s, %s, %s" % (len(running_data.train.examples),
len(running_data.dev.examples),
len(running_data.test.examples)))
batch_size = configs['batch_size']
def main(**kwargs):
config = C(
random_seed=42,
learning_rate=1e-3,
horizon=16,
discount=0.995,
num_observations=1000000,
num_workers=32,
entropy_weight=1e-2,
episode_log_interval=100,
opt_log_interval=10,
average_reward_lr=0.001,
clip_grad_norm=None,
model=C(
num_features=64,
encoder=C(type="minigrid", ),
memory=C(type="lstm", ),
),
)
for k in kwargs:
config[k] = kwargs[k]
utils.random_seed(config.random_seed)
writer = SummaryWriter(config.experiment_path)
# build env
env = VecEnv([build_env for _ in range(config.num_workers)])
env = wrappers.TensorboardBatchMonitor(
env, writer, log_interval=config.episode_log_interval, fps_mul=0.5)
env = wrappers.Torch(env)
# build agent and optimizer
agent = Agent(
env.observation_space,
env.action_space,
**config.model,
)
optimizer = torch.optim.Adam(
agent.parameters(),
config.learning_rate,
betas=(0.0, 0.999),
)
average_reward = 0
# load state
# state = torch.load("./state.pth")
# agent.load_state_dict(state["agent"])
# optimizer.load_state_dict(state["optimizer"])
# train
metrics = {
"episode/return": Stack(),
"episode/length": Stack(),
"rollout/reward": Stack(),
"rollout/value_target": Stack(),
"rollout/value": Stack(),
"rollout/td_error": Stack(),
"rollout/entropy": Stack(),
"rollout/actor_loss": Stack(),
"rollout/critic_loss": Stack(),
"rollout/loss": Stack(),
}
opt_step = 0
observation_step = 0
pbar = tqdm(total=config.num_observations)
env.seed(config.random_seed)
obs = env.reset()
action = torch.zeros(config.num_workers, dtype=torch.int)
memory = agent.zero_memory(config.num_workers)
# r_stats = utils.RunningStats()
while observation_step < config.num_observations:
history = History()
memory = agent.detach_memory(memory)
for i in range(config.horizon):
transition = history.append_transition()
dist, value, memory_prime = agent(obs, action, memory)
transition.record(value=value, entropy=dist.entropy())
action = select_action(dist)
transition.record(log_prob=dist.log_prob(action))
obs_prime, reward, done, info = env.step(action)
observation_step += config.num_workers
pbar.update(config.num_workers)
# for r in reward:
# r_stats.push(r)
# reward = reward / r_stats.standard_deviation()
transition.record(reward=reward, done=done)
memory_prime = agent.reset_memory(memory_prime, done)
obs, memory = obs_prime, memory_prime
for i in info:
if "episode" not in i:
continue
metrics["episode/return"].update(i["episode"]["r"])
metrics["episode/length"].update(i["episode"]["l"])
rollout = history.build()
_, value_prime, _ = agent(obs_prime, action, memory_prime)
# value_target = utils.n_step_bootstrapped_return(
# reward_t=rollout.reward,
# done_t=rollout.done,
# value_prime=value_prime.detach(),
# discount=config.discount,
# )
advantage = utils.generalized_advantage_estimation(
reward_t=rollout.reward,
value_t=rollout.value.detach(),
value_prime=value_prime.detach(),
done_t=rollout.done,
gamma=config.discount,
lambda_=0.96,
)
value_target = advantage + rollout.value.detach()
# value_target = utils.differential_n_step_bootstrapped_return(
# reward_t=rollout.reward,
# done_t=rollout.done,
# value_prime=value_prime.detach(),
# average_reward=average_reward,
# )
td_error = value_target - rollout.value
critic_loss = 0.5 * td_error.pow(2)
actor_loss = (-rollout.log_prob * td_error.detach() -
config.entropy_weight * rollout.entropy)
loss = actor_loss + critic_loss
optimizer.zero_grad()
agg(loss).backward()
if config.clip_grad_norm is not None:
nn.utils.clip_grad_norm_(agent.parameters(), config.clip_grad_norm)
optimizer.step()
average_reward += config.average_reward_lr * agg(
td_error.detach()) # TODO: do not use td-error
opt_step += 1
metrics["rollout/reward"].update(rollout.reward.detach())
metrics["rollout/value"].update(rollout.value.detach())
metrics["rollout/value_target"].update(value_target.detach())
metrics["rollout/td_error"].update(td_error.detach())
metrics["rollout/entropy"].update(rollout.entropy.detach())
metrics["rollout/actor_loss"].update(actor_loss.detach())
metrics["rollout/critic_loss"].update(critic_loss.detach())
metrics["rollout/loss"].update(loss.detach())
if opt_step % config.opt_log_interval == 0:
print("log metrics")
writer.add_scalar("rollout/average_reward",
average_reward,
global_step=observation_step)
grad_norm = torch.norm(
torch.stack([
torch.norm(p.grad.detach(), 2.0)
for p in agent.parameters()
]), 2.0)
writer.add_scalar("rollout/grad_norm",
grad_norm,
global_step=observation_step)
for k in [
"rollout/reward",
"rollout/value_target",
"rollout/value",
"rollout/td_error",
]:
v = metrics[k].compute_and_reset()
writer.add_scalar(f"{k}/mean",
v.mean(),
global_step=observation_step)
writer.add_histogram(f"{k}/hist",
v,
global_step=observation_step)
for k in [
"rollout/entropy",
"rollout/actor_loss",
"rollout/critic_loss",
"rollout/loss",
]:
v = metrics[k].compute_and_reset()
writer.add_scalar(f"{k}/mean",
v.mean(),
global_step=observation_step)
for k in [
"episode/return",
"episode/length",
]:
v = metrics[k].compute_and_reset()
writer.add_scalar(f"{k}/mean",
v.mean(),
global_step=observation_step)
writer.add_histogram(f"{k}/hist",
v,
global_step=observation_step)
writer.flush()
# torch.save(
# {
# "agent": agent.state_dict(),
# "optimizer": optimizer.state_dict(),
# "average_reward": average_reward,
# },
# "./state.pth",
# )
env.close()
writer.close()
