def get_average_log_delta_for(self, layer_id: int) -> float: """Supports getting deltas just for the layer 0""" assert layer_id <= len(self._group.conv_layers) if layer_id == len(self._group.conv_layers): expert = self._group.top_layer.sp_node else: expert = self._group.conv_layers[layer_id].expert_flock_nodes[0] if type(expert) is ExpertFlockNode or type( expert) is ConvExpertFlockNode: # turns out that the conv expert can have shape [2,2,num_cc] deltas = FlockNodeAccessor.get_sp_deltas(expert) elif type(expert) is SpatialPoolerFlockNode or type( expert) is ConvSpatialPoolerFlockNode: deltas = SpatialPoolerFlockNodeAccessor.get_sp_deltas(expert) else: logger.error("unsupported expert type!") return 0 delta = average_sp_delta(deltas) if delta > 0: # avoid math.domain error delta = math.log(delta) return delta
def get_average_log_delta_for(self, layer_id: int) -> float: expert = self._top_layer.sp_node deltas = SpatialPoolerFlockNodeAccessor.get_sp_deltas(expert) delta = average_sp_delta(deltas) if delta > 0: # avoid math.domain error delta = math.log(delta) return delta
def get_average_log_delta(self) -> float: """Supports getting deltas just for the layer 0""" delta = average_sp_delta( SpatialPoolerFlockNodeAccessor.get_sp_deltas(self.flock_node)) if delta > 0: # avoid math.domain error delta = math.log(delta) return delta
def clone_sp_output_tensor_for(self, layer_id: int) -> torch.Tensor: flock = self._get_flock(layer_id) flock_size = self.get_flock_size_of(layer_id) if type(flock) is ExpertFlockNode or type( flock) is ConvExpertFlockNode: # turns out that the conv expert can have shape [2,2,num_cc] return FlockNodeAccessor.get_sp_output_tensor(flock).clone().view( flock_size, -1) if type(flock) is SpatialPoolerFlockNode or type( flock) is ConvSpatialPoolerFlockNode: return SpatialPoolerFlockNodeAccessor.get_output_tensor( flock).clone().view(flock_size, -1) logger.error(f'unsupported flock class type')
def test_sp_flock_node_accessor_types_and_dimensions(): device = 'cuda' # CPU not supported by SPFlock upper_bound = 107 flock_input_size = upper_bound flock_size = 1 num_cc = 21 # define params sp_params = MnistSpTopology.get_sp_params(num_cluster_centers=num_cc, cluster_boost_threshold=1000, learning_rate=0.1, buffer_size=2 * 30, batch_size=30, input_size=flock_input_size, flock_size=flock_size, max_boost_time=1500) # random_node -> unsqueeze_node, sp_flock random_node = RandomNumberNode(upper_bound=upper_bound) unsqueeze_node = UnsqueezeNode(0) sp_node = SpatialPoolerFlockNode(sp_params.clone()) Connector.connect(random_node.outputs.one_hot_output, unsqueeze_node.inputs.input) Connector.connect(unsqueeze_node.outputs.output, sp_node.inputs.sp.data_input) # update dimensions creator = AllocatingCreator(device=device) random_node.allocate_memory_blocks(creator) unsqueeze_node.allocate_memory_blocks(creator) sp_node.allocate_memory_blocks(creator) # make step random_node.step() unsqueeze_node.step() sp_node.step() # collect the results reconstruction = SpatialPoolerFlockNodeAccessor.get_reconstruction(sp_node) deltas = SpatialPoolerFlockNodeAccessor.get_sp_deltas(sp_node) boosting_durations = SpatialPoolerFlockNodeAccessor.get_sp_boosting_durations( sp_node) output_id = SpatialPoolerFlockNodeAccessor.get_output_id(sp_node) # check result properties assert type(reconstruction) is torch.Tensor assert type(deltas) is torch.Tensor assert type(boosting_durations) is torch.Tensor assert type(output_id) is int assert reconstruction.shape == (flock_size, flock_input_size) assert deltas.shape == (flock_size, num_cc, flock_input_size) assert boosting_durations.shape == (flock_size, num_cc) assert 0 <= output_id < num_cc # test the sp metrics delta = average_sp_delta(deltas) boosting_dur = average_boosting_duration(boosting_durations) nbc = num_boosted_clusters(boosting_durations) assert type(delta) is float assert type(boosting_dur) is float assert 0 <= boosting_dur <= 1000 assert type(nbc) is float assert 0 <= nbc <= 1
def sp_output_tensor(self) -> torch.Tensor: return SpatialPoolerFlockNodeAccessor.get_output_tensor( self.flock_node)
def get_average_boosting_duration(self) -> float: return average_boosting_duration( SpatialPoolerFlockNodeAccessor.get_sp_boosting_durations( self.flock_node))
def get_average_delta(self) -> float: delta = average_sp_delta( SpatialPoolerFlockNodeAccessor.get_sp_deltas(self._sp)) if delta > 0: # avoid math.domain error delta = math.log(delta) return delta
def get_learned_model_output_id(self) -> int: return SpatialPoolerFlockNodeAccessor.get_output_id(self._sp)