compiled-knowledge 4.1.0a1__cp312-cp312-win_amd64.whl → 4.1.0a2__cp312-cp312-win_amd64.whl

ck/dataset/dataset_builder.py

@@ -0,0 +1,512 @@
+from __future__ import annotations
+
+from itertools import count
+from typing import Iterable, List, TypeAlias, Sequence, overload, Set, Tuple, MutableSequence, Dict, Optional, \
+    assert_never
+
+import numpy as np
+
+from ck.dataset import HardDataset, SoftDataset
+from ck.pgm import RandomVariable, State
+from ck.utils.np_extras import NDArrayFloat64, NDArrayStates, dtype_for_number_of_states, DTypeStates, NDArrayNumeric
+
+HardValue: TypeAlias = int
+SoftValue: TypeAlias = Sequence[float]
+Value: TypeAlias = HardValue | SoftValue | None
+
+
+class Record(Sequence[Value]):
+    """
+    A record is a sequence of values, co-indexed with dataset columns.
+
+    A value is either a state index (HardValue), a sequence of state
+    weights (SoftValue), or missing (None).
+    """
+
+    def __init__(self, dataset: DatasetBuilder, values: Optional[Iterable[Value]] = None):
+        self.weight: float = 1
+        self._dataset: DatasetBuilder = dataset
+        self._values: List[Value] = [] if values is None else list(values)
+
+    def __len__(self) -> int:
+        return len(self._dataset.rvs)
+
+    @overload
+    def __getitem__(self, index: int | RandomVariable) -> Value:
+        ...
+
+    @overload
+    def __getitem__(self, index: slice) -> Sequence[Value]:
+        ...
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            return [self._getitem(i) for i in range(*index.indices(len(self)))]
+        if isinstance(index, RandomVariable):
+            # noinspection PyProtectedMember
+            return self._getitem(self._dataset._rvs_index[index])
+
+        size = len(self)
+        if index < 0:
+            index += size
+        if not 0 <= index < size:
+            raise IndexError('index out of range')
+        return self._getitem(index)
+
+    def _getitem(self, index: int) -> Value:
+        """
+        Assumes:
+            0 <= index < len(self).
+        """
+        if index >= len(self._values):
+            return None
+        return self._values[index]
+
+    @overload
+    def __setitem__(self, index: int | RandomVariable, value: Value) -> None:
+        ...
+
+    @overload
+    def __setitem__(self, index: slice, value: Iterable[Value]) -> None:
+        ...
+
+    def __setitem__(self, index, value):
+        if isinstance(index, slice):
+            for i, v in zip(range(*index.indices(len(self))), value):
+                self._setitem(i, v)
+            return
+        if isinstance(index, RandomVariable):
+            # noinspection PyProtectedMember
+            self._setitem(self._dataset._rvs_index[index], value)
+            return
+
+        size = len(self)
+        if index < 0:
+            index += size
+        if not 0 <= index < size:
+            raise IndexError('index out of range')
+        self._setitem(index, value)
+
+    def _setitem(self, index: int, value: Value) -> None:
+        """
+        Assumes:
+            0 <= index < len(self).
+        """
+        to_append: int = index + 1 - len(self._values)
+        self._values += [None] * to_append
+
+        if value is None:
+            self._values[index] = None
+            return
+
+        rv: RandomVariable = self._dataset.rvs[index]
+        if isinstance(value, int):
+            if not (0 <= value < len(rv)):
+                raise ValueError(f'state index out of range, expected: 0 <= {value!r} < {len(rv)}')
+            self._values[index] = value
+            return
+
+        # Expect the value is a sequence of floats
+        if len(value) != len(rv):
+            raise ValueError(f'state weights incorrect length, expected: {len(rv)}, got: {len(value)}')
+        self._values[index] = tuple(value)
+
+    def set(self, *values: Value) -> None:
+        """
+        Set all the values of this record, using state indexes or state weights.
+
+        If insufficient or additional values are provided, a ValueError will be raised.
+        """
+        if len(values) != len(self):
+            raise ValueError('incorrect number of values provided')
+        for i, value in enumerate(values):
+            self._setitem(i, value)
+
+    def set_states(self, *values: State) -> None:
+        """
+        Set all the values of this record from random variable states.
+
+        State indexes are resolved using `RandomVariable.state_idx`.
+        If insufficient or additional values are provided, a ValueError will be raised.
+        """
+        rvs = self._dataset.rvs
+        if len(values) != len(rvs):
+            raise ValueError('incorrect number of values provided')
+        for i, rv, value in zip(count(), rvs, values):
+            self._setitem(i, rv.state_idx(value))
+
+    def __str__(self) -> str:
+        return self.to_str()
+
+    def to_str(
+            self,
+            *,
+            show_weight: bool = True,
+            as_states: bool = False,
+            missing: str = 'None',
+            sep: str = ', ',
+    ) -> str:
+        """
+        Render the record as a human-readable string.
+        If as_states is true, then hard values states are dumped instead of just state indexes.
+
+        Args:
+            show_weight: If `True`, the instance weight is included.
+            as_states: If `True`, the states are used instead of just state indexes.
+            missing: the string to use for missing values.
+            sep: the string to use for separating values.
+        """
+
+        def _value_str(rv_idx: int, v: Value) -> str:
+            if v is None:
+                return missing
+            if isinstance(v, int):
+                if as_states:
+                    return repr(self._dataset.rvs[rv_idx].states[v])
+                else:
+                    return str(v)
+            else:
+                return str(v)
+
+        instance_str = sep.join(_value_str(i, self._getitem(i)) for i in range(len(self)))
+        if show_weight:
+            return f'({instance_str}) * {self.weight}'
+        else:
+            return f'({instance_str})'
+
+
+class DatasetBuilder(Sequence[Record]):
+    """
+    A dataset builder can be used for making a hard or soft dataset, incrementally growing
+    the dataset as needed. This represents a flexible but inefficient interim representation of data.
+    """
+
+    def __init__(self, rvs: Iterable[RandomVariable] = ()):
+        """
+        Args:
+            rvs: Optional random variables to include in the dataset. Default is no random variables.
+        """
+        self._rvs: Tuple[RandomVariable, ...] = ()
+        self._rvs_index: Dict[RandomVariable, int] = {}
+        self._records: List[Record] = []
+        self.new_column(*rvs)
+
+    @property
+    def rvs(self) -> Sequence[RandomVariable]:
+        return self._rvs
+
+    def new_column(self, *rv: RandomVariable) -> None:
+        """
+        Adds one, or more, new random variables to the dataset. For existing rows,
+        value for the new random variable will be `None`.
+
+        Args:
+            rv: a new random variable to include in the dataset.
+
+        Raises:
+            ValueError: if the given random variable already exists in the dataset.
+        """
+        # Do all consistency checks first to fail early, before modifying the dataset.
+        rvs_to_add: Set[RandomVariable] = set(rv)
+        if len(rvs_to_add) != len(rv):
+            raise ValueError(f'request to add a column includes duplicates')
+        duplicate_rvs: Set[RandomVariable] = rvs_to_add.intersection(self._rvs_index.keys())
+        if len(duplicate_rvs) > 0:
+            duplicate_rv_names = ', '.join(rv.name for rv in duplicate_rvs)
+            raise ValueError(f'column already exists in the dataset: {duplicate_rv_names}')
+
+        for rv in rvs_to_add:
+            self._rvs_index[rv] = len(self._rvs)
+            self._rvs += (rv,)
+
+    def ensure_column(self, *rv: RandomVariable) -> None:
+        """
+        Add a column for one, or more, random variables, only
+        adding a random variable if it is not already present in the dataset.
+        """
+        all_rvs = self._rvs_index.keys()
+        self.new_column(*(_rv for _rv in rv if _rv not in all_rvs))
+
+    def del_column(self, *rv: RandomVariable) -> None:
+        """
+        Delete one, or more, random variables from the dataset.
+
+        Args:
+            rv: a random variable to remove from the dataset.
+
+        Raises:
+            ValueError: if the given random variable does not exist in the dataset.
+        """
+        # Do all consistency checks first to fail early, before modifying the dataset.
+        rvs_to_del: Set[RandomVariable] = set(rv)
+        if len(rvs_to_del) != len(rv):
+            raise ValueError(f'request to delete a column includes duplicates')
+        missing_columns = rvs_to_del.difference(self._rvs_index.keys())
+        if len(missing_columns) > 0:
+            missing_rv_names = ', '.join(rv.name for rv in missing_columns)
+            raise ValueError(f'missing columns: {missing_rv_names}')
+
+        # Get column indices to remove, in descending order
+        indices = sorted((self._rvs_index[rv] for rv in rvs_to_del), reverse=True)
+
+        # Remove from the index
+        for rv in rvs_to_del:
+            self._rvs_index.pop(rv)
+
+        # Remove from column sequence
+        rvs_list: List[RandomVariable] = list(self._rvs)
+        for i in indices:
+            rvs_list.pop(i)
+        self._rvs = tuple(rvs_list)
+
+        # Remove from records
+        for record in self._records:
+            # noinspection PyProtectedMember
+            record_values: List[Value] = record._values
+            for i in indices:
+                if i < len(record_values):
+                    record_values.pop(i)
+
+    def total_weight(self) -> float:
+        """
+        Calculate the total weight of this dataset.
+        """
+        return sum(record.weight for record in self._records)
+
+    def get_weights(self) -> NDArrayFloat64:
+        """
+        Allocate and return a 1D numpy array of instance weights.
+
+        Ensures:
+            shape of the result == `(len(self), )`.
+        """
+        result: NDArrayStates = np.fromiter(
+            (record.weight for record in self._records),
+            count=len(self._records),
+            dtype=np.float64,
+        )
+        return result
+
+    def get_column_hard(self, rv: RandomVariable, *, missing: Optional[int] = None) -> NDArrayStates:
+        """
+        Allocate and return a 1D numpy array of state indexes.
+
+        Args:
+            rv: a random variable in this dataset.
+            missing: the value to use in the result to represent missing values. If not provided,
+                then the default missing value is len(rv), which is an invalid state index.
+
+        Raises:
+            ValueError: if the supplied missing value is negative.
+
+        Ensures:
+            shape of the result == `(len(self), )`.
+        """
+        index: int = self._rvs_index[rv]
+        if missing is None:
+            missing = len(rv)
+        if missing < 0:
+            raise ValueError(f'missing value must be >= 0')
+        number_of_states = max(len(rv), missing + 1)
+        dtype: DTypeStates = dtype_for_number_of_states(number_of_states)
+        result: NDArrayStates = np.fromiter(
+            (_get_state(record[index], missing) for record in self._records),
+            count=len(self._records),
+            dtype=dtype,
+        )
+        return result
+
+    def get_column_soft(self, rv: RandomVariable, *, missing: float | Sequence[float] = np.nan) -> NDArrayFloat64:
+        """
+        Allocate and return a numpy array of state weights.
+
+        Args:
+            rv: a random variable in this dataset.
+            missing: the value to use in the result to represent missing values. Default is all NaN.
+
+        Ensures:
+            shape of the result == `(len(self), len(rv))`.
+        """
+        index: int = self._rvs_index[rv]
+        size: int = len(rv)
+
+        if isinstance(missing, (float, int)):
+            missing_weights: NDArrayFloat64 = np.array([missing] * size, dtype=np.float64)
+        else:
+            missing_weights: NDArrayFloat64 = np.array(missing, dtype=np.float64)
+            if missing_weights.shape != (size,):
+                raise ValueError(f'missing weights shape expected {(size,)}, but got {missing_weights.shape}')
+
+        result: NDArrayFloat64 = np.empty(shape=(len(self._records), size), dtype=np.float64)
+        for i, record in enumerate(self._records):
+            result[i, :] = _get_state_weights(size, record[index], missing_weights)
+        return result
+
+    def append(self, *values: Value) -> Record:
+        """
+        Appends a new record to the dataset.
+
+        Args:
+            values: the new record to append. If omitted, a new record will be created
+                with all values missing (`None`).
+
+        Returns:
+            the new record.
+        """
+        record = Record(self, values)
+        self._records.append(record)
+        return record
+
+    def insert(self, index: int, values: Optional[Iterable[Value]] = None) -> Record:
+        """
+        Inserts a new record to the dataset at the given index.
+
+        Args:
+            index: where to insert the record (interpreted as per builtin `list.insert`).
+            values: the new record to append. If omitted, a new record will be created
+                with all values missing (`None`).
+
+        Returns:
+            the new record.
+        """
+        record = Record(self, values)
+        self._records.insert(index, record)
+        return record
+
+    def append_dataset(self, dataset: HardDataset | SoftDataset) -> None:
+        """
+        Append all the records of the given dataset to this dataset builder.
+
+        Args:
+            dataset: the dataset of records to append.
+
+        Raises:
+            KeyError: if `dataset.rvs` is not a superset of `this.rvs`.
+        """
+        if isinstance(dataset, HardDataset):
+            cols: Tuple = tuple(dataset.state_idxs(rv).tolist() for rv in self.rvs)
+        elif isinstance(dataset, SoftDataset):
+            cols: Tuple = tuple(dataset.state_weights(rv) for rv in self.rvs)
+        else:
+            assert_never('not reached')
+        weights: NDArrayNumeric = dataset.weights
+        for weight, vals in zip(weights, zip(*cols)):
+            self.append(*vals).weight = weight
+
+    @overload
+    def __getitem__(self, index: int) -> Record:
+        ...
+
+    @overload
+    def __getitem__(self, index: slice) -> MutableSequence[Record]:
+        ...
+
+    def __getitem__(self, index):
+        return self._records[index]
+
+    def __delitem__(self, index: int | slice) -> None:
+        del self._records[index]
+
+    def __len__(self) -> int:
+        return len(self._records)
+
+    def dump(
+            self,
+            *,
+            show_rvs: bool = True,
+            show_weights: bool = True,
+            as_states: bool = False,
+            missing: str = 'None',
+            sep: str = ', ',
+    ) -> None:
+        """
+        Dump the dataset in a human-readable format.
+        If as_states is true, then hard values states are dumped instead of just state indexes.
+
+        Args:
+            show_rvs: If `True`, the random variables are dumped.
+            show_weights: If `True`, the instance weights are dumped.
+            as_states: If `True`, the states are dumped instead of just state indexes.
+            missing: the string to use for missing values.
+            sep: the string to use for separating values.
+        """
+        if show_rvs:
+            rvs = ', '.join(str(rv) for rv in self.rvs)
+            print(f'rvs: [{rvs}]')
+        print(f'instances ({len(self)}, with total weight {self.total_weight()}):')
+        for record in self._records:
+            print(record.to_str(show_weight=show_weights, as_states=as_states, missing=missing, sep=sep))
+
+
+def hard_dataset_from_builder(dataset_builder: DatasetBuilder, *, missing: Optional[int] = None) -> HardDataset:
+    """
+    Create a hard dataset from a soft dataset by repeated application
+    of `HardDataset.add_rv_from_state_idxs`.
+
+    The instance weights of the returned dataset will be a copy
+    of the instance weights of the soft dataset.
+
+    No adjustments are made to the resulting dataset weights, even if
+    a value in the dataset builder is soft evidence that does not sum to
+    one.
+
+    Args:
+        dataset_builder: The dataset builder providing random variables,
+            their states, and instance weights.
+        missing: the value to use in the result to represent missing values. If not provided,
+            then the default missing value is len(rv) for each rv, which is an invalid state index.
+
+    Returns:
+        A `HardDataset` instance.
+    """
+    dataset = HardDataset(weights=dataset_builder.get_weights())
+    for rv in dataset_builder.rvs:
+        dataset.add_rv_from_state_idxs(rv, dataset_builder.get_column_hard(rv, missing=missing))
+    return dataset
+
+
+def soft_dataset_from_builder(
+        dataset_builder: DatasetBuilder,
+        *,
+        missing: float | Sequence[float] = np.nan,
+) -> SoftDataset:
+    """
+    Create a soft dataset from a hard dataset by repeated application
+    of `SoftDataset.add_rv_from_state_idxs`.
+
+    The instance weights of the returned dataset will be a copy
+    of the instance weights of the hard dataset.
+
+    Args:
+        dataset_builder: The dataset builder providing random variables,
+            their state weights, and instance weights.
+        missing: the value to use in the result to represent missing values.
+            If a single float is provided, all state weights will have that value. Alternatively,
+            a sequence of state weights can be provided, but all random variables will need
+            to be the same size. Default is all state weights set to NaN.
+
+    Returns:
+        A `SoftDataset` instance.
+    """
+    dataset = SoftDataset(weights=dataset_builder.get_weights())
+    for rv in dataset_builder.rvs:
+        dataset.add_rv_from_state_weights(rv, dataset_builder.get_column_soft(rv, missing=missing))
+    return dataset
+
+
+def _get_state(value: Value, missing: int) -> int:
+    if value is None:
+        return missing
+    if isinstance(value, int):
+        return value
+    return np.argmax(value).item()
+
+
+def _get_state_weights(size: int, value: Value, missing: Sequence[float]) -> Sequence[float]:
+    if value is None:
+        return missing
+    if isinstance(value, int):
+        result = np.zeros(size, dtype=np.float64)
+        result[value] = 1
+        return result
+    return value

