acteval 0.1.0__py3-none-any.whl

acteval/density/features/frequency.py

@@ -0,0 +1,51 @@
+import numpy as np
+from numpy import arange, ndarray
+from pandas import DataFrame
+
+from acteval.density.features._discretise import descretise_population
+
+
+def count_schedules(population: DataFrame) -> int:
+    count = population.pid.nunique()
+    return {"all": (np.array([count]), np.array([1]))}
+
+
+def binned_activity_count(
+    population: DataFrame, class_map: dict, duration: int = 1440, step: int = 15
+) -> ndarray:
+    return descretise_population(
+        population, duration=duration, step_size=step, class_map=class_map
+    ).sum(0)[0, :, :]
+
+
+def binned_activity_density(
+    population: DataFrame, class_map: dict, duration: int = 1440, step: int = 15
+) -> ndarray:
+    return descretise_population(
+        population, duration=duration, step_size=step, class_map=class_map
+    ).mean(0)[0, :, :]
+
+
+def activity_frequencies(
+    population: DataFrame, duration: int = 1440, step: int = 15
+) -> dict[str, tuple[ndarray, ndarray]]:
+    index_to_acts = {i: a for i, a in enumerate(population.act.unique())}
+    class_map = {a: i for i, a in index_to_acts.items()}
+    bins = binned_activity_count(
+        population=population, class_map=class_map, duration=duration, step=step
+    )
+    support = arange(0, 1, step / duration)
+    freqs = {act: (support, bins[:, i]) for act, i in class_map.items()}
+    return freqs
+
+
+def activity_densities(
+    population: DataFrame, duration: int = 1440, step: int = 15
+) -> dict[str, tuple[ndarray, ndarray]]:
+    index_to_acts = {i: a for i, a in enumerate(population.act.unique())}
+    class_map = {a: i for i, a in index_to_acts.items()}
+    bins = binned_activity_density(
+        population=population, class_map=class_map, duration=duration, step=step
+    )
+    support = arange(0, 1, step / duration)
+    return {act: (support, bins[:, i]) for act, i in class_map.items()}

acteval/density/features/participation.py

