def tp_sequence_significance(self, source: SequenceSignificanceSource):
if self.flock_node._unit is None:
return None
process = self.flock_node._unit.flock.tp_flock.trained_forward_process
if process is None:
return None
if source == SequenceSignificanceSource.MODEL_FREQUENCY:
return self.tp_frequent_seq_occurrences()
if source == SequenceSignificanceSource.SEQ_LIKELIHOODS_ACTIVE:
tensor_getter = lambda _: process.seq_likelihoods_active
elif source == SequenceSignificanceSource.SEQ_LIKELIHOODS_CLUSTERS:
tensor_getter = lambda _: process.seq_likelihoods_clusters
elif source == SequenceSignificanceSource.SEQ_LIKELIHOODS_EXPLORATION:
tensor_getter = lambda _: process.seq_likelihoods_exploration
elif source == SequenceSignificanceSource.SEQ_LIKELIHOODS_GOAL_DIRECTED:
tensor_getter = lambda _: process.seq_rewards_goal_directed
elif source == SequenceSignificanceSource.SEQ_LIKELIHOODS_PRIORS_CLUSTERS:
tensor_getter = lambda _: process.seq_likelihoods_priors_clusters
elif source == SequenceSignificanceSource.SEQ_LIKELIHOODS_PRIORS_CLUSTERS_CONTEXT:
tensor_getter = lambda _: process.seq_likelihoods_priors_clusters_context
else:
raise IllegalArgumentException(
f'Unrecognized sequence significance source {source}')
tensor = FlockProcessObservable(self.flock_node.params.flock_size,
lambda: process,
tensor_getter).get_tensor()
return tensor[self.expert_id] if is_valid_tensor(tensor) else None
def get_data(self) -> BufferObserverData:
self._tensor = self.get_tensor()
if self._tensor is not None:
self._tensor = sanitize_tensor(self._tensor)
tensor, projection_params = self._tensor_view_projection.transform_tensor(
self._tensor, self._is_rgb)
self._update_scale_to_respect_minimum_size(tensor)
current_ptr = []
if self._buffer_memory_block.buffer is not None:
ptr_tensor = self._buffer_memory_block.buffer.current_ptr
if is_valid_tensor(ptr_tensor):
flock_size = ptr_tensor.numel()
buffer_size = math.floor(projection_params.count /
flock_size)
offsets = torch.arange(0,
buffer_size * flock_size,
buffer_size,
device=ptr_tensor.device)
current_ptr = ptr_tensor.add(offsets).to(
"cpu").numpy().tolist()
tensor_data = TensorObservableData(
tensor,
TensorObservableParams(scale=self._scale,
projection=projection_params))
result = BufferObserverData(tensor_data, current_ptr=current_ptr)
else:
result = BufferObserverData(dummy_tensor_observable_data(),
current_ptr=[0])
return result
def sp_execution_counter_learning(self):
tensor = self.sp_flock_node.memory_blocks.sp.execution_counter_learning.tensor
return tensor[self.expert_id, 0] if is_valid_tensor(tensor) else None
def sp_cluster_centers(self):
tensor = self.sp_flock_node.memory_blocks.sp.cluster_centers.tensor
if not is_valid_tensor(tensor):
return None
return tensor[self.expert_id]
def current_cluster_id(self) -> int:
tensor = self.sp_flock_node.outputs.sp.forward_clusters.tensor
if not is_valid_tensor(tensor):
return 0
tensor = tensor._base if tensor._base is not None else tensor
return tensor[self.expert_id].argmax().item()
def tp_frequent_seq_occurrences(self):
tensor = self.flock_node.memory_blocks.tp.frequent_seq_occurrences.tensor
return tensor[self.expert_id] if is_valid_tensor(tensor) else None
def sp_cluster_centers(self):
tensor = self.flock_node.memory_blocks.sp.cluster_centers.tensor
return tensor[self.expert_id] if is_valid_tensor(tensor) else None