ck/dataset/dataset_from_csv.py

@@ -9,7 +9,7 @@ def hard_dataset_from_csv(
         lines: Iterable[str],
         *,
         weights: Optional[int | str] = None,
-        sep: str = ',',
+        sep: Optional[str] = ',',
         comment: str = '#',
 ) -> HardDataset:
     """
@@ -30,6 +30,8 @@ def hard_dataset_from_csv(
     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:
@@ -46,6 +48,8 @@ def hard_dataset_from_csv(
         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:

ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c

@@ -13,7 +13,7 @@
             "/O2"
         ],
         "include_dirs": [
-            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-qw5_jlkb\\Lib\\site-packages\\numpy\\_core\\include"
+            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-zvpv36cx\\Lib\\site-packages\\numpy\\_core\\include"
         ],
         "name": "ck.pgm_compiler.support.circuit_table._circuit_table_cy",
         "sources": [

ck_demos/dataset/demo_dataset_builder.py

@@ -0,0 +1,37 @@
+from ck.dataset import HardDataset, SoftDataset
+from ck.dataset.dataset_builder import DatasetBuilder, soft_dataset_from_builder, hard_dataset_from_builder
+from ck.pgm import PGM
+
+
+def main() -> None:
+    pgm = PGM()
+    x = pgm.new_rv('x', (True, False))
+    y = pgm.new_rv('y', ('yes', 'no', 'maybe'))
+
+    builder = DatasetBuilder([x, y])
+    builder.append()
+    builder.append(1, 2).weight = 3
+    builder.append(None, [0.7, 0.1, 0.2])
+    builder.append().set_states(True, 'maybe')
+
+    print('DatasetBuilder dump')
+    builder.dump()
+    print()
+
+    print('DatasetBuilder dump, showing states and custom missing values')
+    builder.dump(as_states=True, missing='?')
+    print()
+
+    print('HardDataset dump')
+    dataset: HardDataset = hard_dataset_from_builder(builder, missing=99)
+    dataset.dump()
+    print()
+
+    print('SoftDataset dump')
+    dataset: SoftDataset = soft_dataset_from_builder(builder)
+    dataset.dump()
+    print()
+
+
+if __name__ == '__main__':
+    main()

{compiled_knowledge-4.1.0a1.dist-info → compiled_knowledge-4.1.0a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.1.0a1
+Version: 4.1.0a2
 Summary: A Python package for compiling and querying discrete probabilistic graphical models.
 Author-email: Barry Drake <barry@compiledknowledge.org>
 License-Expression: MIT

{compiled_knowledge-4.1.0a1.dist-info → compiled_knowledge-4.1.0a2.dist-info}/RECORD

@@ -1,8 +1,8 @@
 ck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm.py,sha256=DXI3RZWBlk6wNj9VlAEDGeEUQ1WIpQwojVAt231K-Co,121095
 ck/circuit/__init__.py,sha256=klUR7OVESf53-8Ho4f32clHFsR2SOz4XgwZzfDlms88,418
-ck/circuit/_circuit_cy.c,sha256=F2S4BB48_dFPkcemz98GgDy6MPuiUBZ55ag--ZHIQjA,1741715
-ck/circuit/_circuit_cy.cp312-win_amd64.pyd,sha256=jAVF2AWMadeWwDhR8XhVaLEWq9WWfESW1emfWzgnl3E,242688
+ck/circuit/_circuit_cy.c,sha256=bEZxHMg02hky24K05HBdsLCHl8n-z6btIx5v-3q6nBE,1741715
+ck/circuit/_circuit_cy.cp312-win_amd64.pyd,sha256=k1pLiEcGqusMBordd72JgCMf2MYSEdrgrSg6TEofuYA,242688
 ck/circuit/_circuit_cy.pxd,sha256=F1WU4KuX_knXQX-hwNKoHsoUK3fJLbLOxEnomWMJFpI,1057
 ck/circuit/_circuit_cy.pyx,sha256=TIjqsdyN_IzOm9XQw26kEURpL6GSL1kJO3K-UUlkbQc,27763
 ck/circuit/_circuit_py.py,sha256=gQZoEphxut2UyBL0ZqmNc8KlNBSMST_VOCqOpDMIRSM,28331
@@ -14,25 +14,26 @@ ck/circuit_compiler/llvm_compiler.py,sha256=6RHUCVWCOgt3ZNyjRTl2Z2npYJMWyAFJVAIc
 ck/circuit_compiler/llvm_vm_compiler.py,sha256=XJhiAZmGMRRz49XUfng9lgETxVw6NgD6XCI0H3fX-1E,22200
 ck/circuit_compiler/named_circuit_compilers.py,sha256=snlD3JnhAZC-atKpf5GD0v4CGdvj2_ZhCZ3O-tsxzxc,2284
 ck/circuit_compiler/cython_vm_compiler/__init__.py,sha256=pEAwTleuZgdYhTAQMea2f9YsFK54eoNbZSbrWkW8aeE,49
-ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=ps__1F2ullSqtYiqJTzOyRL6a58H2SwxF3BuRjzMnNc,871325
-ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=AjAOgp8yLv9s8p2TqFao6vu_Qh89ZLbcHT7DudvpDlI,103936
+ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=HRZKcv1K8sCrRDPMgsbQuZYmmzmxtUjX7c8Y0Pi4aYw,871325
+ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=Ie7z7m05E59XoBbyBf2GVNKXgbgYcHR27wMcCpCoals,103936
 ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=550r0AkOh8ZuuTRy3e6Aq-YqBQ82EKcap8e6f3zlEuM,13278
 ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py,sha256=3Q-HCyA7VWFoXS9gn-k4LXedzqHPvdFNvWHfDcKYv6s,4473
 ck/circuit_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/circuit_compiler/support/input_vars.py,sha256=x6krN6sW9A-vZTteY4M4on_0vS4ChaaCcmnXcnQ4y0s,4812
 ck/circuit_compiler/support/llvm_ir_function.py,sha256=07IUmx4bGReDu-BsUhJEWM_onm8NmsHwQzJan1rnAFE,8572
 ck/circuit_compiler/support/circuit_analyser/__init__.py,sha256=RbyIObAAb-w0Ky4fB198xAfxTh2doquN9ez68SZSZgo,536
-ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c,sha256=NaGjKozPtkX4MlLkl9iZa2SaEXIXiQLuYcXurNV6EFQ,448751
-ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.cp312-win_amd64.pyd,sha256=n1ReonEKFgSI_urpp5FOejaicSEx42KUczPcR4K8GPg,54272
+ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c,sha256=Z_i7EFoOaeztsOJK2iuUPJe6BVUGylcIXyn3WCxFBR0,448751
+ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.cp312-win_amd64.pyd,sha256=p4b31PxmdYPJEMn6eJlOaOV4nbM1KMlL4q-ItwJem2E,54272
 ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.pyx,sha256=ctDOHOjnUhdsR_XHBrgchFVTImLhsEUjU3cqkP-GdF8,3331
 ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_py.py,sha256=eWjc2B946LeSzcGa9PyI4XQvlx_B1KPEiQuM6OOFjjQ,3086
 ck/dataset/__init__.py,sha256=3vxB-b8LdgtoZ73q28sdPYPUbCbXARH-fNGUZcxIzIo,56
-ck/dataset/cross_table.py,sha256=tLXbfONstheQdhMK0VfFa9fBxFOC-5jwW0v7mgNFUF0,9744
+ck/dataset/cross_table.py,sha256=D8Y0WpISouAkMnt0j8bs4Csw_MhxT6h4eUucaQQOkmw,9745
 ck/dataset/cross_table_probabilities.py,sha256=U7LlmWUc_Ow6CVEk_6CLK0p2g8GlRpHEGPZFXrV8tmI,1997
-ck/dataset/dataset.py,sha256=EC9ynRP4pCFWmeB8B6zEmPh_3c2jP3K37AnincBZc34,21698
+ck/dataset/dataset.py,sha256=fGxjEqv9qfdEq8s1ph8B_ptFftpf1wddVgYH8jDNtr0,22746
+ck/dataset/dataset_builder.py,sha256=e9fNbvDl1HhM49DxvvBtXWOHpvPPocBsTTzUsCpkR_A,18912
 ck/dataset/dataset_compute.py,sha256=B1BxTJ-JAsNk8l79iDRmJAQ5QwEvWgsI1wepRg4aQCQ,5845
 ck/dataset/dataset_from_crosstable.py,sha256=0I4jr4PtfBtniTFBHlAOlcl_ZH0NSD37azkcA2CaWSQ,1323
-ck/dataset/dataset_from_csv.py,sha256=a3r8OydeiGLN41pVm-9x5z1hvLtyUTCJdzsz2DK9MBM,5698
+ck/dataset/dataset_from_csv.py,sha256=Nn2RzZP_fhag2UaXzv27YEnKSo6oogKEVGEEafQuB6U,5953
 ck/dataset/sampled_dataset.py,sha256=8PfiTXqraSQ5rXpFUFFMN13jQL1x--_z9g6FYs2VW1U,3357
 ck/example/__init__.py,sha256=BXVxvTcl3tqgai-xJiGQIaG_ChlpPRdfWg985MQ7dwM,1744
 ck/example/alarm.py,sha256=QkHoUb6MxZzCOCX4nLE8UJazNEqAPqrFWQ01lslvdsk,25274
@@ -101,8 +102,8 @@ ck/pgm_compiler/support/factor_tables.py,sha256=tV9qE2zC8iwEQxTuXE6qiE6lmMpz4-Vc
 ck/pgm_compiler/support/join_tree.py,sha256=Chkyyo--ChgWEsDqTh8RCxPN7Z1NyvL--GjTC4ONvkY,12897
 ck/pgm_compiler/support/named_compiler_maker.py,sha256=g2MLnlkWXkISHL6dh23EY53SptTo7-itfuZogSpMdB8,1420
 ck/pgm_compiler/support/circuit_table/__init__.py,sha256=yJ05NvuNE9j0E_QnjDzHYfLqcHn5TdOleEpG3wSRgXQ,579
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c,sha256=9nI3PYdEGS09uaPBjwxt0ftjimajyEqEWbyluGozm4s,730350
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cp312-win_amd64.pyd,sha256=113C-K77YNcGyhmOim81IYWoRWyX-HA37afCgbpcSOQ,97280
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c,sha256=5TqAN98gLTZ3inQFBc_b6xpJJjjs2RJsbJ3loHHybho,730350
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cp312-win_amd64.pyd,sha256=r97wGUlqYT8oLecHbdPLUKnyGMgct6uPaGoypx1xIIA,97280
 ck/pgm_compiler/support/circuit_table/_circuit_table_cy.pyx,sha256=rVO1yxjZmZ6yv5s0zKq4Ji9WYrDuYTZsRG_zeF1_1xE,12015
 ck/pgm_compiler/support/circuit_table/_circuit_table_py.py,sha256=h6xPYGBSy6XHQBFLPD2D1-V7Kiw9utY68nWrcGRMEg4,11287
 ck/probability/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -143,6 +144,8 @@ ck_demos/circuit/demo_derivatives.py,sha256=3JoWVAEKLEoLjq6QzWkq4Z-qVq1l0tHvGDn5
 ck_demos/circuit_compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/circuit_compiler/compare_circuit_compilers.py,sha256=IEzwvKt6c8wrmAyd6F0sUaNaWYEx1BBFQhRyDt7cibI,756
 ck_demos/circuit_compiler/show_llvm_program.py,sha256=HKUuyLfBjH6ZgD8l4gQWVSBPUh55ZCXjPa7ZEdm5OyU,712
+ck_demos/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ck_demos/dataset/demo_dataset_builder.py,sha256=1OycYIr0C_3NCn0SLNoHftjStnRrGk_f0yNlckD6nh4,1024
 ck_demos/getting_started/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/getting_started/simple_demo.py,sha256=AR40OtUVd-CJOxFlsu8_RtGLL2LLnZg506SzrIx7OQA,668
 ck_demos/pgm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -185,8 +188,8 @@ ck_demos/utils/compare.py,sha256=Bwjpflevl4nusfA0zp96rInaVKFGuhC5Xv7HzA1Fobk,508
 ck_demos/utils/convert_network.py,sha256=TSKj8q7L7J5rhrvwjaDkdYZ0Sg8vV5FRL_vCanX1CQw,1363
 ck_demos/utils/sample_model.py,sha256=in-Nlv-iuNIu6y9fDuMyo7nzgimBuTAnCWcpnVqvqDQ,8839
 ck_demos/utils/stop_watch.py,sha256=VzXHRWx0V8vPSD-bLgLlEYkCkR2FA0-KmM_pfKx-Pxo,13205
-compiled_knowledge-4.1.0a1.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
-compiled_knowledge-4.1.0a1.dist-info/METADATA,sha256=e9hWaS-X8HETgzi758WKtE4m-iXA75YTeOIL4SGKQQo,1837
-compiled_knowledge-4.1.0a1.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
-compiled_knowledge-4.1.0a1.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
-compiled_knowledge-4.1.0a1.dist-info/RECORD,,
+compiled_knowledge-4.1.0a2.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
+compiled_knowledge-4.1.0a2.dist-info/METADATA,sha256=41mdCLKoTBDANacEu1V3Al9pup0b_6HjQ-DvBO4WUuk,1837
+compiled_knowledge-4.1.0a2.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+compiled_knowledge-4.1.0a2.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
+compiled_knowledge-4.1.0a2.dist-info/RECORD,,