def test_create_flock_params():
"""Read from the params class and convert to list of params class instances"""
params = MultipleLayersParams()
params.seq_length = [1, 2, 3]
params.n_cluster_centers = [1, 2, 3]
params.cluster_boost_threshold = 123
params.num_conv_layers = 3
params_list = params.convert_to_expert_params()
assert len(params_list) == 3
conv_classes = params.read_list_of_params('conv_classes')
assert len(conv_classes) == 3
conv_classes += [params.read_param('conv_classes', 0)]
assert len(conv_classes) == 4
conv_classes += params.read_list_of_params('conv_classes')
assert len(conv_classes) == 7
num_cc = params.read_list_of_params('n_cluster_centers')
assert len(num_cc) == 3
n_cc = params.read_param('n_cluster_centers', 1)
assert n_cc == 2
cbt = params.read_list_of_params('cluster_boost_threshold')
assert isinstance(cbt, list)
assert len(cbt) == 3
top_params = MultipleLayersParams()
cbt = top_params.read_list_of_params('cluster_boost_threshold')
assert isinstance(cbt, list)
assert len(cbt) == 1
def test_default_top_params():
"""Default params should be set for 1 layer (i.e. the top-level one)"""
params = MultipleLayersParams()
params_list = params.convert_to_expert_params()
assert len(params_list) == 1
def __init__(self,
top_layer_params: MultipleLayersParams = None,
model_seed: Optional[int] = None,
baseline_seed: Optional[int] = None,
class_filter: List[int] = None,
random_order: bool = False,
num_labels: int = 20,
image_size=SeDatasetSize.SIZE_64,
fof_fixed_size: Optional[int] = None):
super().__init__(device='cuda')
# parse params here
self._dataset_params = DatasetSeObjectsParams()
self._dataset_params.dataset_config = DatasetConfig.TRAIN_ONLY
self._dataset_params.dataset_size = image_size
self._dataset_params.class_filter = class_filter
self._dataset_params.random_order = random_order
self._dataset_params.seed = baseline_seed
if top_layer_params is None:
top_layer_params = MultipleLayersParams()
self._top_params = top_layer_params.convert_to_expert_params()[0]
self._label_size = num_labels
self._fof_fixed_size = fof_fixed_size
# create and add nodes here
self._node_se_dataset = DatasetSeObjectsNode(self._dataset_params)
self.add_node(self._node_se_dataset)
self._attention_group = BottomUpAttentionGroup()
self.add_node(self._attention_group)
if self._fof_fixed_size is not None:
input_size = self._fof_fixed_size
self._attention_group.fixed_region_size = self._fof_fixed_size
self._attention_group.use_fixed_region = True
else:
input_size = image_size.value
self._attention_group.use_fixed_region = False
self._input_data_size = input_size * input_size * 3
self._sp_reconstruction_layer = SpReconstructionLayer(
self._input_data_size,
self._label_size,
self._top_params,
"ReconstructionLayer",
model_seed)
self.add_node(self._sp_reconstruction_layer)
# connect nodes here
Connector.connect(self._node_se_dataset.outputs.image_output,
self._attention_group.inputs.image)
Connector.connect(self._attention_group.outputs.fof,
self._sp_reconstruction_layer.inputs.data)
Connector.connect(self._node_se_dataset.outputs.task_to_agent_label,
self._sp_reconstruction_layer.inputs.label)
def __init__(self,
inputs: TNCMGroupInputs,
outputs: TOutputs,
conv_layers_params: MultipleLayersParams,
model_seed: Optional[int] = 321,
image_size: Tuple[int, int, int] = (24, 24, 3),
name: str = "TA Model"):
""" Create the multilayer topology of configuration: N conv layers
Args:
conv_layers_params: parameters for each layer (or default ones)
model_seed: seed of the topology
image_size: small resolution by default
"""
super().__init__(name=name,
inputs=inputs,
outputs=outputs)
self._num_layers = conv_layers_params.num_conv_layers + 1
self._input_dims = image_size
# parse conv layers to ExpertParams
self._conv_params_list = conv_layers_params.convert_to_expert_params()
# other parameters for the convolution
conv_classes = conv_layers_params.read_list_of_params('conv_classes')
rf_sizes = conv_layers_params.read_list_of_params('rf_size')
rf_strides = conv_layers_params.read_list_of_params('rf_stride')
num_flocks = conv_layers_params.read_list_of_params('n_flocks')
self._conv_params = self.create_conv_layer_params(param_list=self._conv_params_list,
rf_sizes=rf_sizes,
rf_strides=rf_strides,
num_flocks=num_flocks,
conv_classes=conv_classes,
model_seed=model_seed)
self.conv_layers, self.output_projection_sizes = create_connected_conv_layers(self._conv_params,
self._input_dims)
for layer in self.conv_layers:
self.add_node(layer)
# image -> Conv0
Connector.connect(
self.inputs.image.output,
self.conv_layers[0].inputs.data)
def __init__(self,
conv_layers_params: MultipleLayersParams,
top_layer_params: MultipleLayersParams,
model_seed: Optional[int] = 321,
num_labels: int = 20,
image_size: Tuple[int, int, int] = (24, 24, 3),
name: str = "Nc1r1Group"):
super().__init__(ClassificationTaskInputs(self),
ClassificationTaskOutputs(self), conv_layers_params,
model_seed, image_size, name)
self._num_labels = num_labels
validate_predicate(
lambda: self._num_labels is not None,
"num_labels cannot be None if top layer is used (top_layer_params is not None)."
)
# parse to expert params
self._top_params = top_layer_params.convert_to_expert_params()[0]
self.top_layer = SpReconstructionLayer(self.output_projection_sizes,
self._num_labels,
sp_params=self._top_params,
name='TOP',
seed=model_seed)
self.add_node(self.top_layer)
# Conv[-1] -> Fully
Connector.connect(self.conv_layers[-1].outputs.data,
self.top_layer.inputs.data)
# Label -> Fully
Connector.connect(self.inputs.label.output,
self.top_layer.inputs.label)
# Fully -> Reconstructed label
Connector.connect(self.top_layer.outputs.label,
self.outputs.reconstructed_label.input)
