def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config) self.input_size = (3, ) self.output_size = (1, 1) self.action_min = -2 self.action_max = 2 self._actor = mlp_creator( sizes=[self.input_size[0], 64, 64, self.output_size[0]], activation=nn.Tanh(), output_activation=None) self._critic = mlp_creator(sizes=[self.input_size[0], 64, 64, 1], activation=nn.Tanh(), output_activation=None) log_std = self._config.log_std if self._config.log_std != 'default' else -0.5 self.log_std = torch.nn.Parameter( torch.ones(self.output_size, dtype=torch.float32) * log_std, requires_grad=True) if not quiet: self._logger = get_logger( name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) cprint(f'Started.', self._logger) self.initialize_architecture()
def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config, quiet=True) self.input_size = (30, ) self.output_size = (3, ) self._actor = mlp_creator( sizes=[self.input_size[0], 64, 64, self.output_size[0]], activation=nn.Tanh(), output_activation=None) self._critic = mlp_creator(sizes=[self.input_size[0], 64, 64, 1], activation=nn.Tanh(), output_activation=None) self.initialize_architecture() self.discrete_action_mapper = DiscreteActionMapper([ torch.as_tensor([0.2, 0.0, 0.0, 0.0, 0.0, -0.2]), torch.as_tensor([0.2, 0.0, 0.0, 0.0, 0.0, 0.0]), torch.as_tensor([0.2, 0.0, 0.0, 0.0, 0.0, 0.2]), ]) if not quiet: self._logger = get_logger( name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) cprint(f'Started.', self._logger)
def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config, quiet=True) self.input_size = (4,) self.output_size = (5,) self.discrete = False log_std = self._config.log_std if self._config.log_std != 'default' else -0.5 self.log_std = torch.nn.Parameter(torch.ones(self.output_size, dtype=torch.float32) * log_std, requires_grad=True) self._actor = mlp_creator(sizes=[self.input_size[0], 10, self.output_size[0]], activation=nn.Tanh(), output_activation=None) self._critic = mlp_creator(sizes=[self.input_size[0], 10, 1], activation=nn.Tanh(), output_activation=None) self.initialize_architecture() self.discrete_action_mapper = DiscreteActionMapper([ torch.as_tensor([0.0, 0.0, 0.0, 0.0]), torch.as_tensor([-1.0, 0.0, 0.0, 0.0]), torch.as_tensor([1.0, 0.0, 0.0, 0.0]), torch.as_tensor([0.0, -1.0, 0.0, 0.0]), torch.as_tensor([0.0, 1.0, 0.0, 0.0]), ]) if not quiet: self._logger = get_logger(name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) cprint(f'Started.', self._logger)
def __init__(self, config: ArchitectureConfig, quiet: bool = False): raise NotImplementedError( 'Currently this should not work as the actions recorded are 6d ' 'but this network only return 1d') super().__init__(config=config, quiet=True) self.input_size = (30, ) self.output_size = (1, ) self.action_min = -1 self.action_max = +1 self._actor = mlp_creator( sizes=[self.input_size[0], 64, 64, self.output_size[0]], activation=nn.Tanh(), output_activation=nn.Tanh()) self._critic = mlp_creator(sizes=[self.input_size[0], 64, 64, 1], activation=nn.Tanh(), output_activation=None) log_std = self._config.log_std if self._config.log_std != 'default' else -0.5 self.log_std = torch.nn.Parameter( torch.ones(self.output_size, dtype=torch.float32) * log_std, requires_grad=True) if not quiet: self._logger = get_logger( name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) cprint(f'Started.', self._logger) self.initialize_architecture()
def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config, quiet=True) self.input_size_net = (2, ) self.output_size = (8, ) self.action_max = 0.5 self.starting_height = -1 self.previous_input = torch.Tensor([0, 0]) self.sz = 416 self._actor = mlp_creator( sizes=[self.input_size[0], 8, 2], # for now actors can only fly sideways layer_bias=True, activation=nn.Tanh(), output_activation=nn.Tanh()) log_std = self._config.log_std if self._config.log_std != 'default' else -0.5 self.log_std = torch.nn.Parameter(torch.ones( (1, ), dtype=torch.float32) * log_std, requires_grad=True) self._critic = mlp_creator(sizes=[self.input_size[0], 8, 1], layer_bias=True, activation=nn.Tanh(), output_activation=nn.Tanh()) self._adversarial_actor = mlp_creator(sizes=[self.input_size[0], 8, 2], layer_bias=True, activation=nn.Tanh(), output_activation=nn.Tanh()) self.adversarial_log_std = torch.nn.Parameter(torch.ones( (1, ), dtype=torch.float32) * log_std, requires_grad=True) self._adversarial_critic = mlp_creator( sizes=[self.input_size[0], 8, 1], layer_bias=True, activation=nn.Tanh(), output_activation=nn.Tanh()) self.yolov3_tiny = Yolov3Tiny(num_classes=80) self.yolov3_tiny.load_state_dict( torch.load('src/ai/yolov3/yolov3_files/yolov3_tiny_coco_01.h5')) if not quiet: self._logger = get_logger( name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) cprint(f'Started.', self._logger) self.initialize_architecture()
def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config, quiet=True) self._playfield_size = (0, 1, 0) self.input_size = (1, ) self.output_size = (8, ) self.action_min = -0.5 self.action_max = 0.5 self.starting_height = -1 self.previous_input = 0 self.waypoint = get_waypoint(self._playfield_size) self._actor = mlp_creator( sizes=[self.input_size[0], 4, 1], # for now actors can only fly sideways layer_bias=False, activation=nn.Tanh(), output_activation=None) log_std = self._config.log_std if self._config.log_std != 'default' else -0.5 self.log_std = torch.nn.Parameter(torch.ones( (1, ), dtype=torch.float32) * log_std, requires_grad=True) self._critic = mlp_creator(sizes=[self.input_size[0], 4, 1], layer_bias=False, activation=nn.Tanh(), output_activation=None) self._adversarial_actor = mlp_creator(sizes=[self.input_size[0], 4, 1], layer_bias=False, activation=nn.Tanh(), output_activation=None) self.adversarial_log_std = torch.nn.Parameter(torch.ones( (1, ), dtype=torch.float32) * log_std, requires_grad=True) self._adversarial_critic = mlp_creator( sizes=[self.input_size[0], 4, 1], layer_bias=False, activation=nn.Tanh(), output_activation=None) if not quiet: self._logger = get_logger( name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) cprint(f'Started.', self._logger) self.initialize_architecture()
def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config, quiet=True) self._logger = get_logger( name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) if not quiet: cprint(f'Started.', self._logger) self.input_size = (3, 128, 128) self.output_size = (6, ) self.discrete = False self.dropout = nn.Dropout( p=config.dropout) if config.dropout != 'default' else None self.encoder = nn.Sequential( nn.Conv2d(3, 32, 4, stride=2), nn.ReLU(), nn.Conv2d(32, 64, 4, stride=2), nn.ReLU(), nn.Conv2d(64, 128, 4, stride=2), nn.ReLU(), nn.Conv2d(128, 256, 4, stride=2), nn.ReLU(), ) self.decoder = mlp_creator( sizes=[256 * 6 * 6, 128, 128, self.output_size[0]], activation=nn.ReLU(), output_activation=nn.Tanh(), bias_in_last_layer=False) self.initialize_architecture()
def test_mlp_creator(self): network = mlp_creator(sizes=[4, 10, 10, 1], activation=nn.ReLU(), output_activation=None, bias_in_last_layer=False) self.assertEqual(len(network), 5) count = 0 for p in network.parameters(): count += np.prod(p.shape) self.assertEqual(count, 170)
def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config, quiet=True) self.input_size = (4, ) self.output_size = (2, ) self._actor = mlp_creator( sizes=[self.input_size[0], 64, 64, self.output_size[0]], activation=nn.Tanh(), output_activation=None) self._critic = mlp_creator(sizes=[self.input_size[0], 64, 64, 1], activation=nn.Tanh(), output_activation=None) if not quiet: self._logger = get_logger( name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) cprint(f'Started.', self._logger) self.initialize_architecture()
def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config, quiet=True) self._logger = get_logger(name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) if not quiet: cprint(f'Started.', self._logger) self.input_size = (1, 200, 200) self.output_size = (6,) self.discrete = False self.dropout = nn.Dropout(p=config.dropout) if config.dropout != 'default' else None self.conv2d_1 = nn.Conv2d(in_channels=self.input_size[0], out_channels=32, kernel_size=5, stride=2, padding=1, bias=True) self.maxpool_1 = nn.MaxPool2d(kernel_size=3, stride=2) # First residual block self.batch_normalization_1 = nn.BatchNorm2d(32) self.conv2d_2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, stride=2, padding=1, bias=True) self.batch_normalization_2 = nn.BatchNorm2d(32) self.conv2d_3 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, stride=1, padding=1, bias=True) self.conv2d_4 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=1, stride=2, padding=0, bias=True) # Second residual block self.batch_normalization_3 = nn.BatchNorm2d(32) self.conv2d_5 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=2, padding=1, bias=True) self.batch_normalization_4 = nn.BatchNorm2d(64) self.conv2d_6 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1, bias=True) self.conv2d_7 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=1, stride=2, padding=0, bias=True) # Third residual block self.batch_normalization_5 = nn.BatchNorm2d(64) self.conv2d_8 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=2, padding=1, bias=True) self.batch_normalization_6 = nn.BatchNorm2d(128) self.conv2d_9 = nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1, bias=True) self.conv2d_10 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=1, stride=2, padding=0, bias=True) #self.dense_1 = nn.Linear(6272, 1) #self.dense_2 = nn.Linear(6272, 1) self.decoder = mlp_creator(sizes=[6272, 2056, self.output_size[0]], activation=nn.ReLU(), output_activation=nn.Tanh(), bias_in_last_layer=False)
def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config, quiet=True) self._logger = get_logger( name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) if not quiet: cprint(f'Started.', self._logger) self.input_size = (1, 240, 428) self.output_size = (6, ) self.discrete = False self.dropout = nn.Dropout( p=config.dropout) if config.dropout != 'default' else None self.batch_normalisation = config.batch_normalisation if isinstance(config.batch_normalisation, bool) \ else False self.encoder = nn.Sequential( nn.Conv2d(1, 12, 3, stride=2, padding=2), nn.ReLU(), nn.Conv2d(12, 12, 3, stride=2, padding=2), nn.ReLU(), nn.Conv2d(12, 12, 3, stride=2, padding=2), nn.ReLU(), nn.Conv2d(12, 24, 3, stride=2, padding=2), nn.ReLU(), nn.Conv2d(24, 24, 3, stride=2, padding=2), nn.ReLU(), nn.Conv2d(24, 24, 3, stride=2, padding=2), nn.ReLU(), nn.Conv2d(24, 32, 3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(32, 64, 3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(64, 64, 3, stride=1, padding=1), nn.ReLU(), ) self.decoder = mlp_creator(sizes=[3456, 128, 64, self.output_size[0]], activation=nn.ReLU(), output_activation=nn.Identity(), bias_in_last_layer=False) self.initialize_architecture()
def __init__(self, config: ArchitectureConfig, quiet: bool = False): super().__init__(config=config, quiet=True) self._deeply_supervised_parameter_names = [ name for name, _ in self.named_parameters() ] self._discriminator = conv_creator( channels=[1, 3, 6, 9], kernel_sizes=[5, 5, 5], strides=[3, 3, 3], activation=nn.LeakyReLU(), output_activation=nn.LeakyReLU(), batch_norm=self._config.batch_normalisation) self._discriminator_decision = mlp_creator( [9 * 6 * 6, 1], output_activation=nn.Sigmoid(), bias_in_last_layer=False) if not quiet: self._logger = get_logger( name=get_filename_without_extension(__file__), output_path=config.output_path, quiet=False) self.initialize_architecture() cprint(f'Started.', self._logger)
################################################################################ print(f'{get_date_time_tag()}: Define network') input_size = 8 * 16 * 16 output_size = 64 * 64 VisualPriorRepresentation._load_unloaded_nets([feature_type]) encoder = VisualPriorRepresentation.feature_task_to_net[feature_type] fixed_encoder = copy.deepcopy(encoder) if arguments.side_tuning else None if arguments.end_to_end or arguments.side_tuning: for p in encoder.parameters(): p.requires_grad = True if arguments.mlp: decoder = mlp_creator(sizes=[input_size, 2056, 2056, output_size], activation=nn.ReLU(), output_activation=None, bias_in_last_layer=False) else: decoder = TaskonomyDecoder(out_channels=1, is_decoder_mlp=False, apply_tanh=True, eval_only=False) for p in decoder.parameters(): p.requires_grad = True print(f'encoder: {get_checksum_network_parameters(encoder.parameters())}') print(f'decoder: {get_checksum_network_parameters(decoder.parameters())}') if arguments.side_tuning: print( f'fixed_encoder: {get_checksum_network_parameters(fixed_encoder.parameters())}' )