def __init__(self, num_skills, state_size, hidden_size, code_size,
num_layers=4, normalize_inputs=False, skill_preprocessing_fn=lambda x: x,
input_key='next_state', input_size=None):
super().__init__()
self.num_skills = int(num_skills)
self.state_size = int(state_size) if input_size is None else int(input_size)
self.code_size = int(code_size)
self.normalize_inputs = bool(normalize_inputs)
self.skill_preprocessing_fn = skill_preprocessing_fn
self.input_key = str(input_key)
self._make_normalizer_module()
assert num_layers >= 2
self.num_layers = int(num_layers)
self.encoder = create_nn(input_size=self.input_size, output_size=self.encoder_output_size,
hidden_size=hidden_size, num_layers=self.num_layers,
input_normalizer=self.normalizer if self.normalizes_inputs else nn.Sequential())
self.decoder = create_nn(input_size=self.code_size, output_size=self.input_size,
hidden_size=hidden_size, num_layers=self.num_layers)
self.mse_loss = nn.MSELoss(reduction='none')
def __init__(self,
n,
state_size,
hidden_size,
num_layers=4,
normalize_inputs=False,
input_key='next_state',
input_size=None):
super().__init__()
self.n = n
self.state_size = int(state_size) if input_size is None else int(
input_size)
self.input_key = str(input_key)
assert num_layers >= 2
self.num_layers = int(num_layers)
input_normalizer = Normalizer(
self.state_size) if normalize_inputs else nn.Sequential()
self.layers = create_nn(input_size=self.state_size,
output_size=self.n,
hidden_size=hidden_size,
num_layers=self.num_layers,
input_normalizer=input_normalizer)
self.softmax = nn.Softmax(dim=1)
self.loss = nn.CrossEntropyLoss(reduction='none')
def __init__(self,
env,
hidden_size,
a_range=None,
state_size=None,
goal_size=None,
action_size=None,
num_layers=4,
normalize_inputs=False):
super().__init__()
self.a_range = env.action_range if a_range is None else a_range
self.state_size = env.state_size if state_size is None else state_size
self.goal_size = env.goal_size if goal_size is None else goal_size
self.action_size = env.action_size if action_size is None else action_size
assert num_layers >= 2
self.num_layers = int(num_layers)
input_size = self.state_size + self.goal_size
input_normalizer = Normalizer(
input_size) if normalize_inputs else nn.Sequential()
self.layers = create_nn(input_size=input_size,
output_size=self.action_size * 2,
hidden_size=hidden_size,
num_layers=self.num_layers,
input_normalizer=input_normalizer,
final_activation_fn=nn.Softplus)
def __init__(self,
n,
state_size,
hidden_size,
num_layers=4,
skill_preprocessing_fn=lambda x: x,
normalize_inputs=False):
super().__init__()
self.n = n
self.state_size = int(state_size)
assert num_layers >= 2
self.num_layers = int(num_layers)
self.normalize_inputs = bool(normalize_inputs)
self.skill_preprocessing_fn = skill_preprocessing_fn
self._make_normalizer_module(
) # in practice, this will normalize states (outputs) instead of skills (inputs)
self.layers = create_nn(input_size=self.input_size,
output_size=self.output_size,
hidden_size=hidden_size,
num_layers=self.num_layers,
input_normalizer=nn.Sequential())
self.mse_loss = nn.MSELoss(reduction='none')
def __init__(self,
env,
hidden_size,
a_range=None,
state_size=None,
goal_size=None,
action_size=None,
num_layers=4,
normalize_inputs=False,
min_logstd=-20,
max_logstd=2,
hidden_init_fn=None,
b_init_value=None,
last_fc_init_w=None):
super().__init__()
self.a_range = env.action_range if a_range is None else a_range
self.state_size = env.state_size if state_size is None else state_size
self.goal_size = env.goal_size if goal_size is None else goal_size
self.action_size = env.action_size if action_size is None else action_size
self.min_logstd = min_logstd
self.max_logstd = max_logstd
input_size = self.state_size + self.goal_size
assert num_layers >= 2
self.num_layers = int(num_layers)
input_normalizer = Normalizer(
input_size) if normalize_inputs else nn.Sequential()
self.layers = create_nn(input_size=input_size,
output_size=self.action_size * 2,
hidden_size=hidden_size,
num_layers=self.num_layers,
input_normalizer=input_normalizer,
hidden_init_fn=hidden_init_fn,
b_init_value=b_init_value,
last_fc_init_w=last_fc_init_w)
def __init__(self,
env,
hidden_size,
use_antigoal=False,
a_range=None,
state_size=None,
goal_size=None,
num_layers=4,
normalize_inputs=False,
hidden_init_fn=None,
b_init_value=None,
last_fc_init_w=None,
antigoal_size=None):
super().__init__()
self.use_antigoal = use_antigoal
self.a_range = env.action_range if a_range is None else a_range
self.state_size = env.state_size if state_size is None else state_size
self.goal_size = env.goal_size if goal_size is None else goal_size
self.antigoal_size = env.goal_size if antigoal_size is None else antigoal_size
assert num_layers >= 2
self.num_layers = int(num_layers)
input_size = self.state_size + self.goal_size
if self.use_antigoal:
input_size += self.antigoal_size
input_normalizer = Normalizer(
input_size) if normalize_inputs else nn.Sequential()
self.layers = create_nn(input_size=input_size,
output_size=1,
hidden_size=hidden_size,
num_layers=self.num_layers,
input_normalizer=input_normalizer,
hidden_init_fn=hidden_init_fn,
b_init_value=b_init_value,
last_fc_init_w=last_fc_init_w)