def __init__(self,
name: str,
weight: float,
classifier: AbstractClassifier,
activity_pattern: AbstractActivityPattern,
memory_space: AbstractMemorySpace,
corpus: Corpus,
self_influenced: bool,
enabled: bool = True):
super().__init__()
self.logger = logging.getLogger(__name__)
self.logger.debug(f"[__init__ Creating atom '{name}'.")
self.name = name
self._weight: Parameter = Parameter(weight, 0.0, None, 'float',
"Relative scaling of atom peaks.")
self._enabled: Parameter = ParamWithSetter(enabled, False, True,
"bool",
"Enables this Atom.",
self._set_enabled)
self._classifier: AbstractClassifier = classifier
self._memory_space: AbstractMemorySpace = memory_space
self._activity_pattern: AbstractActivityPattern = activity_pattern
self._self_influenced: Parameter = Parameter(
self_influenced, 0, 1, 'bool',
"Whether new events creates by player should influence this atom or not."
)
self._corpus: Optional[Corpus] = None
if corpus:
self.read_corpus(corpus)
self._parse_parameters()
def __init__(self, weight: float = 1.0, mu: float = DEFAULT_ENERGY, sigma: float = DEFAULT_SIGMA,
listening_mode: ListeningMode = ListeningMode.MANUAL, moving_average_len: int = DEFAULT_MA_LEN):
super().__init__()
self.listen_to: Parameter = ParamWithSetter(listening_mode, 0, 2, "int",
"listen to (manual=0, external=1, feedback=2)",
self._set_listening_mode)
self.moving_average_len: Parameter = Parameter(moving_average_len, 1, None, "int",
"num previous events to take into account if listening to input")
self._weight: Parameter = Parameter(weight, None, None, 'float', "Relative weight of filter")
self._mu: Parameter = ParamWithSetter(mu, None, None, 'float', "Mean value of gaussian.", self._set_mu)
self._sigma: Parameter = Parameter(sigma, None, None, 'float', "Standard deviation of gaussian")
self.history: deque[float] = deque([], self.moving_average_len.value)
def __init__(self, corpus: Corpus = None):
super().__init__(corpus)
self.logger.debug("[__init__]: ManualActivityPattern initialized.")
self.extinction_threshold: Parameter = Parameter(
0.1, 0.0, None, 'float', "Score below which peaks are removed")
self.tau_mem_decay: Parameter = ParamWithSetter(
self._calc_tau(self.DEFAULT_N), 1, None, "int",
"Number of updates until peak is decayed below threshold.",
self._set_tau)
self.default_score: Parameter = Parameter(
1.0, None, None, 'float', "Value of a new peaks upon creation.")
self._peaks: Peaks = Peaks.create_empty()
self.last_update_time: float = 0.0
self._event_indices: np.ndarray = np.zeros(0, dtype=np.int32)
self._parse_parameters()
def __init__(self, corpus: Optional[Corpus] = None):
super().__init__(corpus=corpus)
self.logger.debug("[__init__]: ManualActivityPattern initialized.")
self.default_score: Parameter = Parameter(
1.0, None, None, 'float', "Value of a new peaks upon creation.")
self._peaks: Peaks = Peaks.create_empty()
self._parse_parameters()
def __init__(self, factor: float = DEFAULT_FACTOR):
super().__init__()
self.logger = logging.getLogger(__name__)
self.logger.debug(f"[__init__] Creating {type(self).__name__} with factor {factor}.")
self._factor: Parameter = Parameter(factor, 0.0, None, 'float',
"Scaling factor for peaks close to previous output.")
self._previous_output_index: Optional[int] = None
def __init__(
self,
name: str,
peak_selector: AbstractPeakSelector = AbstractPeakSelector.default(),
merge_action: AbstractMergeAction = AbstractMergeAction.default(),
corpus: Optional[Corpus] = None,
scale_actions: List[AbstractScaleAction] = AbstractScaleAction.
default_set()):
super().__init__()
self.logger = logging.getLogger(__name__)
self.name: str = name
self._transform_handler: TransformHandler = TransformHandler()
self.peak_selector: AbstractPeakSelector = peak_selector
self.corpus: Optional[Corpus] = corpus
self.scale_actions: Dict[Type[AbstractScaleAction],
AbstractScaleAction] = {}
self.merge_action: AbstractMergeAction = merge_action
self.atoms: Dict[str, Atom] = {}
for scale_action in scale_actions:
self.add_scale_action(scale_action)
self.previous_peaks: Peaks = Peaks.create_empty()
self._transform_handler: TransformHandler = TransformHandler()
self._force_jump_index: Optional[int] = None
self.enabled: Parameter = Parameter(default_value=True,
min=False,
max=True,
type_str="bool",
description="Enables this Player.")
self._parse_parameters()
def __init__(self,
corpus: Corpus = None,
tau_mem_decay: float = DEFAULT_T):
super().__init__(corpus)
self.logger.debug("[__init__]: ClassicActivityPattern initialized.")
self.extinction_threshold: Parameter = Parameter(
0.1, 0.0, None, 'float', "Score below which peaks are removed")
# TODO: tau shouldn't be the parameter: t should
self.tau_mem_decay: Parameter = ParamWithSetter(
self._calc_tau(tau_mem_decay), 0, None, "float",
"Number of updates until peak is decayed below threshold.",
self._set_tau)
self.default_score: Parameter = Parameter(
1.0, None, None, 'float', "Value of a new peaks upon creation.")
self._peaks: Peaks = Peaks.create_empty()
self.last_update_time: float = 0.0
self._parse_parameters()
def __init__(self, t_width: float = 0.09):
super().__init__()
self.logger = logging.getLogger(__name__)
self.logger.debug(
f"[__init__] Creating DistanceMergeAction with width {t_width}.")
self._t_width: Parameter = Parameter(t_width, 0.0, None, 'float',
"Very unclear parameter") # TODO
self._parse_parameters()
def __init__(self, factor: float = DEFAULT_FACTOR):
super().__init__()
self.logger = logging.getLogger(__name__)
self._factor: Parameter = Parameter(factor, 0.0, None, 'float',
"Scaling factor for peaks not matching previous transform")
self._previous_transform: Optional[AbstractTransform] = None
# This will always be set immediately after adding transform to player and the
# Optional case should never have to be handled
self._transform_handler: Optional[TransformHandler] = None
def __init__(self):
super().__init__()
self.enabled: Parameter = Parameter(True, False, True, "bool", "Enables this ScaleAction.")
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.output_probability: Parameter = Parameter(
1.0, 0.0, 1.0, "float", "Probability to trigger output")
def __init__(self, threshold: float = DEFAULT_THRESHOLD, **kwargs):
super().__init__(**kwargs)
self._threshold: Parameter = Parameter(threshold, 0, None, "float",
"TODOOO")
def __init__(self, selectivity=DEFAULT_SELECTIVITY):
super().__init__()
self.logger = logging.getLogger(__name__)
self.logger.debug("[__init__] Creating PhaseMergeAction with selectivity {}".format(selectivity))
self._selectivity: Parameter = Parameter(selectivity, None, None, 'float', "Phase modulation") # TODO
self._parse_parameters()
def __init__(self):
super().__init__()
self._low_thresh: Parameter = Parameter(0, 0, 1.0, "float", "Fraction [0,1] marking start of region")
self._high_thresh: Parameter = Parameter(1.0, 0, 1.0, "float", "Fraction [0,1] marking end of region")
def __init__(self, mu: float = 0.0, sigma: float = 1.0):
super().__init__()
self._mu: Parameter = Parameter(mu, None, None, 'float', "Mean value of gaussian.")
self._sigma: Parameter = Parameter(sigma, None, None, 'float', "Standard deviation of gaussian")
def __init__(self, history_len: int = DEFAULT_NUM_EVENTS, sigma: float = DEFAULT_SIGMA):
super().__init__()
self._history_len: Parameter = Parameter(history_len, 1, None, "int", "TODO")
self._history: FeedbackQueue = FeedbackQueue(max_length=self._history_len.value)
self._sigma: Parameter = Parameter(sigma, None, None, 'float', "Standard deviation of gaussian")
def __init__(self, activation_threshold: int = DEFAULT_ACTIVATION_THRESHOLD,
jump_threshold: int = DEFAULT_JUMP_THRESHOLD):
super().__init__()
self._activation_threshold: Parameter = Parameter(activation_threshold, 1, None, "int", "TODO")
self._jump_threshold: Parameter = Parameter(jump_threshold, 1, None, "int", "TODO")
self._history: FeedbackQueue = FeedbackQueue()
