code stringlengths 17 6.64M |
|---|
def checkpoint_name(checkpoint_dir, epoch='latest'):
return os.path.join(checkpoint_dir, 'ckpt-{}.dat'.format(epoch))
|
class FileStorageObserverWithExUuid(FileStorageObserver):
' Wraps the FileStorageObserver so that we can pass in the Id.\n This allows us to save experiments into subdirectories with \n meaningful names. The standard FileStorageObserver jsut increments \n a counter.'
UNUSED_VALUE = (- 1)
... |
class VideoLogger(object):
' Logs a video to a file, frame-by-frame \n \n All frames must be the same height.\n \n Example:\n >>> logger = VideoLogger("output.mp4")\n >>> for i in range(30):\n >>> logger.log(color_transitions_(i, n_frames, width, height) )\n ... |
def color_transitions_(i, k, width, height):
x = np.linspace(0, 1.0, width)
y = np.linspace(0, 1.0, height)
bg = np.array(np.meshgrid(x, y))
bg = (((1.0 - (i / k)) * bg) + ((i / k) * (1 - bg)))
r = ((np.ones_like(bg[0][(np.newaxis, ...)]) * i) / k)
return np.uint8((np.rollaxis(np.concatenate([... |
class SensorPack(dict):
' Fun fact, you can slice using np.s_. E.g.\n sensors.at(np.s_[:2])\n '
def at(self, val):
return SensorPack({k: v[val] for (k, v) in self.items()})
def apply(self, lambda_fn):
return SensorPack({k: lambda_fn(k, v) for (k, v) in self.items()})
def s... |
def replay_logs(existing_log_paths, mlog):
existing_results_path = combined_paths(existing_log_paths, 'result_log.pkl')
save_training_logs(existing_results_path, mlog)
|
def move_metadata_file(old_log_dir, new_log_dir, uuid):
fp_metadata_old = get_subdir(old_log_dir, 'metadata')
fp_metadata_old = [fp for fp in fp_metadata_old if (uuid in fp)]
if (len(fp_metadata_old) == 0):
logger.info(f'No metadata for new experiment found at {old_log_dir} for {uuid}')
else:
... |
def checkpoint_name(checkpoint_dir, epoch='latest'):
return os.path.join(checkpoint_dir, 'ckpt-{}.dat'.format(epoch))
|
def get_parent_dirname(path):
return os.path.basename(os.path.dirname(path))
|
def get_subdir(training_directory, subdir_name):
"\n look through all files/directories in training_directory\n return all files/subdirectories whose basename have subdir_name\n if 0, return none\n if 1, return it\n if more, return list of them\n\n e.g. training_directory: '/path/to/exp'\n ... |
def read_pkl(pkl_name):
with open(pkl_name, 'rb') as f:
data = pickle.load(f)
return data
|
def unused_dir_name(output_dir):
"\n Returns a unique (not taken) output_directory name with similar structure to existing one\n Specifically,\n if dir is not taken, return itself\n if dir is taken, return a new name where\n if dir = base + number, then newdir = base + {number+1}\n ow: n... |
def combined_paths(paths, name):
'\n Runs get_subdir on every path in paths then flattens\n Finds all files/directories in all paths whose basename includes name\n Returns all these in a one-dimensional list\n '
ret_paths = []
for exp_path in paths:
evals = get_subdir(exp_path, name)
... |
def read_logs(pkl_name):
return read_pkl(pkl_name)['results'][0]
|
def save_training_logs(results_paths, mlog):
"\n results_path is a list of experiment's result pkl file paths\n e.g. results_path = ['exp1/results_log.pkl', 'exp2/results_log.pkl']\n "
step_num_set = set()
for results_path in results_paths:
print(f'logging {results_path}')
try:
... |
def save_testing_logs(eval_paths, mlog):
"\n eval_paths is a list of eval runs path\n e.g. eval_paths = ['exp1/eval', 'exp1/eval1', 'exp2/eval']\n "
data_all_epochs = []
seen_epochs = set()
for eval_path in eval_paths:
subdirectories = os.listdir(eval_path)
for subdir in subdi... |
def save_train_testing(exp_paths, mlog):
train_result_paths = combined_paths(exp_paths, 'result_log.pkl')
save_training_logs(train_result_paths, mlog)
eval_paths = combined_paths(exp_paths, 'eval')
save_testing_logs(eval_paths, mlog)
|
class EpisodeTracker(object):
'\n Provides a method for tracking important metrics with a simultaneous batch of episodes\n '
def __init__(self, n_to_track):
self.episodes = [[] for _ in range(n_to_track)]
def append(self, obs, actions):
for (i, (o, a)) in enumerate(zip(obs['glo... |
def softmax_cross_entropy(inputs, target, weight=None, cache={}, size_average=None, ignore_index=(- 100), reduce=None, reduction='mean'):
cache['predictions'] = inputs
cache['labels'] = target
if (len(target.shape) == 2):
target = torch.argmax(target, dim=1)
loss = F.cross_entropy(inputs, targ... |
def heteroscedastic_normal(mean_and_scales, target, weight=None, cache={}, eps=0.01):
(mu, scales) = mean_and_scales
loss = ((((mu - target) ** 2) / ((scales ** 2) + eps)) + torch.log(((scales ** 2) + eps)))
loss = ((torch.mean((weight * loss)) / weight.mean()) if (weight is not None) else loss.mean())
... |
def heteroscedastic_double_exponential(mean_and_scales, target, weight=None, cache={}, eps=0.05):
(mu, scales) = mean_and_scales
loss = ((torch.abs((mu - target)) / (scales + eps)) + torch.log((2.0 * (scales + eps))))
loss = ((torch.mean((weight * loss)) / weight.mean()) if (weight is not None) else loss.... |
def weighted_mse_loss(inputs, target, weight=None, cache={}):
losses = {}
cache['predictions'] = inputs
cache['labels'] = target
if (weight is not None):
loss = (torch.mean((weight * ((inputs - target) ** 2))) / torch.mean(weight))
else:
loss = F.mse_loss(inputs, target)
return... |
def weighted_l1_loss(inputs, target, weight=None, cache={}):
target = target.float()
if (weight is not None):
loss = (torch.mean((weight * torch.abs((inputs - target)))) / torch.mean(weight))
else:
loss = F.l1_loss(inputs, target)
return {'total': loss, 'l1': loss}
|
def perceptual_l1_loss(decoder_path, bake_decodings):
task = [t for t in SINGLE_IMAGE_TASKS if (t in decoder_path)][0]
decoder = TaskonomyDecoder(TASKS_TO_CHANNELS[task], feed_forward=(task in FEED_FORWARD_TASKS))
checkpoint = torch.load(decoder_path)
decoder.load_state_dict(checkpoint['state_dict'])
... |
def perceptual_l2_loss(decoder_path, bake_decodings):
task = [t for t in SINGLE_IMAGE_TASKS if (t in decoder_path)][0]
decoder = TaskonomyDecoder(TASKS_TO_CHANNELS[task], feed_forward=(task in FEED_FORWARD_TASKS))
checkpoint = torch.load(decoder_path)
decoder.load_state_dict(checkpoint['state_dict'])
... |
def dense_softmax_cross_entropy_loss(inputs, targets, cache={}):
(batch_size, _) = targets.shape
losses = {}
losses['final'] = (((- 1.0) * torch.sum((torch.softmax(targets.float(), dim=1) * F.log_softmax(inputs.float(), dim=1)))) / batch_size)
losses['standard'] = losses['final']
return losses
|
def dense_cross_entropy_loss_(inputs, targets):
(batch_size, _) = targets.shape
return (((- 1.0) * torch.sum((targets * F.log_softmax(inputs, dim=1)))) / batch_size)
|
def dense_softmax_cross_entropy(inputs, targets, weight=None, cache={}):
assert (weight is None)
cache['predictions'] = inputs
cache['labels'] = targets
(batch_size, _) = targets.shape
loss = (((- 1.0) * torch.sum((torch.softmax(targets.detach(), dim=1) * F.log_softmax(inputs, dim=1)))) / batch_si... |
def dense_cross_entropy(inputs, targets, weight=None, cache={}):
assert (weight == None)
cache['predictions'] = inputs
cache['labels'] = targets
(batch_size, _) = targets.shape
loss = (((- 1.0) * torch.sum((targets.detach() * F.log_softmax(inputs, dim=1)))) / batch_size)
return {'total': loss,... |
def perceptual_cross_entropy_loss(decoder_path, bake_decodings):
task = [t for t in SINGLE_IMAGE_TASKS if (t in decoder_path)][0]
decoder = TaskonomyDecoder(TASKS_TO_CHANNELS[task], feed_forward=(task in FEED_FORWARD_TASKS))
checkpoint = torch.load(decoder_path)
decoder.load_state_dict(checkpoint['sta... |
def identity_regularizer(loss_fn, model):
def runner(inputs, target, weight=None, cache={}):
losses = loss_fn(inputs, target, weight, cache)
return losses
return runner
|
def transfer_regularizer(loss_fn, model, reg_loss_fn='F.l1_loss', coef=0.001):
def runner(inputs, target, weight=None, cache={}):
orig_losses = loss_fn(inputs, target, weight, cache)
if (type(model).__name__ == 'PolicyWithBase'):
assert (('base_encoding' in cache) and ('transfered_enc... |
def perceptual_regularizer(loss_fn, model, coef=0.001, decoder_path=None, use_transfer=True, reg_loss_fn='F.mse_loss'):
assert (decoder_path is not None), 'Pass in a decoder to which to transform our parameters and regularize on'
task = [t for t in SINGLE_IMAGE_TASKS if (t in decoder_path)][0]
decoder = T... |
def cfg_to_md(cfg, uuid):
' Because tensorboard uses markdown'
return (((uuid + '\n\n ') + pprint.pformat(cfg).replace('\n', ' \n').replace("\n '", "\n '")) + '')
|
def count_trainable_parameters(model):
return sum((p.numel() for p in model.parameters() if p.requires_grad))
|
def count_total_parameters(model):
return sum((p.numel() for p in model.parameters()))
|
def is_interactive():
try:
ip = get_ipython()
return ip.has_trait('kernel')
except:
return False
|
def is_cuda(model):
return next(model.parameters()).is_cuda
|
class Bunch(object):
def __init__(self, adict):
self.__dict__.update(adict)
(self._keys, self._vals) = zip(*adict.items())
(self._keys, self._vals) = (list(self._keys), list(self._vals))
def keys(self):
return self._keys
def vals(self):
return self._vals
|
def compute_weight_norm(parameters):
' no grads! '
total = 0.0
count = 0
for p in parameters:
total += torch.sum((p.data ** 2))
count += p.numel()
return (total / count)
|
def get_number(name):
'\n use regex to get the first integer in the name\n if none exists, return -1\n '
try:
num = int(re.findall('[0-9]+', name)[0])
except:
num = (- 1)
return num
|
def append_dict(d, u, stop_recurse_keys=[]):
for (k, v) in u.items():
if (isinstance(v, collections.Mapping) and (k not in stop_recurse_keys)):
d[k] = append_dict(d.get(k, {}), v, stop_recurse_keys=stop_recurse_keys)
else:
if (k not in d):
d[k] = []
... |
def update_dict_deepcopy(d, u):
for (k, v) in u.items():
if isinstance(v, collections.Mapping):
d[k] = update_dict_deepcopy(d.get(k, {}), v)
else:
d[k] = v
return d
|
def eval_dict_values(d):
for k in d.keys():
if isinstance(d[k], collections.Mapping):
d[k] = eval_dict_values(d[k])
elif isinstance(d[k], str):
d[k] = eval(d[k].replace('---', "'"))
return d
|
def search_and_replace_dict(model_kwargs, task_initial):
for (k, v) in model_kwargs.items():
if isinstance(v, collections.Mapping):
search_and_replace_dict(v, task_initial)
elif (isinstance(v, str) and ('encoder' in v) and (task_initial not in v)):
new_pth = v.replace('curv... |
class _CustomDataParallel(nn.Module):
def __init__(self, model, device_ids):
super(_CustomDataParallel, self).__init__()
self.model = nn.DataParallel(model, device_ids=device_ids)
self.model.to(device)
num_devices = (torch.cuda.device_count() if (device_ids is None) else len(devic... |
class Profiler(object):
def __init__(self, name, logger=None, level=logging.INFO):
self.name = name
self.logger = logger
self.level = level
def step(self, name):
' Returns the duration and stepname since last step/start '
duration = self.summarize_step(start=self.step... |
class RAdam(Optimizer):
def __init__(self, params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False):
if amsgrad:
warnings.warn('amsgrad is not used')
defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
self.buffer = [[None, None, None... |
class PlainRAdam(Optimizer):
def __init__(self, params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0):
defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
super(PlainRAdam, self).__init__(params, defaults)
def __setstate__(self, state):
super(PlainRAdam... |
class AdamW(Optimizer):
def __init__(self, params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, warmup=0):
defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay, warmup=warmup)
super(AdamW, self).__init__(params, defaults)
def __setstate__(self, state):
s... |
def set_seed(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
np.random.seed(seed)
random.seed(seed)
|
def compute_optimal_imgs(img_paths, use_pool=False):
(median_time, mean_time, pil_time) = (0, 0, 0)
img_paths = [path for path in img_paths if ('.png' in path)]
mean_meter = ValueSummaryMeter()
median_meter = MedianImageMeter(bit_depth=8, im_shape=(256, 256, 3), device='cuda')
p = Pool(6)
for ... |
class SimpleRLEnv(habitat.RLEnv):
def get_reward_range(self):
return [(- 1), 1]
def get_reward(self, observations):
return 0
def get_done(self, observations):
return self.habitat_env.episode_over
def get_info(self, observations):
return self.habitat_env.get_metrics(... |
def draw_top_down_map(info, heading, output_size):
top_down_map = maps.colorize_topdown_map(info['top_down_map']['map'])
original_map_size = top_down_map.shape[:2]
map_scale = np.array((1, ((original_map_size[1] * 1.0) / original_map_size[0])))
new_map_size = np.round((output_size * map_scale)).astype... |
def get_logger(cfg, uuid):
if (cfg['saving']['logging_type'] == 'visdom'):
mlog = tnt.logger.VisdomMeterLogger(title=uuid, env=uuid, server=cfg['saving']['visdom_server'], port=cfg['saving']['visdom_port'], log_to_filename=cfg['saving']['visdom_log_file'])
elif (cfg['saving']['logging_type'] == 'tenso... |
def maybe_bake_decodings(cfg, logger):
task = cfg['training']['taskonomy_encoder']
need_encodings = (cfg['training']['baked_encoding'] and (not os.path.isdir(os.path.join(cfg['training']['data_dir'], f'{task}_encoding'))))
need_decodings = (cfg['training']['baked_decoding'] and (not os.path.isdir(os.path.... |
@ex.main
def train(cfg, uuid):
logger.setLevel(logging.INFO)
logger.info(cfg)
logger.debug(f'Loaded Torch version: {torch.__version__}')
logger.debug(f'Using device: {device}')
task = cfg['training']['taskonomy_encoder']
start_epoch = 0
logger.debug(f'Starting data loaders')
maybe_bake... |
def train_model(cfg, student, teacher, dataloaders, loss_fn, optimizer, start_epoch=0, num_epochs=250, save_epochs=25, scheduler=None, mlog=None, flog=None):
checkpoint_dir = os.path.join(cfg['saving']['log_dir'], cfg['saving']['save_dir'])
run_kwargs = {'baked_encoding': cfg['training']['baked_encoding'], 'b... |
def run_one_epoch(student, teacher, decoder, dataloader, loss_fn, loss_type, optimizer, epoch, baked_encoding, baked_decoding, mlog, flog, train, cfg):
student.train(train)
phase = ('train' if train else 'val')
with torch.set_grad_enabled(train), Profiler(f"Epoch {epoch} ({('train' if train else 'val')})"... |
@ex.config
def cfg_base():
uuid = 'basic'
cfg = {}
cfg['learner'] = {'model': 'atari_residual', 'model_kwargs': {}, 'eps': 1e-05, 'lr': 0.001, 'lr_scheduler_method': None, 'lr_scheduler_method_kwargs': {}, 'max_grad_norm': 1, 'test': False, 'scheduler': 'plateau'}
cfg['training'] = {'baked_encoding': ... |
@ex.named_config
def model_fcn5():
cfg = {'learner': {'model': 'FCN5Residual', 'model_kwargs': {'num_groups': 2, 'use_residual': False, 'normalize_output': False}}}
|
@ex.named_config
def model_fcn5_residual():
cfg = {'learner': {'model': 'FCN5Residual', 'model_kwargs': {'num_groups': 2, 'use_residual': True, 'normalize_output': False}}}
|
@ex.named_config
def model_fcn3():
cfg = {'learner': {'model': 'FCN3', 'model_kwargs': {'num_groups': 2, 'normalize_output': False}}}
|
@ex.named_config
def student_taskonomy_encoder_penultimate():
cfg = {'learner': {'model': 'TaskonomyEncoder', 'model_kwargs': {'train': True, 'eval_only': False}}}
|
@ex.named_config
def student_taskonomy_encoder():
cfg = {'learner': {'model': 'TaskonomyEncoder', 'model_kwargs': {'train_penultimate': True, 'eval_only': False}}}
|
@ex.named_config
def scheduler_reduce_on_plateau():
cfg = {'learner': {'lr_scheduler_method': 'lr_scheduler.ReduceLROnPlateau', 'lr_scheduler_method_kwargs': {'factor': 0.1, 'patience': 5}}}
|
@ex.named_config
def scheduler_step_lr():
cfg = {'learner': {'lr_scheduler_method': 'lr_scheduler.StepLR', 'lr_scheduler_method_kwargs': {'lr_decay_epochs': 30, 'gamma': 0.1}}}
|
@ex.named_config
def cfg_eval():
uuid = 'eval'
cfg = {}
cfg['learner'] = {'model': 'FCN5', 'test': True}
cfg['training'] = {'train': False}
|
def save_as_png(file_path, decoding):
decoding = ((0.5 * decoding) + 0.5)
decoding *= ((2 ** 16) - 1)
decoding = decoding.astype(np.uint16)
if (decoding.shape[0] == 2):
zeros = np.zeros((1, decoding.shape[1], decoding.shape[2]), dtype=np.uint16)
decoding = np.vstack((decoding, zeros))
... |
def save_to_file(arr, original_image_fname, new_root, subfolder, filetype='.npy'):
abspath = os.path.abspath(original_image_fname)
base_name = os.path.basename(abspath).replace('.png', filetype)
parent_name = get_parent_dirname(abspath)
file_path = os.path.join(new_root, subfolder, parent_name, base_n... |
def save_mappable(x):
return save_to_file(*x)
|
def remove_done_folders(task, folders_to_convert, data_dir, save_dir, store_prediction, store_representation):
rgb_dir = os.path.join(data_dir, 'rgb')
encoding_dir = os.path.join(save_dir, f'{task}_encoding')
decoding_dir = os.path.join(save_dir, f'{task}_decoding')
folders_to_use = set()
for fold... |
def need_to_save(task, folders_to_convert, data_dir, save_dir, store_prediction, store_representation):
folders_to_convert = remove_done_folders(task, folders_to_convert, data_dir, save_dir, store_prediction, store_representation)
return (len(folders_to_convert) != 0)
|
def save_reprs(task, model_base_path, folders_to_convert, split_to_convert, data_dir, save_dir, store_representation=True, store_prediction=True, n_dataloader_workers=4, batch_size=64, skip_done_folders=True):
logger.info(f'Setting up model of {task} with {model_base_path}')
out_channels = (TASKS_TO_CHANNELS[... |
@ex.main
def run_cfg(cfg):
save_reprs(task=cfg['task'], model_base_path=cfg['model_base_path'], folders_to_convert=cfg['folders_to_convert'], split_to_convert=cfg['split_to_convert'], data_dir=cfg['data_dir'], save_dir=cfg['save_dir'], store_representation=cfg['store_representation'], store_prediction=cfg['store_... |
@ex.config
def cfg_base():
task = 'autoencoding'
model_base_path = '/mnt/models/'
store_representation = True
store_prediction = True
folders_to_convert = None
split_to_convert = None
batch_size = 64
n_dataloader_workers = 8
data_dir = '/mnt/data'
save_dir = '/mnt/data'
|
@ex.named_config
def cfg_docker():
cfg = {'task': 'keypoints3d', 'model_base_path': '/mnt/models/', 'store_representation': False, 'store_prediction': True, 'split_to_convert': 'splits.taskonomy_no_midlevel["fullplus"]', 'data_dir': '/mnt/data', 'save_dir': '/mnt/data', 'folders_to_convert': None, 'batch_size': 6... |
def save_as_png(file_path, decoding):
decoding = ((0.5 * decoding) + 0.5)
decoding *= ((2 ** 16) - 1)
decoding = decoding.astype(np.uint16)
decoding = np.transpose(decoding, (1, 2, 0))
if (decoding.shape[2] > 1):
cv2.imwrite(file_path, cv2.cvtColor(decoding, cv2.COLOR_RGB2BGR))
else:
... |
def save_to_file(arr, original_image_fname, new_root, subfolder, filetype='.npy'):
abspath = os.path.abspath(original_image_fname)
base_name = os.path.basename(abspath).replace('.png', filetype)
parent_name = get_parent_dirname(abspath).replace(SOURCE_TASK, 'mask_valid')
file_path = os.path.join(new_r... |
def save_mappable(x):
return save_to_file(*x)
|
def build_mask(target, val=65000):
mask = (target >= val)
mask = (F.max_pool2d(mask.float(), 5, padding=2, stride=2) == 0)
return (mask * 255)
|
@ex.main
def make_mask(folders_to_convert, split_to_convert, data_dir, save_dir, n_dataloader_workers=4, batch_size=64):
if ((folders_to_convert is None) and (split_to_convert is not None)):
split_to_convert = eval(split_to_convert)
logger.info(f'Converting from split {split_to_convert}')
... |
@ex.config
def cfg_base():
folders_to_convert = None
split_to_convert = None
batch_size = 64
n_dataloader_workers = 8
data_dir = '/mnt/data'
save_dir = '/mnt/data'
|
def save_as_png(file_path, decoding):
decoding = ((0.5 * decoding) + 0.5)
decoding *= ((2 ** 16) - 1)
decoding = decoding.astype(np.uint16)
decoding = np.transpose(decoding, (1, 2, 0))
if (decoding.shape[2] > 1):
cv2.imwrite(file_path, cv2.cvtColor(decoding, cv2.COLOR_RGB2BGR))
else:
... |
def save_to_file(arr, original_image_fname, new_root, subfolder, filetype='.npy'):
abspath = os.path.abspath(original_image_fname)
base_name = os.path.basename(abspath).replace('.png', filetype)
parent_name = get_parent_dirname(abspath)
file_path = os.path.join(new_root, subfolder, parent_name, base_n... |
def shrink_file(original_fpath, new_fpath):
with open(original_fpath, 'rb') as f:
img = Image.open(f)
img = img.convert('RGB')
img = transforms.Resize((256, 256), Image.BICUBIC)(img)
with open(new_fpath, 'wb') as f:
img.save(f)
|
def save_mappable(x):
return shrink_file(*x)
|
@ex.main
def make_mask(folders_to_convert, split_to_convert, data_dir, save_dir, n_dataloader_workers=4, batch_size=64):
if ((folders_to_convert is None) and (split_to_convert is not None)):
split_to_convert = eval(split_to_convert)
logger.info(f'Converting from split {split_to_convert}')
... |
@ex.config
def cfg_base():
folders_to_convert = None
split_to_convert = None
batch_size = 64
n_dataloader_workers = 8
data_dir = '/mnt/data'
save_dir = '/mnt/data'
|
@ex.command
def run_hps(cfg, uuid):
print(cfg)
argv_plus_hps = sys.argv
script_name = argv_plus_hps[0]
script_name = script_name.replace('.py', '').replace('/', '.')
script_name = (script_name[1:] if script_name.startswith('.') else script_name)
for (hp, hp_range) in flatten(cfg['hps_kwargs'][... |
@ex.named_config
def cfg_hps():
uuid = 'hps'
cfg = {}
cfg['hps_kwargs'] = {'hp': {'learner': {'lr': ((- 5), (- 3)), 'optimizer_kwargs': {'weight_decay': ((- 6), (- 4))}}}, 'script_name': 'train', 'add_time_to_logdir': True}
|
@ex.command
def prologue(cfg, uuid):
os.makedirs(LOG_DIR, exist_ok=True)
assert (not (cfg['saving']['obliterate_logs'] and cfg['training']['resume_training'])), 'Cannot obliterate logs and resume training'
if cfg['saving']['obliterate_logs']:
assert LOG_DIR, 'LOG_DIR cannot be empty'
subpr... |
@ex.main
def train(cfg, uuid):
set_seed(cfg['training']['seed'])
logger.setLevel(logging.INFO)
logger.info(pprint.pformat(cfg))
logger.debug(f'Loaded Torch version: {torch.__version__}')
logger.debug(f'Using device: {device}')
logger.info(f'Training following tasks: ')
for (i, (s, t)) in e... |
def train_model(cfg, model, dataloaders, loss_fns, optimizer, start_epoch=0, num_epochs=250, save_epochs=25, scheduler=None, mlog=None, flog=None):
'\n Main training loop. Multiple tasks might happen in the same epoch. \n 0 to 1 random validation only\n 1 to 2 train task 0 labeled as ... |
def post_training_epoch(dataloader=None, epoch=(- 1), model=None, loss_fns=None, **kwargs):
post_training_cache = {}
if hasattr(loss_fns[dataloader.curr_iter_idx], 'post_training_epoch'):
loss_fns[dataloader.curr_iter_idx].post_training_epoch(model, dataloader, post_training_cache, **kwargs)
for (... |
def run_one_epoch(model: LifelongSidetuneNetwork, dataloader, loss_fns, optimizer, epoch, cfg, mlog, flog, train=True, use_thread=False) -> (list, dict):
start_time = time.time()
model.train(train)
params_with_grad = model.parameters()
phase = ('train' if train else 'val')
sources = cfg['training'... |
def save_checkpoint(model, optimizer, epoch, dataloaders, checkpoint_dir, use_thread=False):
dict_to_save = {'state_dict': model.state_dict(), 'epoch': epoch, 'model': model, 'optimizer': optimizer, 'curr_iter_idx': dataloaders['train'].curr_iter_idx}
checkpoints.save_checkpoint(dict_to_save, checkpoint_dir, ... |
@ex.command
def prologue(cfg, uuid):
os.makedirs(LOG_DIR, exist_ok=True)
assert (not (cfg['saving']['obliterate_logs'] and cfg['training']['resumable'])), 'cannot obliterate logs and resume training'
if cfg['saving']['obliterate_logs']:
assert LOG_DIR, 'LOG_DIR cannot be empty'
subprocess.... |
@ex.main
def run_training(cfg, uuid, override={}):
try:
logger.info(('-------------\nStarting with configuration:\n' + pprint.pformat(cfg)))
logger.info(('UUID: ' + uuid))
torch.set_num_threads(1)
set_seed(cfg['training']['seed'])
old_log_dir = cfg['saving']['log_dir']
... |
class ExpertData(data.Dataset):
def __init__(self, data_path, keys, num_frames, split='train', transform: dict={}, load_to_mem=False, remove_last_step_in_traj=True, removed_actions=[]):
'\n data expected format\n /path/to/data/\n scenek/\n trajj/\n ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.