compiled-knowledge 4.0.0a25__cp312-cp312-win_amd64.whl → 4.1.0__cp312-cp312-win_amd64.whl

ck/dataset/dataset_from_crosstable.py

@@ -0,0 +1,64 @@
+from typing import Sequence
+
+import numpy as np
+
+from ck.dataset import HardDataset, SoftDataset
+from ck.dataset.cross_table import CrossTable, cross_table_from_soft_dataset
+from ck.pgm import RandomVariable
+from ck.utils.np_extras import dtype_for_number_of_states
+
+
+def dataset_from_cross_table(cross_table: CrossTable) -> HardDataset:
+    """
+    Construct a HardDataset from the given cross-table.
+
+    Args:
+        cross_table: A cross-table represented as a dictionary.
+
+    Returns:
+        A dataset where instances and instance weights are those of the
+        given cross-table.
+
+    Ensures:
+        `result.total_weight() == dataset.total_weight()`.
+        Zero weighted instances are not counted.
+    """
+    rvs: Sequence[RandomVariable] = cross_table.rvs
+
+    # Unzip the cross-table dictionary
+    rvs_series = [[] for _ in range(len(rvs))]
+    weights = []
+    for instance, weight in cross_table.items():
+        for series, state in zip(rvs_series, instance):
+            series.append(state)
+        weights.append(weight)
+
+    # Put the hard dataset together
+    return HardDataset(
+        data=(
+            (rv, np.array(series, dtype=dtype_for_number_of_states(len(rv))))
+            for rv, series in zip(rvs, rvs_series)
+        ),
+        weights=np.array(weights, dtype=np.float64),
+    )
+
+
+def expand_soft_dataset(soft_dataset: SoftDataset) -> HardDataset:
+    """
+    Construct a hard dataset with the same data semantics as the given soft dataset
+    by expanding soft evidence.
+
+    Any state weights in `soft_dataset` that represents uncertainty over states
+    of a random variable will be converted to an equivalent set of weighted hard
+    instances. This means that the returned dataset may have a number of instances
+    different to that of the given soft dataset.
+
+    The ordering of instances in the returned dataset is not guaranteed.
+
+    This method works by constructing a cross-table from the given soft dataset,
+    then converting the crosstable to a hard dataset using `dataset_from_cross_table`.
+    This implies that the result will have no duplicated instances and no
+    instances with weight zero.
+    """
+    crosstab: CrossTable = cross_table_from_soft_dataset(soft_dataset)
+    return dataset_from_cross_table(crosstab)

ck/dataset/dataset_from_csv.py

@@ -0,0 +1,151 @@
+from typing import Iterable, List, Sequence, Optional
+
+from ck.dataset import HardDataset
+from ck.pgm import RandomVariable
+
+
+def hard_dataset_from_csv(
+        rvs: Iterable[RandomVariable],
+        lines: Iterable[str],
+        *,
+        weights: Optional[int | str] = None,
+        sep: Optional[str] = ',',
+        comment: str = '#',
+) -> HardDataset:
+    """
+    Interpret the given sequence of lines as CSV for a HardDataset.
+
+    Each line is a list of state indexes (ints) separated by `sep`.
+
+    Every line should have the same number of values.
+
+    If the first line contains a non-integer value, then the first
+    line will be interpreted as a header line.
+
+    If there is no header line, then the values will be interpreted in the
+    same order as `rvs` and the number of values on each line should be
+    the same as the number of random variables in `rvs`.
+
+    If there is a header line, then it will be interpreted as the order
+    of random variables. There must be a column name in the header to match
+    each name of the given random variables. Additional columns will be ignored.
+
+    Leading and trailing whitespace is ignored for each field, including header column names.
+
+    As text file (and StringIO) objects are iterable over lines, here is how to read a csv file:
+    ```
+        with open(csv_filename, 'r') as file:
+            hard_dataset_from_csv(rvs, file)
+    ```
+    Here is an example to read from a csv string:
+    ```
+        hard_dataset_from_csv(rvs, csv_string.splitlines())
+    ```
+
+    Args:
+        rvs: the random variables for the returned dataset.
+        lines: the sequence of lines to interpret, each line is an instance in the dataset.
+        weights: the column in the csv file holding instance weights. Can be either the
+            column number (counting from zero) or a column name (requires a header line).
+        sep: the string to use to separate values in a line, default is a comma.
+            If set to `None`, lines will be split on any consecutive run of whitespace characters
+            (including \n \r \t \f and spaces).
+        comment: text starting with this will be treated as a comment. Set to '' to disallow comments.
+
+    Returns:
+        a HardDataset.
+
+    Raises:
+        ValueError: if the lines do not conform to a CSV format.
+    """
+    rvs: Sequence[RandomVariable] = tuple(rvs)
+
+    # Define `clean_line` being sensitive to comments.
+    if len(comment) > 0:
+        def clean_line(l: str) -> str:
+            i = l.find(comment)
+            if i >= 0:
+                l = l[:i]
+            return l.strip()
+    else:
+        def clean_line(l: str) -> str:
+            return l.strip()
+
+    # Get the first line which may be a header line or data line
+    it = iter(lines)
+    try:
+        while True:
+            line = clean_line(next(it))
+            if len(line) > 0:
+                break
+    except StopIteration:
+        # Empty dataset with the given random variables
+        return HardDataset((rv, []) for rv in rvs)
+
+    values: List[str] = [value.strip() for value in line.split(sep)]
+    number_of_columns: int = len(values)
+    series: List[List[int]]  # series[dataset-column] = list of values
+    weight_series: Optional[List[float]] = None
+    column_map: List[int]  # column_map[dataset-column] = input-column
+    if all(_is_number(value) for value in values):
+        # First line is not a header line
+        if weights is None:
+            if number_of_columns != len(rvs):
+                raise ValueError('number of columns does not match number of random variables')
+            column_map = list(range(len(rvs)))
+        else:
+            if number_of_columns != len(rvs) + 1:
+                raise ValueError('number of columns does not match number of random variables and weight column')
+            if not isinstance(weights, int):
+                raise ValueError('no header detected - `weights` must be a column number')
+            if not (-number_of_columns <= weights < number_of_columns):
+                raise ValueError('`weights` column number out of range')
+            column_map = list(range(len(rvs) + 1))
+            column_map.pop(weights)
+
+        # Initialise series with the first line of data
+        series = [[int(values[i])] for i in column_map]
+        if weights is not None:
+            weight_series = [float(values[weights])]
+
+    else:
+        # First line is a header line
+        # Lookup each random variable to find its column
+        column_map = [
+            values.index(rv.name)  # will raise ValueError if not found
+            for rv in rvs
+        ]
+        if isinstance(weights, str):
+            # Convert weights column name to column number
+            weights: int = values.index(weights)  # will raise ValueError if not found
+        elif isinstance(weights, int) and not (number_of_columns <= weights < number_of_columns):
+            raise ValueError('`weights` column number out of range')
+
+        # Initialise each series as empty
+        series = [[] for _ in rvs]
+        if weights is not None:
+            weight_series = []
+
+    # Read remaining data lines
+    for line in it:
+        line = clean_line(line)
+        if len(line) == 0:
+            continue
+        if len(values) != number_of_columns:
+            raise ValueError('number of values does not match number of columns')
+        values = line.split(sep)
+        for series_i, i in zip(series, column_map):
+            series_i.append(int(values[i]))
+        if weights is not None:
+            weight_series.append(float(values[weights]))
+
+    # Construct the dataset
+    return HardDataset(zip(rvs, series), weights=weight_series)
+
+
+def _is_number(s: str) -> bool:
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False