@@ -0,0 +1,192 @@
+import numpy as np
+from numpy import array, ndarray
+
+from acteval.density.features.pid_features import PidFeatures
+from acteval.density.features.utils import (
+    _count_matrix,
+    weighted_features,
+)
+from acteval.population import Population
+
+
+def participation_prob_by_act(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    """Calculate the participations by activity for a given population.
+
+    Args:
+        population (Population): The population data.
+
+    Returns:
+        dict[str, tuple[array, array]]: A dictionary containing the participation for each activity.
+    """
+    matrix = population.count_matrix
+    participated = (matrix > 0).sum(axis=0)
+    n = population.n
+    return {
+        act: (array([0, 1]), array([n - participated[j], participated[j]]))
+        for j, act in enumerate(population.unique_acts)
+    }
+
+
+def participation_rates(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    return weighted_features({"all": population.pid_counts})
+
+
+def participation_rates_by_act(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    matrix = population.count_matrix
+    return weighted_features(
+        {act: matrix[:, j] for j, act in enumerate(population.unique_acts)}
+    )
+
+
+def participation_rates_by_seq_act(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    matrix, _, unique_keys = _count_matrix(population.pids, population.seq_key)
+    return weighted_features({k: matrix[:, j] for j, k in enumerate(unique_keys)})
+
+
+def participation_rates_by_act_enum(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    matrix, _, unique_keys = _count_matrix(population.pids, population.act_enum_key)
+    return weighted_features({k: matrix[:, j] for j, k in enumerate(unique_keys)})
+
+
+def calc_pair_prob(act_counts, pair):
+    a, b = pair
+    if a == b:
+        return (act_counts[a] > 1).sum()
+    return ((act_counts[a] > 0) & (act_counts[b] > 0)).sum()
+
+
+def calc_pair_rate(act_counts, pair):
+    a, b = pair
+    if a == b:
+        return ((act_counts[a] / 2).astype(int)).value_counts().to_dict()
+    return ((act_counts[[a, b]].min(axis=1) / 2).astype(int)).value_counts().to_dict()
+
+
+def combinations_with_replacement(
+    targets: list, length: int, prev_array=[]
+) -> list[list]:
+    """Returns all possible combinations of elements in the input array with replacement,
+    where each combination has a length of tuple_length.
+
+    Args:
+        targets (list): The input array to generate combinations from.
+        length (int): The length of each combination.
+        prev_array (list, optional): The previous array generated in the recursion. Defaults to [].
+
+    Returns:
+        list: A list of all possible combinations of elements in the input array with replacement.
+    """
+    if len(prev_array) == length:
+        return [prev_array]
+    combs = []
+    for i, val in enumerate(targets):
+        prev_array_extended = prev_array.copy()
+        prev_array_extended.append(val)
+        combs += combinations_with_replacement(targets[i:], length, prev_array_extended)
+    return combs
+
+
+def joint_participation_prob(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    """Calculate the participation prob for all pairs of activities in the given population.
+
+    Args:
+        population (Population): A Population containing the population data.
+
+    Returns:
+        dict: A dictionary containing the participation probability for all pairs of activities.
+    """
+    matrix = population.count_matrix
+    unique_acts = population.unique_acts
+    act_list = list(unique_acts)
+    act_idx = {a: i for i, a in enumerate(act_list)}
+    n = matrix.shape[0]
+    pairs = combinations_with_replacement(act_list, 2)
+    metric = {}
+    for pair in pairs:
+        ai, bi = act_idx[pair[0]], act_idx[pair[1]]
+        if pair[0] == pair[1]:
+            p = int((matrix[:, ai] > 1).sum())
+        else:
+            p = int(((matrix[:, ai] > 0) & (matrix[:, bi] > 0)).sum())
+        metric["+".join(pair)] = (array([0, 1]), array([n - p, p]))
+    return metric
+
+
+def joint_participation_rate(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    """Calculate the participation rate for all pairs of activities in the given population.
+
+    Args:
+        population (Population): A Population containing the population data.
+
+    Returns:
+        dict: A dictionary containing the participation rate for all pairs of activities.
+    """
+    matrix = population.count_matrix
+    unique_acts = population.unique_acts
+    act_list = list(unique_acts)
+    act_idx = {a: i for i, a in enumerate(act_list)}
+    pairs = combinations_with_replacement(act_list, 2)
+    metric = {}
+    for pair in pairs:
+        ai, bi = act_idx[pair[0]], act_idx[pair[1]]
+        if pair[0] == pair[1]:
+            vals = matrix[:, ai] // 2
+        else:
+            vals = np.minimum(matrix[:, ai], matrix[:, bi]) // 2
+        keys, counts = np.unique(vals, return_counts=True)
+        metric["+".join(pair)] = (keys, counts)
+    return metric
+
+
+# ---------------------------------------------------------------------------
+# Per-pid variants — return PidFeatures for efficient subsetting
+# ---------------------------------------------------------------------------
+
+
+def participation_rates_by_act_per_pid(
+    population: Population,
+) -> PidFeatures:
+    """Per-pid participation rates by activity.
+
+    Each key maps to ``(count_per_person, pids)`` where *pids* is shared
+    across all keys (the dense pid range).
+    """
+    matrix = population.count_matrix
+    pids = np.arange(population.n)
+    data = {act: (matrix[:, j], pids) for j, act in enumerate(population.unique_acts)}
+    return PidFeatures(data=data, bin_size=None, factor=1)
+
+
+def joint_participation_rate_per_pid(
+    population: Population,
+) -> PidFeatures:
+    """Per-pid joint participation rates for all activity pairs."""
+    matrix = population.count_matrix
+    unique_acts = population.unique_acts
+    act_list = list(unique_acts)
+    act_idx = {a: i for i, a in enumerate(act_list)}
+    pids = np.arange(population.n)
+    pairs = combinations_with_replacement(act_list, 2)
+    data = {}
+    for pair in pairs:
+        ai, bi = act_idx[pair[0]], act_idx[pair[1]]
+        if pair[0] == pair[1]:
+            vals = matrix[:, ai] // 2
+        else:
+            vals = np.minimum(matrix[:, ai], matrix[:, bi]) // 2
+        data["+".join(pair)] = (vals, pids)
+    return PidFeatures(data=data, bin_size=None, factor=1)

acteval/density/features/pid_features.py

@@ -0,0 +1,73 @@
+"""PidFeatures: pre-compression feature data with pid tracking for efficient subsetting."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+from numpy import ndarray
+
+from acteval.density.features.utils import compress_feature
+
+
+@dataclass
+class PidFeatures:
+    """Per-pid feature data that can be subset and aggregated.
+
+    Stores raw (pre-compression) values alongside pid arrays so that features
+    can be efficiently filtered to a subset of persons and then compressed
+    into the standard ``{key: (values, weights)}`` format.
+
+    Args:
+        data: ``{key: (values, pids)}`` where *values* is a 1-D (or 2-D)
+            array and *pids* is a same-length array of dense pid ints.
+        bin_size: Optional bin size forwarded to ``compress_feature``.
+        factor: Divisor forwarded to ``compress_feature``.
+    """
+
+    data: dict[str, tuple[ndarray, ndarray]]
+    bin_size: int | None = None
+    factor: int = 1
+
+    # Internal cache: maps ``id(pid_array)`` → mask for a given pid set,
+    # so that per-person features sharing one pid array compute the mask once.
+    _mask_cache: dict[int, ndarray] = field(default_factory=dict, repr=False)
+
+    def subset(self, pid_set: ndarray) -> PidFeatures:
+        """Return a new PidFeatures containing only values for *pid_set*.
+
+        Args:
+            pid_set: 1-D array of dense pid ints to keep.
+        """
+        pid_set_unique = np.unique(pid_set)
+        new_data: dict[str, tuple[ndarray, ndarray]] = {}
+        mask_cache: dict[int, ndarray] = {}
+
+        for key, (values, pids) in self.data.items():
+            pid_id = id(pids)
+            if pid_id not in mask_cache:
+                mask_cache[pid_id] = np.isin(pids, pid_set_unique)
+            mask = mask_cache[pid_id]
+            new_data[key] = (values[mask], pids[mask])
+
+        return PidFeatures(
+            data=new_data,
+            bin_size=self.bin_size,
+            factor=self.factor,
+        )
+
+    def aggregate(self) -> dict[str, tuple[ndarray, ndarray]]:
+        """Compress per-pid data into ``{key: (unique_values, counts)}``.
+
+        Produces identical output to the existing pipeline's
+        ``weighted_features`` / ``compress_feature`` calls.
+        """
+        result: dict[str, tuple[ndarray, ndarray]] = {}
+        for key, (values, _pids) in self.data.items():
+            if len(values) == 0:
+                result[key] = (np.array([]), np.array([], dtype=np.int64))
+            else:
+                result[key] = compress_feature(
+                    values, bin_size=self.bin_size, factor=self.factor
+                )
+        return result

acteval/density/features/times.py

@@ -0,0 +1,171 @@
+import numpy as np
+from numpy import array, ndarray
+
+from acteval.density.features.pid_features import PidFeatures
+from acteval.density.features.utils import (
+    _collect_by_group,
+    _collect_by_group_with_pids,
+    weighted_features,
+)
+from acteval.population import Population
+
+
+def start_times_by_act(
+    population: Population, bin_size: int = 15, factor: int = 1440
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = _collect_by_group(population.acts, population.starts)
+    return weighted_features(features, bin_size=bin_size, factor=factor)
+
+
+def end_times_by_act(
+    population: Population, bin_size: int = 15, factor: int = 1440
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = _collect_by_group(population.acts, population.ends)
+    return weighted_features(features, bin_size=bin_size, factor=factor)
+
+
+def durations_by_act(
+    population: Population, bin_size: int = 15, factor: int = 1440
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = _collect_by_group(population.acts, population.durations)
+    return weighted_features(features, bin_size=bin_size, factor=factor)
+
+
+def start_durations_by_act(population: Population) -> dict[str, ndarray]:
+    if population.is_empty:
+        return {a: array([]) for a in population.unique_acts}
+    pairs = np.column_stack([population.starts, population.durations])
+    return _collect_by_group(population.acts, pairs)
+
+
+def start_and_duration_by_act_bins(
+    population: Population, bin_size: int = 15, factor: int = 1440
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = start_durations_by_act(population)
+    return weighted_features(features, bin_size=bin_size, factor=factor)
+
+
+def joint_durations_by_act_bins(
+    population: Population, bin_size: int = 15, factor: int = 1440
+) -> dict[str, tuple[ndarray, ndarray]]:
+    if population.is_empty:
+        return {a: array([]) for a in population.unique_acts}
+    pids = population.pids
+    acts = population.acts.astype(str)
+    durations = population.durations.astype(float)
+
+    # Identify rows that are not the last in their pid group
+    same_pid_next = np.empty(len(pids), dtype=bool)
+    same_pid_next[:-1] = pids[:-1] == pids[1:]
+    same_pid_next[-1] = False
+
+    # For valid rows, pair current duration with next duration
+    valid_acts = acts[same_pid_next]
+    valid_durs = durations[same_pid_next]
+    next_durs = durations[1:][same_pid_next[:-1]]
+    valid_pairs = np.column_stack([valid_durs, next_durs])
+
+    features = _collect_by_group(valid_acts, valid_pairs)
+    return weighted_features(features, bin_size=bin_size, factor=factor)
+
+
+def start_times_by_act_plan_seq(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = _collect_by_group(population.seq_key, population.starts)
+    return weighted_features(features, factor=1440)
+
+
+def start_times_by_act_plan_enum(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = _collect_by_group(population.act_enum_key, population.starts)
+    return weighted_features(features, factor=1440)
+
+
+def end_times_by_act_plan_seq(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = _collect_by_group(population.seq_key, population.ends)
+    return weighted_features(features, factor=1440)
+
+
+def end_times_by_act_plan_enum(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = _collect_by_group(population.act_enum_key, population.ends)
+    return weighted_features(features, factor=1440)
+
+
+def durations_by_act_plan_seq(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = _collect_by_group(population.seq_key, population.durations)
+    return weighted_features(features, factor=1440)
+
+
+def durations_by_act_plan_enum(
+    population: Population,
+) -> dict[str, tuple[ndarray, ndarray]]:
+    features = _collect_by_group(population.act_enum_key, population.durations)
+    return weighted_features(features, factor=1440)
+
+
+# ---------------------------------------------------------------------------
+# Per-pid variants — return PidFeatures for efficient subsetting
+# ---------------------------------------------------------------------------
+
+
+def start_times_by_act_plan_enum_per_pid(
+    population: Population,
+) -> PidFeatures:
+    features = _collect_by_group_with_pids(
+        population.act_enum_key, population.starts, population.pids
+    )
+    return PidFeatures(data=features, bin_size=None, factor=1440)
+
+
+def durations_by_act_plan_enum_per_pid(
+    population: Population,
+) -> PidFeatures:
+    features = _collect_by_group_with_pids(
+        population.act_enum_key, population.durations, population.pids
+    )
+    return PidFeatures(data=features, bin_size=None, factor=1440)
+
+
+def start_and_duration_by_act_bins_per_pid(
+    population: Population,
+    bin_size: int = 15,
+    factor: int = 1440,
+) -> PidFeatures:
+    if population.is_empty:
+        return PidFeatures(data={}, bin_size=bin_size, factor=factor)
+    pairs = np.column_stack([population.starts, population.durations])
+    features = _collect_by_group_with_pids(population.acts, pairs, population.pids)
+    return PidFeatures(data=features, bin_size=bin_size, factor=factor)
+
+
+def joint_durations_by_act_bins_per_pid(
+    population: Population,
+    bin_size: int = 15,
+    factor: int = 1440,
+) -> PidFeatures:
+    if population.is_empty:
+        return PidFeatures(data={}, bin_size=bin_size, factor=factor)
+    pids = population.pids
+    acts = population.acts.astype(str)
+    durations = population.durations.astype(float)
+
+    same_pid_next = np.empty(len(pids), dtype=bool)
+    same_pid_next[:-1] = pids[:-1] == pids[1:]
+    same_pid_next[-1] = False
+
+    valid_acts = acts[same_pid_next]
+    valid_pids = pids[same_pid_next]
+    valid_durs = durations[same_pid_next]
+    next_durs = durations[1:][same_pid_next[:-1]]
+    valid_pairs = np.column_stack([valid_durs, next_durs])
+
+    features = _collect_by_group_with_pids(valid_acts, valid_pairs, valid_pids)
+    return PidFeatures(data=features, bin_size=bin_size, factor=factor)