def __init__(self,
config: dict = None,
pose_autoencoder=None,
cost_input_dimension=None,
phase_dim=0,
input_slicers: list = None,
output_slicers: list = None,
train_set=None,
val_set=None,
name="model",
load=False):
super().__init__()
if not load:
self.pose_autoencoder = pose_autoencoder # start with 3
cost_hidden_dim = config["cost_hidden_dim"]
cost_output_dim = config["cost_output_dim"]
self.cost_encoder = MLP(dimensions=[
cost_input_dimension, cost_hidden_dim, cost_hidden_dim,
cost_output_dim
],
name="CostEncoder",
load=True,
single_module=-1)
phase_dim = input_slicers[0]
moe_input_dim = pose_autoencoder.dimensions[
-1] + phase_dim + cost_output_dim
moe_output_dim = pose_autoencoder.dimensions[
-1] + pose_autoencoder.extra_feature_len + phase_dim * 2 + cost_input_dimension
self.generationModel = RNN(
config=config,
dimensions=[moe_input_dim, moe_output_dim],
device=self.device,
batch_size=2 * config["batch_size"],
name="GRU")
# (120 * config["batch_size"]) / config["autoregress_chunk_size"]) - 1 *
# config["batch_size"],
# self.batch_norm = nn.BatchNorm1d(np.sum())
self.in_slices = [0] + list(accumulate(add, input_slicers))
# self.in_slices = input_slicers
self.out_slices = [0] + list(accumulate(add, output_slicers))
# self.out_slices = output_slicers
self.config = config
self.batch_size = config["batch_size"]
self.learning_rate = config["lr"]
self.loss_fn = config["loss_fn"]
self.autoregress_chunk_size = config["autoregress_chunk_size"]
# self.autoregress_prob = config["autoregress_prob"]
# self.autoregress_inc = config["autoregress_inc"]
self.best_val_loss = np.inf
self.phase_smooth_factor = 0.9
self.train_set = train_set
self.val_set = val_set
self.name = name
def __init__(self,
config: dict = None,
Model=None,
pose_autoencoder=None,
feature_dims=None,
input_slicers: list = None,
output_slicers: list = None,
train_set=None,
val_set=None,
test_set=None,
name="MotionGeneration"):
super().__init__()
self.feature_dims = feature_dims
self.config = config
self.loss_fn = config[
"loss_fn"] if "loss_fn" in config else nn.functional.mse_loss
self.opt = config[
"optimizer"] if "optimizer" in config else torch.optim.Adam
self.scheduler = config["scheduler"] if "scheduler" in config else None
self.scheduler_param = config[
"scheduler_param"] if "scheduler_param" in config else None
self.batch_size = config["batch_size"]
self.learning_rate = config["lr"]
self.best_val_loss = np.inf
self.phase_smooth_factor = 0.9
self.pose_autoencoder = pose_autoencoder if pose_autoencoder is not None else \
MLP(config=config, dimensions=[feature_dims["pose_dim"]], name="PoseAE")
self.use_label = pose_autoencoder is not None and pose_autoencoder.use_label
cost_hidden_dim = config["cost_hidden_dim"]
self.cost_encoder = MLP(config=config,
dimensions=[
feature_dims["cost_dim"], cost_hidden_dim,
cost_hidden_dim, cost_hidden_dim
],
name="CostEncoder",
single_module=-1)
self.generationModel = Model(config=config,
dimensions=[
feature_dims["g_input_dim"],
feature_dims["g_output_dim"]
],
phase_input_dim=feature_dims["phase_dim"])
self.input_dims = input_slicers
self.output_dims = output_slicers
self.in_slices = [0] + list(accumulate(add, input_slicers))
self.out_slices = [0] + list(accumulate(add, output_slicers))
self.train_set = train_set
self.val_set = val_set
self.test_set = test_set
self.name = name
def __init__(self,
config: dict = None,
pose_autoencoder=None,
cost_input_dimension=None,
phase_dim=0,
input_slicers: list = None,
output_slicers: list = None,
train_set=None,
val_set=None,
name="model",
load=False):
super().__init__()
if not load:
self.pose_autoencoder = pose_autoencoder # start with 3
cost_hidden_dim = config["cost_hidden_dim"]
cost_output_dim = config["cost_output_dim"]
self.cost_encoder = MLP(dimensions=[
cost_input_dimension, cost_hidden_dim, cost_hidden_dim,
cost_output_dim
],
name="CostEncoder",
load=True,
single_module=-1)
self.phase_dim = phase_dim
phase_dim = input_slicers[0]
moe_input_dim = pose_autoencoder.dimensions[-1] + cost_output_dim
moe_output_dim = pose_autoencoder.dimensions[
-1] + self.phase_dim + cost_input_dimension
self.generationModel = MoE(
config=config,
dimensions=[moe_input_dim, moe_output_dim],
phase_input_dim=phase_dim,
name="MixtureOfExperts")
self.in_slices = [0] + list(accumulate(add, input_slicers))
self.out_slices = [0] + list(accumulate(add, output_slicers))
self.config = config
self.batch_size = config["batch_size"]
self.learning_rate = config["lr"]
self.loss_fn = config["loss_fn"]
self.window_size = config["window_size"]
self.autoregress_chunk_size = config["autoregress_chunk_size"]
self.autoregress_prob = config["autoregress_prob"]
self.autoregress_inc = config["autoregress_inc"]
self.best_val_loss = np.inf
self.phase_smooth_factor = 0.9
self.epochs = 0
self.train_set = train_set
self.val_set = val_set
self.name = name
self.epochs = 0
self.automatic_optimization = False
def swap_pose_encoder(self, pose_encoder=None,
input_dim=None, output_dim=None,
feature_dims=None, freeze=False):
self.pose_autoencoder = pose_encoder
self.input_dims = input_dim
self.output_dims = output_dim
self.feature_dims = feature_dims
self.in_slices = [0] + list(accumulate(add, self.input_dims))
self.out_slices = [0] + list(accumulate(add, self.output_dims))
if freeze:
self.generationModel.freeze()
self.cost_encoder.freeze()
def _decode_header_to_dict(
cls, encoded_header: bytes) -> Iterator[Tuple[str, Any]]:
if len(encoded_header) != cls.smc_encoded_size:
raise ValidationError(
"Expected encoded header to be of size: {0}. Got size {1} instead.\n- {2}"
.format(
cls.smc_encoded_size,
len(encoded_header),
encode_hex(encoded_header),
))
start_indices = accumulate(lambda i, field: i + field[2],
cls.fields_with_sizes, 0)
field_bounds = sliding_window(2, start_indices)
for byte_range, field in zip(field_bounds, cls._meta.fields):
start_index, end_index = byte_range
field_name, field_type = field
field_bytes = encoded_header[start_index:end_index]
if field_type == rlp.sedes.big_endian_int:
# remove the leading zeros, to avoid `not minimal length` error in deserialization
formatted_field_bytes = field_bytes.lstrip(b'\x00')
elif field_type == address:
formatted_field_bytes = field_bytes[-20:]
else:
formatted_field_bytes = field_bytes
yield field_name, field_type.deserialize(formatted_field_bytes)
def __init__(self,
config: dict = None,
input_dims: list = None,
pose_labels=None,
train_set=None,
val_set=None,
test_set=None,
name: str = "model",
save_period=5,
workers=6):
super(RBF, self).__init__()
M = len(input_dims)
self.name = name
self.input_dims = input_dims
self.input_slice = [0] + list(accumulate(add, input_dims))
self.act = nn.ELU
self.save_period = save_period
self.workers = workers
self.pose_labels = pose_labels if pose_labels is not None else [
None for _ in range(M)
]
self.config = config
self.basis_func = basis_func_dict()[config["basis_func"]]
self.hidden_dim = config["hidden_dim"]
self.keep_prob = config["keep_prob"]
self.k = config["k"]
self.learning_rate = config["lr"]
self.batch_size = config["batch_size"]
self.loss_fn = config[
"loss_fn"] if "loss_fn" in config else nn.functional.mse_loss
self.opt = config[
"optimizer"] if "optimizer" in config else torch.optim.Adam
self.scheduler = config["scheduler"] if "scheduler" in config else None
self.scheduler_param = config[
"scheduler_param"] if "scheduler_param" in config else None
self.models = [
MLP(config=config,
dimensions=[input_dims[i]],
pose_labels=self.pose_labels[i],
name="M" + str(i),
single_module=0) for i in range(M)
]
self.active_models = self.models
self.cluster_model = RBF_Layer(in_features=self.k,
out_features=self.k,
basis_func=self.basis_func)
self.train_set = train_set
self.val_set = val_set
self.test_set = test_set
self.best_val_loss = np.inf
def add_models(self,
input_dims: list = None,
pose_labels: list = None,
freeze=False):
n = len(self.models) + 1
if pose_labels is not None:
self.models += [
MLP(config=self.config,
dimensions=[input_dims[i]],
pose_labels=pose_labels[i],
name="M" + str(i + n),
single_module=0) for i in range(len(input_dims))
]
else:
self.models += [
MLP(config=self.config,
dimensions=[input_dims[i]],
name="M" + str(i + n),
single_module=0) for i in range(len(input_dims))
]
if freeze:
for model in self.active_models:
model.freeze(True)
self.active_models = self.models[n - 1:]
self.input_dims = input_dims
else:
self.active_models = self.models
self.input_dims += input_dims
self.input_slice = [0] + list(accumulate(add, self.input_dims))
def test_headerdb_get_score_for_non_genesis_headers(headerdb, genesis_header):
headerdb.persist_header(genesis_header)
headers = mk_header_chain(genesis_header, length=10)
difficulties = tuple(h.difficulty for h in headers)
scores = tuple(accumulate(operator.add, difficulties, genesis_header.difficulty))
headerdb.persist_header_chain(headers)
for header, expected_score in zip(headers, scores[1:]):
actual_score = headerdb.get_score(header.hash)
assert actual_score == expected_score
def __init__(self, *clause, copula=None, name=None):
"""
:param clause: clause like objects including :class:`Clause`,
:class:`ParallelGroup`, :class:`SequentialGroup` etc
:param copula: a custom copula function
:param name: a optional name of this group
"""
super().__init__(*clause, name=name)
if copula is None:
self.copula = Lambda(lambda lst, context: list(accumulate(mul, (1 - x for x in lst), initial=1)),
repre='DefaultCopula')
else:
self.copula = copula
def assert_is_canonical_chain(headerdb, headers):
if not headers:
return
# verify that the HEAD is correctly set.
head = headerdb.get_canonical_head()
assert_headers_eq(head, headers[-1])
# verify that each header is set as the canonical block.
for header in headers:
canonical_hash = headerdb.get_canonical_block_hash(header.block_number)
assert canonical_hash == header.hash
# verify difficulties are correctly set.
base_header = headerdb.get_block_header_by_hash(headers[0].parent_hash)
difficulties = tuple(h.difficulty for h in headers)
scores = tuple(accumulate(operator.add, difficulties, base_header.difficulty))
for header, expected_score in zip(headers, scores[1:]):
actual_score = headerdb.get_score(header.hash)
assert actual_score == expected_score
def ranges(c):
return accumulate(add, cons(0, c))