ck/dataset/sampled_dataset.py

@@ -0,0 +1,96 @@
+import random
+from dataclasses import dataclass
+from typing import Sequence, List, Iterator, Tuple, Dict
+
+import numpy as np
+
+from ck.dataset import HardDataset
+from ck.dataset.cross_table import CrossTable
+from ck.pgm import RandomVariable, Instance
+from ck.sampling.sampler import Sampler
+from ck.utils.np_extras import dtype_for_number_of_states, NDArray
+from ck.utils.random_extras import Random
+
+
+def dataset_from_sampler(sampler: Sampler, length: int) -> HardDataset:
+    """
+    Create a hard dataset using samples from a sampler.
+
+    Args:
+        sampler: A sampler which defined the random variables and provides samples.
+        length: The length of the dataset to create.
+
+    Returns:
+        A HardDataset of the given length.
+    """
+    rvs: Sequence[RandomVariable] = sampler.rvs
+    columns: List[NDArray] = [
+        np.zeros(length, dtype=dtype_for_number_of_states(len(rv)))
+        for rv in rvs
+    ]
+    for i, instance in enumerate(sampler.take(length)):
+        for column, state in zip(columns, instance):
+            column[i] = state
+    return HardDataset(zip(rvs, columns))
+
+
+class CrossTableSampler(Sampler):
+    def __init__(self, crosstab: CrossTable, rand: Random = random):
+        """
+        Adapt a cross table to a sampler.
+
+        Instances will be drawn from the sampler according to their
+        weight in the given cross-table. If the given cross-table is
+        modified after constructing the sampler, the sampler will not
+        be affected.
+        """
+        if len(crosstab) == 0:
+            raise ValueError('no instances to sample')
+
+        super().__init__(rvs=crosstab.rvs, condition=())
+
+        # Group instances by weight.
+        # We do this in anticipation that it makes sampling more efficient.
+        weight_groups: Dict[float, _WeightGroup] = {}
+        for instance, weight in crosstab.items():
+            weight_group = weight_groups.get(weight)
+            if weight_group is None:
+                weight_groups[weight] = _WeightGroup(weight, weight, [instance])
+            else:
+                weight_group.append(instance)
+
+        self._weight_groups: List[_WeightGroup] = list(weight_groups.values())
+        self._total_weight = sum(group.total for group in weight_groups.values())
+        self._rand = rand
+
+    def __iter__(self) -> Iterator[Instance]:
+        while True:
+            # This code performs inverse transform sampling
+            r: float = self._rand.random() * self._total_weight
+
+            # This does a serial search to find the weight group.
+            # This is efficient for small numbers of groups, but this may be
+            # improved for large numbers of groups.
+            it = iter(self._weight_groups)
+            group = next(it)
+            while r >= group.total:
+                r -= group.total
+                group = next(it)
+
+            # Pick an instance in the group
+            i = int(r / group.weight)
+            yield group.instances[i]
+
+
+@dataclass
+class _WeightGroup:
+    """
+    Support for CrossTableSampler.
+    """
+    weight: float
+    total: float
+    instances: List[Tuple[int, ...]]
+
+    def append(self, instance: Tuple[int, ...]) -> None:
+        self.total += self.weight
+        self.instances.append(instance)