amachine.am_create.am_random_structured_cyclic_composition

View Source

 1from ..am_hmm import HMM
 2from ..am_structured_symbol_set import StructuredSymbolSet
 3from .am_structured_isomorphic_permutations import structured_isomorphic_permutations
 4from .am_structured_composition import structured_composition
 5
 6import numpy as np
 7
 8def random_structured_cyclic_composition(
 9    composition_rigidity            : float,
10    instances_per_component         : int,
11    composition_connectivity_factor : float,
12    component_repetition_pentalty   : float,
13    component_residency_factor      : float,
14    component_sizes                 : list[int],
15    component_connectedness         : list[float],
16    component_randomness            : list[float],
17    symbol_set                      : StructuredSymbolSet,
18    end_of_component_symbols        : set[str],
19    composition_id                  : str | None = None, 
20    invariant_categories            : set[int] | None = None,
21    np_rng                          : np.random.Generator | None = None ) -> HMM : 
22
23    all_components : dict[str,list[am.HMM] ] = {}
24    component_instance_counts : dict[str,list[int]] = {}
25
26    for idx, component_size in enumerate( component_sizes ) :
27
28        total_orbit_size = symbol_set.cyclic_orbit_size( 
29            invariant_categories=invariant_categories
30        )
31
32        permutations, group_id = structured_isomorphic_permutations(
33            n_states=component_size,
34            symbol_set=symbol_set,
35            connectedness=component_connectedness[ idx ],
36            randomness=component_randomness[ idx ],
37            n_permutations=total_orbit_size,
38            permutation_group="cyclic_product",
39            selection_mode="sequential",
40            invariant_categories=invariant_categories,
41            np_rng=np_rng
42        )
43
44        all_components[ group_id ] = permutations
45
46        component_instance_counts[ group_id ] = [
47            instances_per_component for _ in all_components[ group_id ] 
48        ]
49
50    composition, connectors = structured_composition(
51        core_alphabet=symbol_set.symbols,
52        composition_rigidity=composition_rigidity,
53        component_groups=all_components,
54        instances_per_component=component_instance_counts,
55        component_residency_factor=component_residency_factor,
56        component_repetition_penalty=component_repetition_pentalty,
57        composition_connectivity_factor=composition_connectivity_factor,
58        instance_cohesion_randomness=0.2,
59        end_of_component_symbols=end_of_component_symbols,
60        symbol_cohesion=symbol_set.symbol_cohesion,
61        composition_id=composition_id,
62        np_rng=np_rng
63    )
64
65    return composition

def random_structured_cyclic_composition( composition_rigidity: float, instances_per_component: int, composition_connectivity_factor: float, component_repetition_pentalty: float, component_residency_factor: float, component_sizes: list[int], component_connectedness: list[float], component_randomness: list[float], symbol_set: amachine.am_structured_symbol_set.StructuredSymbolSet, end_of_component_symbols: set[str], composition_id: str | None = None, invariant_categories: set[int] | None = None, np_rng: numpy.random._generator.Generator | None = None) -> amachine.am_hmm.HMM: View Source

10def random_structured_cyclic_composition(
11    composition_rigidity            : float,
12    instances_per_component         : int,
13    composition_connectivity_factor : float,
14    component_repetition_pentalty   : float,
15    component_residency_factor      : float,
16    component_sizes                 : list[int],
17    component_connectedness         : list[float],
18    component_randomness            : list[float],
19    symbol_set                      : StructuredSymbolSet,
20    end_of_component_symbols        : set[str],
21    composition_id                  : str | None = None, 
22    invariant_categories            : set[int] | None = None,
23    np_rng                          : np.random.Generator | None = None ) -> HMM : 
24
25    all_components : dict[str,list[am.HMM] ] = {}
26    component_instance_counts : dict[str,list[int]] = {}
27
28    for idx, component_size in enumerate( component_sizes ) :
29
30        total_orbit_size = symbol_set.cyclic_orbit_size( 
31            invariant_categories=invariant_categories
32        )
33
34        permutations, group_id = structured_isomorphic_permutations(
35            n_states=component_size,
36            symbol_set=symbol_set,
37            connectedness=component_connectedness[ idx ],
38            randomness=component_randomness[ idx ],
39            n_permutations=total_orbit_size,
40            permutation_group="cyclic_product",
41            selection_mode="sequential",
42            invariant_categories=invariant_categories,
43            np_rng=np_rng
44        )
45
46        all_components[ group_id ] = permutations
47
48        component_instance_counts[ group_id ] = [
49            instances_per_component for _ in all_components[ group_id ] 
50        ]
51
52    composition, connectors = structured_composition(
53        core_alphabet=symbol_set.symbols,
54        composition_rigidity=composition_rigidity,
55        component_groups=all_components,
56        instances_per_component=component_instance_counts,
57        component_residency_factor=component_residency_factor,
58        component_repetition_penalty=component_repetition_pentalty,
59        composition_connectivity_factor=composition_connectivity_factor,
60        instance_cohesion_randomness=0.2,
61        end_of_component_symbols=end_of_component_symbols,
62        symbol_cohesion=symbol_set.symbol_cohesion,
63        composition_id=composition_id,
64        np_rng=np_rng
65    )
66
67    return composition