def propagate(self, from_blocks: List[Namespace], block: Namespace):
"""Method that propagates shapes to a block.
Args:
from_blocks: The input blocks.
block: The block to propagate its shapes.
Raises:
ValueError: When block.output_feats not valid.
NotImplementedError: If num_features_source is not one of {"from_shape", "output_feats"}.
"""
## Set default values ##
kernel = block.kernel_size
stride = block.stride if hasattr(block, 'stride') else 1
padding = block.padding if hasattr(block, 'padding') else 0
dilation = block.dilation if hasattr(block, 'dilation') else 1
## Initialize block._shape ##
auto_dims = [auto_tag for _ in range(self.conv_dims)]
from_shape = get_shape('out', from_blocks[0])
if self.num_features_source == 'from_shape':
block._shape = create_shape(from_shape,
[from_shape[0]] + auto_dims)
elif self.num_features_source == 'output_feats':
check_output_feats_dims(1, self.block_class, block)
block._shape = create_shape(from_shape,
[block.output_feats] + auto_dims)
## Calculate and set <<auto>> output dimensions ##
for dim, val in enumerate(get_shape('out', block)):
if val == auto_tag:
in_length = get_shape('in', block)[dim]
out_length = conv_out_length(in_length, kernel, stride,
padding, dilation)
set_shape_dim('out', block, dim, out_length)
def propagate(self, from_blocks: List[Namespace], block: Namespace):
"""Method that propagates shapes to a block.
Args:
from_blocks: The input blocks.
block: The block to propagate its shapes.
"""
shape_in = get_shape('out', from_blocks[0])
shape_out = []
if block.reshape_spec == 'flatten':
reshape_spec = [[n for n in range(len(shape_in))]]
else:
reshape_spec = norm_reshape_spec(block.reshape_spec)
for val in reshape_spec:
if isinstance(val, int):
shape_out.append(shape_in[val])
elif isinstance(val, list):
shape_out.append(prod([shape_in[x] for x in val]))
elif isinstance(val, dict):
idx = next(iter(val.keys()))
in_dim = shape_in[int(idx)]
dims = val[idx]
if any(x == auto_tag for x in dims):
auto_idx = dims.index(auto_tag)
nonauto = prod([x for x in dims if x != auto_tag])
dims[auto_idx] = divide(in_dim, nonauto)
shape_out.extend(dims)
block._shape = create_shape(shape_in, shape_out)
def propagate(self, from_blocks: List[Namespace], block: Namespace):
"""Method that propagates shapes to a block.
Args:
from_blocks: The input blocks.
block: The block to propagate its shapes.
Raises:
ValueError: When bidirectional==True and output_feats not even.
"""
## Set default values ##
if not hasattr(block, 'bidirectional'):
block.bidirectional = False
## Initialize block._shape ##
from_shape = get_shape('out', from_blocks[0])
output_feats = block.output_feats
block._shape = create_shape(from_shape, [auto_tag, output_feats])
## Set hidden size ##
if block.bidirectional and output_feats % 2 != 0:
raise ValueError(
f'For bidirectional {block._class} expected output_feats to be even, but got {output_feats}.'
)
block.hidden_size = output_feats // (2 if block.bidirectional else 1)
## Propagate first dimension ##
set_shape_dim('out', block, 0, from_shape[0])
def propagate(
self,
from_blocks: List[Namespace],
block: Namespace,
propagators: dict,
ext_vars: dict,
cwd: str = None,
):
"""Method that propagates shapes in the given block.
Args:
from_blocks: The input blocks.
block: The block to propagate its shapes.
propagators: Dictionary of propagators.
ext_vars: Dictionary of external variables required to load jsonnet.
cwd: Working directory to resolve relative paths.
Raises:
ValueError: If there are multiple blocks with the same id.
ValueError: If no propagator found for some block.
"""
add_ids_prefix(block, from_blocks)
blocks = get_blocks_dict(from_blocks + block.blocks)
topological_predecessors = parse_graph(from_blocks, block)
try:
propagate_shapes(blocks,
topological_predecessors,
propagators=propagators,
ext_vars=ext_vars,
cwd=cwd)
except Exception as ex:
raise type(ex)(f'block[id={block._id}]: {ex}') from ex
in_shape = get_shape('out', from_blocks[0])
out_shape = get_shape('out', block.blocks[-1])
block._shape = create_shape(in_shape, out_shape)
def propagate(self, from_blocks: List[Namespace], block: Namespace):
"""Method that propagates shapes to a block.
Args:
from_blocks: The input blocks.
block: The block to propagate its shapes.
"""
block._shape = create_shape(get_shape('out', from_blocks[0]))
def propagate(self, from_blocks: List[Namespace], block: Namespace):
"""Method that propagates shapes to a block.
Args:
from_blocks: The input blocks.
block: The block to propagate its shapes.
"""
shape_in = list(get_shape('out', from_blocks[0]))
shape_in[block.dim] = None
shape_out = list(shape_in)
shape_out[block.dim] = sum(
[get_shape('out', b)[block.dim] for b in from_blocks])
block._shape = create_shape(shape_in, shape_out)
def propagate(self, from_blocks: List[Namespace], block: Namespace):
"""Method that propagates shapes to a block.
Args:
from_blocks: The input blocks.
block: The block to propagate its shapes.
"""
from_shape = get_shape('out', from_blocks[0])
if self.fixed_dims == 1:
to_shape = from_shape + [block.output_feats]
else:
to_shape = from_shape + block.output_feats
block._shape = create_shape(from_shape, to_shape)
def propagate(
self,
from_blocks: List[Namespace],
block: Namespace,
propagators: dict = None,
ext_vars: Namespace = {},
cwd: str = None,
):
"""Method that propagates shapes through a module.
Args:
from_blocks: The input blocks.
block: The block to propagate its shapes.
propagators: Dictionary of propagators.
ext_vars: External variables required to load jsonnet.
cwd: Working directory to resolve relative paths.
Raises:
ValueError: If no propagator found for some block.
"""
block_ext_vars = deepcopy(ext_vars)
if ext_vars is None:
block_ext_vars = Namespace()
elif isinstance(ext_vars, dict):
block_ext_vars = Namespace(**block_ext_vars)
if hasattr(block, '_ext_vars'):
vars(block_ext_vars).update(vars(block._ext_vars))
cfg = {
'ext_vars': block_ext_vars,
'cwd': cwd,
'parent_id': block._id,
'propagate': False,
'propagators': propagators
}
module = ModuleArchitecture(block._path, cfg=cfg)
self.connect_input(from_blocks, block, module)
module.propagate()
block._shape = module.architecture._shape
delattr(module.architecture, '_shape')
block.architecture = module.architecture