code stringlengths 17 6.64M |
|---|
@ex.named_config
def gsn_transfer_residual_prenorm():
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'transfer_class': 'TransferConv3', 'transfer_weights_path': None, 'transfer_kwargs': {'n_channels': 8, 'residual': True}, 'normalize_pre_transfer': True}}}
|
@ex.config
def cfg_base():
uuid = 'no_uuid'
cfg = {}
cfg['learner'] = {'model': 'atari_residual', 'model_kwargs': {}, 'eps': 1e-05, 'lr': 0.001, 'optimizer_class': 'optim.Adam', 'optimizer_kwargs': {'weight_decay': 0.0001}, 'lr_scheduler_method': None, 'lr_scheduler_method_kwargs': {}, 'max_grad_norm': 1.... |
@ex.named_config
def taskonomy_data():
cfg = {'training': {'dataloader_fn': 'taskonomy_dataset.get_dataloaders', 'dataloader_fn_kwargs': {'data_path': '/mnt/data/', 'train_folders': 'debug', 'val_folders': 'debug', 'test_folders': 'debug', 'load_to_mem': False, 'num_workers': 8, 'pin_memory': True}}}
|
@ex.named_config
def imagenet_data():
cfg = {'training': {'split_to_use': 'splits.taskonomy_no_midlevel["debug"]', 'dataloader_fn': 'imagenet_dataset.get_dataloaders', 'dataloader_fn_kwargs': {'data_path': '/mnt/data/ILSVRC2012', 'load_to_mem': False, 'num_workers': 8, 'pin_memory': False}, 'loss_fn': 'softmax_cr... |
@ex.named_config
def rotating_data():
cfg = {'training': {'suppress_target_and_use_annotator': False, 'sources': ['rgb', 'rotation'], 'post_aggregation_transform_fn': 'imagenet_dataset.RotateBatch()', 'post_aggregation_transform_fn_kwargs': {}}, 'learner': {'model': 'DummyLifelongTaskonomyNetwork', 'model_kwargs'... |
@ex.named_config
def icifar0_data():
cfg = {'training': {'dataloader_fn': 'icifar_dataset.get_cifar_dataloaders', 'dataloader_fn_kwargs': {'data_path': '/mnt/data/', 'load_to_mem': False, 'num_workers': 8, 'pin_memory': True, 'epochlength': 2000, 'sources': ['rgb'], 'targets': [['cifar0-9']], 'masks': None}, 'use... |
@ex.named_config
def data_size_few100():
cfg = {'training': {'split_to_use': "splits.taskonomy_no_midlevel['few100']", 'num_epochs': 10000}, 'saving': {'ticks_per_epoch': 1, 'log_interval': 250, 'save_interval': 1000}}
|
@ex.named_config
def data_size_fullplus():
cfg = {'training': {'split_to_use': splits.taskonomy_no_midlevel['fullplus'], 'num_epochs': 10}, 'saving': {'ticks_per_epoch': 0.25, 'log_interval': 1, 'save_interval': 1}}
|
@ex.named_config
def model_resnet_cifar():
cfg = {'learner': {'model': 'FCN5SkipCifar', 'model_kwargs': {'num_groups': 2, 'use_residual': False, 'normalize_outputs': False}}}
|
@ex.named_config
def model_taskonomy():
cfg = {'learner': {'model': 'TaskonomyNetwork', 'model_kwargs': {'out_channels': 3, 'eval_only': False}}}
|
@ex.named_config
def model_taskonomy_class():
cfg = {'learner': {'model': 'TaskonomyNetwork', 'model_kwargs': {'out_channels': 1000, 'trainable': True, 'is_decoder_mlp': True}}, 'training': {'sources': ['rgb'], 'targets': ['class_object']}}
|
@ex.named_config
def model_fcn8():
cfg = {'learner': {'model': 'FCN8', 'model_kwargs': {'normalize_outputs': False}}}
|
@ex.named_config
def model_fcn5():
cfg = {'learner': {'model': 'FCN5Residual', 'model_kwargs': {'num_groups': 2, 'use_residual': False, 'normalize_outputs': False}}}
|
@ex.named_config
def model_fcn5_residual():
cfg = {'learner': {'model': 'FCN5Residual', 'model_kwargs': {'num_groups': 2, 'use_residual': True, 'normalize_outputs': False}}}
|
@ex.named_config
def model_fcn5_skip():
cfg = {'learner': {'model': 'FCN5', 'model_kwargs': {'num_groups': 2, 'use_residual': False, 'normalize_outputs': False}}}
|
@ex.named_config
def model_fcn5_skip_residual():
cfg = {'learner': {'model': 'FCN5', 'model_kwargs': {'num_groups': 2, 'use_residual': True, 'normalize_outputs': False}}}
|
@ex.named_config
def model_fcn3():
cfg = {'learner': {'model': 'FCN3', 'model_kwargs': {'num_groups': 2, 'normalize_outputs': False}}}
|
@ex.named_config
def model_taskonomy_net():
cfg = {'learner': {'model': 'TaskonomyNetwork', 'model_kwargs': {'out_channels': 3, 'eval_only': False}}}
|
@ex.named_config
def model_sidetune_encoding():
n_channels_out = 3
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'n_channels_in': 3, 'n_channels_out': n_channels_out, 'base_class': 'TaskonomyEncoder', 'base_weights_path': None, 'base_kwargs': {'eval_only': True, 'normalize_outputs': T... |
@ex.named_config
def model_nosidetune_encoding():
n_channels_out = 3
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'n_channels_in': 3, 'n_channels_out': n_channels_out, 'base_class': 'TaskonomyEncoder', 'base_weights_path': None, 'base_kwargs': {'eval_only': True, 'normalize_outputs':... |
@ex.named_config
def model_pix_only_side():
n_channels_out = 3
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'n_channels_in': 3, 'n_channels_out': n_channels_out, 'base_class': None, 'base_weights_path': None, 'base_kwargs': {}, 'use_baked_encoding': False, 'side_class': 'FCN5', 'side... |
@ex.named_config
def model_pix_only_encoder():
n_channels_out = 3
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'n_channels_in': 3, 'n_channels_out': n_channels_out, 'base_class': 'TaskonomyEncoder', 'base_weights_path': None, 'base_kwargs': {'eval_only': False, 'normalize_outputs': T... |
@ex.named_config
def model_transfer_sidetune_encoding():
n_channels_out = 3
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'n_channels_in': 3, 'n_channels_out': n_channels_out, 'base_class': 'TaskonomyEncoder', 'base_weights_path': None, 'base_kwargs': {'eval_only': True, 'normalize_ou... |
@ex.named_config
def model_transfer_nosidetune_encoding():
n_channels_out = 3
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'n_channels_in': 3, 'n_channels_out': n_channels_out, 'base_class': 'TaskonomyEncoder', 'base_weights_path': None, 'base_kwargs': {'eval_only': True, 'normalize_... |
@ex.named_config
def model_transfer_pix_only_encoder():
n_channels_out = 3
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'n_channels_in': 3, 'n_channels_out': n_channels_out, 'base_class': 'TaskonomyEncoder', 'base_weights_path': None, 'base_kwargs': {'eval_only': False, 'normalize_ou... |
@ex.named_config
def model_transfer_pix_only_side():
n_channels_out = 3
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'n_channels_in': 3, 'n_channels_out': n_channels_out, 'base_class': None, 'base_weights_path': None, 'base_kwargs': None, 'use_baked_encoding': False, 'side_class': 'F... |
@ex.named_config
def model_taskonomy_decoder():
cfg = {'learner': {'model': 'TaskonomyDecoder', 'model_kwargs': {'out_channels': 3, 'eval_only': False}}}
|
@ex.named_config
def model_blind():
cfg = {'learner': {'model': 'ConstantModel', 'model_kwargs': {'data': '/mnt/data/normal/median_tiny.png'}}, 'training': {'sources': ['rgb']}}
|
@ex.named_config
def model_unet():
cfg = {'learner': {'model': 'UNet', 'model_kwargs': {'dcwnsample': 6}}}
|
@ex.named_config
def model_unet_heteroscedastic():
cfg = {'learner': {'model': 'UNetHeteroscedastic', 'model_kwargs': {'downsample': 6}}}
|
@ex.named_config
def model_unet_hetero_pooled():
cfg = {'learner': {'model': 'UNetHeteroscedasticPooled', 'model_kwargs': {'downsample': 6}}}
|
@ex.named_config
def gsn_base_resnet50():
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'base_class': 'TaskonomyEncoder', 'base_weights_path': None, 'base_kwargs': {'eval_only': True, 'normalize_outputs': False}, 'use_baked_encoding': True}}}
|
@ex.named_config
def gsn_base_fcn5s():
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'base_class': 'FCN5', 'base_weights_path': None, 'base_kwargs': {'img_channels': 3, 'eval_only': True, 'normalize_outputs': False}, 'use_baked_encoding': True}}}
|
@ex.named_config
def gsn_base_learned():
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'base_kwargs': {'eval_only': False}, 'use_baked_encoding': False}}}
|
@ex.named_config
def gsn_side_resnet50():
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'side_class': 'TaskonomyEncoder', 'side_weights_path': None, 'side_kwargs': {'eval_only': False, 'normalize_outputs': False}}}}
|
@ex.named_config
def gsn_side_fcn5s():
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'side_class': 'FCN5', 'side_weights_path': None, 'side_kwargs': {'img_channels': 3, 'eval_only': False, 'normalize_outputs': False}}}}
|
@ex.named_config
def gsn_side_frozen():
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'side_kwargs': {'eval_only': True}}}}
|
@ex.named_config
def gsn_transfer_residual_prenorm():
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'transfer_class': 'TransferConv3', 'transfer_weights_path': None, 'transfer_kwargs': {'n_channels': 8, 'residual': True}, 'normalize_pre_transfer': True}}}
|
@ex.named_config
def gsn_merge_concat():
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'transfer_class': 'TransferConv3', 'transfer_weights_path': None, 'transfer_kwargs': {'n_channels': 8, 'n_channels_in': (2 * 8), 'residual': True}, 'normalize_pre_transfer': True, 'alpha_blend': False, ... |
@ex.named_config
def loss_distill_cross_entropy():
cfg = {}
cfg['learner'] = {'lr': 0.001, 'optimizer_kwargs': {'weight_decay': 1e-06}}
cfg['training'] = {'loss_fn': 'dense_softmax_cross_entropy', 'targets': ['class_object'], 'loss_kwargs': {}, 'suppress_target_and_use_annotator': True, 'annotator_class':... |
@ex.named_config
def loss_perceptual():
cfg = {}
cfg['training'] = {'loss_fn': 'perceptual_l1', 'targets': ['normal_encoding'], 'loss_kwargs': {'decoder_path': '/mnt/models/normal_decoder.dat', 'bake_decodings': True}, 'suppress_target_and_use_annotator': False, 'annotator_class': 'TaskonomyEncoder', 'annotat... |
@ex.named_config
def loss_perceptual_l2():
cfg = {}
cfg['training'] = {'loss_fn': 'perceptual_l2', 'targets': ['normal_encoding'], 'loss_kwargs': {'decoder_path': '/mnt/models/normal_decoder.dat', 'bake_decodings': True}, 'suppress_target_and_use_annotator': False, 'annotator_class': 'TaskonomyEncoder', 'anno... |
@ex.named_config
def loss_perceptual_cross_entropy():
cfg = {}
cfg['training'] = {'loss_fn': 'perceptual_cross_entropy', 'targets': ['class_object_encoding'], 'loss_kwargs': {'decoder_path': '/mnt/models/class_scene_decoder.dat', 'bake_decodings': True}, 'suppress_target_and_use_annotator': False, 'annotator_... |
@ex.named_config
def loss_softmax_cross_entropy():
cfg = {}
cfg['learner'] = {'lr': 1e-06, 'optimizer_kwargs': {'weight_decay': 1e-05}}
cfg['training'] = {'suppress_target_and_use_annotator': False, 'loss_fn': 'softmax_cross_entropy', 'targets': ['class_object'], 'loss_kwargs': {}}
|
@ex.named_config
def taskonomy_hp():
uuid = 'no_uuid'
cfg = {}
cfg['learner'] = {'lr': 0.0001, 'optimizer_kwargs': {'weight_decay': 2e-06}}
|
@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 test():
cfg = {'training': {'train': False, 'test': True}}
|
@ex.named_config
def treg():
cfg = {}
cfg['training'] = {'regularizer_fn': 'transfer_regularizer', 'regularizer_kwargs': {'coef': 0.001, 'reg_loss_fn': 'F.l1_loss'}, 'loss_list': ['standard', 'final', 'weight_tying']}
|
@ex.named_config
def dreg_t():
cfg = {}
cfg['training'] = {'regularizer_fn': 'perceptual_regularizer', 'regularizer_kwargs': {'coef': 0.001, 'decoder_path': '/mnt/models/curvature_decoder.dat', 'reg_loss_fn': 'F.mse_loss'}, 'loss_list': ['standard', 'final', 'weight_tying']}
|
@ex.named_config
def dreg():
cfg = {}
cfg['training'] = {'regularizer_fn': 'perceptual_regularizer', 'regularizer_kwargs': {'coef': 0.001, 'decoder_path': '/mnt/models/curvature_decoder.dat', 'use_transfer': False, 'reg_loss_fn': 'F.mse_loss'}, 'loss_list': ['standard', 'final', 'weight_tying']}
|
class BaseEmbodiedEnv(gym.Env):
' Abstract class for all embodied environments. '
is_embodied = True
|
class DistributedEnv(object):
distribution_schemes = _distribution_schemes
@classmethod
def new(cls, envs, gae_gamma=None, distribution_method=_distribution_schemes):
if (distribution_method == cls.distribution_schemes.vectorize):
return cls.vectorized(envs, gae_gamma)
elif (d... |
class EnvFactory(object):
@staticmethod
def vectorized(env_id, seed, num_processes, log_dir, add_timestep, sensors={DEFAULT_SENSOR_NAME: None}, addl_repeat_count=0, preprocessing_fn=None, env_specific_kwargs={}, vis_interval=20, visdom_name='main', visdom_log_file=None, visdom_server='localhost', visdom_port... |
class AddTimestep(gym.ObservationWrapper):
def __init__(self, env=None):
super(AddTimestep, self).__init__(env)
self.observation_space = Box(self.observation_space.low[0], self.observation_space.high[0], [(self.observation_space.shape[0] + 1)], dtype=self.observation_space.dtype)
def observa... |
class WrapPyTorch(gym.ObservationWrapper):
def __init__(self, env=None):
super(WrapPyTorch, self).__init__(env)
obs_shape = self.observation_space.shape
self.observation_space = Box(self.observation_space.low[(0, 0, 0)], self.observation_space.high[(0, 0, 0)], [obs_shape[2], obs_shape[0],... |
def cfg(config_file: Optional[str]=None, config_dir: str=DEFAULT_CONFIG_DIR) -> CN:
config = _C.clone()
if config_file:
config.merge_from_file(os.path.join(config_dir, config_file))
return config
|
def make_habitat_vector_env(scenario='PointNav', num_processes=2, target_dim=7, preprocessing_fn=None, log_dir=None, visdom_name='main', visdom_log_file=None, visdom_server='localhost', visdom_port='8097', vis_interval=200, train_scenes=None, val_scenes=None, num_val_processes=0, swap_building_k_episodes=10, gpu_devi... |
def make_env_fn(scenario, config_env, config_baseline, rank, num_val_processes, num_processes, target_dim, log_dir, visdom_name, visdom_log_file, vis_interval, visdom_server, visdom_port, swap_building_k_episodes, map_kwargs, reward_kwargs, should_record, seed, test_mode, dataset, scenario_kwargs):
if (config_env... |
def get_splits(dataset, num_splits: int, episodes_per_split: int=None, remove_unused_episodes: bool=False, collate_scene_ids: bool=True, sort_by_episode_id: bool=False, allow_uneven_splits: bool=True):
'Returns a list of new datasets, each with a subset of the original\n episodes. All splits will have the ... |
def transform_target(target):
r = target[0]
theta = target[1]
return np.array([np.cos(theta), np.sin(theta), r])
|
def transform_observations(observations, target_dim=16, omap=None):
new_obs = observations
new_obs['rgb_filled'] = observations['rgb']
new_obs['taskonomy'] = observations['rgb']
new_obs['target'] = np.moveaxis(np.tile(transform_target(observations['pointgoal']), (target_dim, target_dim, 1)), (- 1), 0)... |
def get_obs_space(image_dim=256, target_dim=16, map_dim=None, use_depth=False):
prep_dict = {'taskonomy': spaces.Box(low=0, high=255, shape=(image_dim, image_dim, 3), dtype=np.uint8), 'rgb_filled': spaces.Box(low=0.0, high=255.0, shape=(image_dim, image_dim, 3), dtype=np.uint8), 'target': spaces.Box(low=(- np.inf... |
class NavRLEnv(habitat.RLEnv):
def __init__(self, config_env, config_baseline, dataset):
config_env.TASK.MEASUREMENTS.append('TOP_DOWN_MAP')
config_env.TASK.SENSORS.append('HEADING_SENSOR')
self._config_env = config_env.TASK
self._config_baseline = config_baseline
self._pr... |
class MidlevelNavRLEnv(NavRLEnv):
metadata = {'render.modes': ['rgb_array']}
def __init__(self, config_env, config_baseline, dataset, target_dim=7, map_kwargs={}, reward_kwargs={}, loop_episodes=True, scenario_kwargs={}):
if scenario_kwargs['use_depth']:
config_env.SIMULATOR.AGENT_0.SENSO... |
def chunks(l, n):
'Yield successive n-sized chunks from l.'
for i in range(0, len(l), n):
(yield l[i:(i + n)])
|
def shuffle_episodes(env, swap_every_k=10):
episodes = env.episodes
episodes = env.episodes = random.sample([c for c in chunks(episodes, swap_every_k)], (len(episodes) // swap_every_k))
env.episodes = flatten(episodes)
return env.episodes
|
def draw_top_down_map(info, heading, output_size):
if (info is None):
return
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.r... |
def gray_to_rgb(img_arr):
if ((len(img_arr.shape) == 3) and (img_arr.shape[2] == 3)):
return img_arr
if (len(img_arr.shape) == 3):
img_arr = img_arr.squeeze(2)
return np.dstack((img_arr, img_arr, img_arr))
|
class HabitatPreprocessVectorEnv(habitat.VectorEnv):
def __init__(self, make_env_fn, env_fn_args, preprocessing_fn=None, auto_reset_done: bool=True, multiprocessing_start_method: str='forkserver'):
super().__init__(make_env_fn, env_fn_args, auto_reset_done, multiprocessing_start_method)
obs_space... |
class PreprocessEnv(habitat.RLEnv):
def __init__(self, env, preprocessing_fn=None):
self.env = env
self.transform = None
self.observation_space = self.env.observation_space
if (preprocessing_fn is not None):
(self.transform, self.observation_space) = preprocessing_fn(s... |
def tile_images(img_nhwc):
'\n Tile N images into one big PxQ image\n (P,Q) are chosen to be as close as possible, and if N\n is square, then P=Q.\n\n input: img_nhwc, list or array of images, ndim=4 once turned into array\n n = batch index, h = height, w = width, c = channel\n returns:\n ... |
class DummyVecEnv(VecEnv):
def __init__(self, env_fns):
self.envs = [fn() for fn in env_fns]
env = self.envs[0]
VecEnv.__init__(self, len(env_fns), env.observation_space, env.action_space)
(shapes, dtypes) = ({}, {})
self.keys = []
obs_space = env.observation_space... |
class ProcessObservationWrapper(gym.ObservationWrapper):
' Wraps an environment so that instead of\n obs = env.step(),\n obs = transform(env.step())\n \n Args:\n transform: a function that transforms obs\n obs_shape: the final obs_shape is needed to set th... |
class SensorEnvWrapper(gym.ObservationWrapper):
' Wraps a typical gym environment so to work with our package\n obs = env.step(),\n obs = {sensor_name: env.step()}\n \n Parameters:\n name: what to name the sensor\n '
def __init__(self, env, name='obs'):
super... |
def SkipWrapper(repeat_count):
class SkipWrapper(gym.Wrapper):
'\n Generic common frame skipping wrapper\n Will perform action for `x` additional steps\n '
def __init__(self, env):
super(SkipWrapper, self).__init__(env)
self.repeat_count = rep... |
class VisdomMonitor(Monitor):
def __init__(self, env, directory, video_callable=None, force=False, resume=False, write_upon_reset=False, uid=None, mode=None, server='localhost', visdom_env='main', port=8097, visdom_log_file=None):
self.visdom_env = visdom_env
self.server = server
self.por... |
class VideoRecorder(video_recorder.VideoRecorder):
def _encode_image_frame(self, frame):
if (not self.encoder):
self.encoder = video_recorder.ImageEncoder(self.path, frame.shape, self.frames_per_sec)
self.metadata['encoder_version'] = self.encoder.version_info
try:
... |
class SingleSensorModule(nn.Module):
def __init__(self, module, sensor_name):
super().__init__()
self.module = module
self.sensor_name = sensor_name
def __call__(self, obs):
return self.module(obs[self.sensor_name])
|
class ActorCriticModule(nn.Module):
def __init__(self):
super().__init__()
@property
def internal_state_size(self):
raise NotImplementedError('internal_state_size not implemented in abstract class LearnerModel')
@property
def output_size(self):
raise NotImplementedError(... |
class NaivelyRecurrentACModule(ActorCriticModule):
' consists of a perception unit, a recurrent unit. \n The perception unit produces a state representation P of shape internal_state_shape \n The recurrent unit learns a function f(P) to generate a new internal_state\n The action and value sho... |
class ForwardInverseACModule(NaivelyRecurrentACModule):
' \n This Module adds a forward-inverse model on top of the perception unit. \n '
def __init__(self, perception_unit, forward_model, inverse_model, use_recurrency=False, internal_state_size=512):
super().__init__(perception_unit, use_r... |
class AlexNet(nn.Module):
def __init__(self, num_classes=1000, normalize_outputs=False, eval_only=True, train=False, stop_layer=None):
super(AlexNet, self).__init__()
assert (normalize_outputs == False), 'AlexNet cannot set normalize_outputs to True'
self.features = nn.Sequential(nn.Conv2... |
def alexnet(pretrained=False, load_path=None, **kwargs):
'AlexNet model architecture from the\n `"One weird trick..." <https://arxiv.org/abs/1404.5997>`_ paper.\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = AlexNet(**kwargs)
if pretrained:
... |
def alexnet_transform(output_size, dtype=np.float32):
" rescale_centercrop_resize\n \n Args:\n output_size: A tuple CxWxH\n dtype: of the output (must be np, not torch)\n \n Returns:\n a function which returns takes 'env' and returns transform, output_s... |
def alexnet_features_transform(task_path, dtype=np.float32):
" rescale_centercrop_resize\n \n Args:\n output_size: A tuple CxWxH\n dtype: of the output (must be np, not torch)\n \n Returns:\n a function which returns takes 'env' and returns transform, o... |
class AlexNetFeaturesOnlyNet(nn.Module):
def __init__(self, n_frames, n_map_channels=0, use_target=True, output_size=512, extra_kwargs={}):
super(AlexNetFeaturesOnlyNet, self).__init__()
self.n_frames = n_frames
self.use_target = use_target
self.use_map = (n_map_channels > 0)
... |
def atari_nature(num_inputs, num_outputs=512):
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_(x, 0)), nn.init.calculate_gain('relu')))
return nn.Sequential(init_(nn.Conv2d(num_inputs, 32, 8, stride=4)), nn.ReLU(), init_(nn.Conv2d(32, 64, 4, stride=2)), nn.ReLU(), init_(nn.Conv2d(... |
def atari_conv(num_inputs):
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_(x, 0)), nn.init.calculate_gain('relu')))
return nn.Sequential(init_(nn.Conv2d(num_inputs, 32, 8, stride=4)), nn.ReLU(), init_(nn.Conv2d(32, 64, 4, stride=2)), nn.ReLU(), init_(nn.Conv2d(64, 32, 3, stride=1... |
def atari_small_conv(num_inputs):
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_(x, 0)), nn.init.calculate_gain('relu')))
return nn.Sequential(init_(nn.Conv2d(num_inputs, 32, 8, stride=4)), nn.ReLU(), init_(nn.Conv2d(32, 64, 4, stride=2)), nn.ReLU())
|
def atari_match_conv(num_frames, num_inputs_per_frame):
num_inputs = (num_frames * num_inputs_per_frame)
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_(x, 0)), nn.init.calculate_gain('relu')))
return nn.Sequential(init_(nn.Conv2d(num_inputs, 64, 8, stride=4)), nn.ReLU(), init... |
def atari_big_conv(num_frames, num_inputs_per_frame):
num_inputs = (num_frames * num_inputs_per_frame)
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_(x, 0)), nn.init.calculate_gain('relu')))
return nn.Sequential(init_(nn.Conv2d(num_inputs, 64, 8, stride=4)), nn.ReLU(), init_(... |
def atari_nature_vae(num_inputs, num_outputs=512):
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_(x, 0)), nn.init.calculate_gain('relu')))
nn.Sequential(init_(nn.Conv2d(num_inputs, 32, 8, stride=4)), nn.ReLU(), init_(nn.Conv2d(32, 64, 4, stride=2)), nn.ReLU(), init_(nn.Conv2d(64,... |
def is_cuda(model):
return next(model.parameters()).is_cuda
|
def task_encoder(checkpoint_path):
net = TaskonomyEncoder()
net.eval()
print(checkpoint_path)
if (checkpoint_path != None):
path_pth_ckpt = os.path.join(checkpoint_path)
checkpoint = torch.load(path_pth_ckpt)
net.load_state_dict(checkpoint['state_dict'])
return net
|
class AtariNet(nn.Module):
def __init__(self, n_frames, n_map_channels=0, use_target=True, output_size=512):
super(AtariNet, self).__init__()
self.n_frames = n_frames
self.use_target = use_target
self.use_map = (n_map_channels > 0)
self.map_channels = n_map_channels
... |
class AtariNatureEncoder(nn.Module):
' VAE encoder '
def __init__(self, img_channels, latent_size):
super().__init__()
self.latent_size = latent_size
self.img_channels = img_channels
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_(x, 0)), nn.init.c... |
class FrameStacked(nn.Module):
def __init__(self, net, n_stack, parallel=False, max_parallel=50):
super().__init__()
self.net = net
self.n_stack = n_stack
self.parallel = parallel
self.max_parallel = max_parallel
def _prepare_inputs(self, x):
if isinstance(x, ... |
class MemoryFrameStacked(FrameStacked):
def __init__(self, net, n_stack, parallel=False, max_parallel=50, attrs_to_remember=[]):
super().__init__(net, n_stack, parallel=parallel, max_parallel=max_parallel)
self.attrs_to_remember = attrs_to_remember
def forward(self, x, cache=None):
x... |
class FramestackResnet(nn.Module):
def __init__(self, n_frames):
super(FramestackResnet, self).__init__()
self.n_frames = n_frames
self.resnet = resnet18(pretrained=True)
def forward(self, x):
assert ((x.shape[1] / 3) == self.n_frames), 'Dimensionality mismatch of input, is n... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.