iita-python 1.2.1__tar.gz → 1.4__tar.gz

{iita_python-1.2.1/iita_python.egg-info → iita_python-1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iita_python
-Version: 1.2.1
+Version: 1.4
 Summary: IITA algorithm in python
 Author-email: Aliaksei Badnarchuk <alexejbodnarchuk@gmail.com>
 Requires-Python: >=3.9

iita_python-1.4/iita_python/__init__.py

@@ -0,0 +1,5 @@
+from .dataset import Dataset
+from .quasiorder import ind_gen
+from . import fit_metrics
+
+__all__ = ['Dataset', 'ind_gen', 'fit_metrics']

iita_python-1.4/iita_python/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.4'
+__version_tuple__ = version_tuple = (1, 4)
+
+__commit_id__ = commit_id = 'g8439da544'

{iita_python-1.2.1 → iita_python-1.4}/iita_python/additional_ce.py

@@ -15,12 +15,12 @@ def pairwise_diff_ce(rp: pd.DataFrame) -> pd.DataFrame:
     items = rp.shape[1]
     subjects = rp.shape[0]
 
-    ce = pd.DataFrame(0, index=np.arange(items), columns=np.arange(items))
+    ce = pd.DataFrame(0, index=rp.columns, columns=rp.columns)
     for i in range(subjects):
         # for subject i, if a < b, add b - a for all item pairs (a,b)
         # this is equivalent to ce[a][b] += 1 if a=0 and b=1, but works for non-binary data as well
 
-        row = rp.loc[i].to_numpy()
+        row = rp.iloc[i].to_numpy()
         ce -= np.clip(row[:, None] - row[None, :], None, 0)
 
     return ce
@@ -39,10 +39,10 @@ def missing_value_substitution_ce(rp: pd.DataFrame) -> pd.DataFrame:
 
     for i in range(items):
         # substitute missing values in item i with the mean of the item
-        col = rp1.loc[:, i].to_numpy()
+        col = rp1.iloc[:, i].to_numpy()
         mean_val = np.nanmean(col)
         col = pd.Series(col).fillna(mean_val)
-        rp1.loc[:, i] = col
+        rp1.iloc[:, i] = col
 
     # then calculate pairwise difference counterexamples
     return pairwise_diff_ce(rp1)
@@ -64,10 +64,10 @@ def relativify(calculator: callable):
         items = rp.shape[1]
         subjects = rp.shape[0]
 
-        valid_cases = pd.DataFrame(0, index=np.arange(items), columns=np.arange(items))
+        valid_cases = pd.DataFrame(0, index=rp.columns, columns=rp.columns)
         for i in range(subjects):
             #for subject i, increment all cases where neither a nor b are NaN (valid case for counterexamples)
-            not_nan = np.logical_not(rp.loc[i].isna())
+            not_nan = np.logical_not(rp.iloc[i].isna())
             valid_cases += np.outer(not_nan, not_nan).astype(int)
 
         # avoid division by zero

iita_python-1.4/iita_python/dataset.py

@@ -0,0 +1,91 @@
+import numpy as np
+import numpy.typing as npt
+from typing import Self, List
+import pandas as pd
+
+class Dataset():
+    # full name aliases for response patterns, counterexamples and equivalence examples
+    @property
+    def response_patterns(self) -> pd.DataFrame:
+        return self.rp
+    @response_patterns.setter
+    def response_patterns(self, inp: pd.DataFrame) -> None:
+        self.rp = inp
+
+    @property
+    def counterexamples(self) -> pd.DataFrame:
+        return self.ce
+    @counterexamples.setter
+    def counterexamples(self, inp: pd.DataFrame) -> None:
+        self.ce = inp
+
+    @property
+    def equiv_examples(self) -> pd.DataFrame:
+        return self.eqe
+    @equiv_examples.setter
+    def equiv_examples(self, inp: pd.DataFrame) -> None:
+        self.eqe = inp
+
+    @property
+    def items(self):
+        return self.rp.shape[1]
+    
+    @property
+    def subjects(self):
+        return self.rp.shape[0]
+    
+    @property
+    def filled_vals(self):
+        return (np.logical_not(np.isnan(self.rp)).astype(int)).sum(axis=0)
+
+    def __init__(self, response_patterns: pd.DataFrame | npt.NDArray | List[List[int]]):
+        """
+        Computes counterexamples, equivalence examples and valid CE cases from response patterns\n
+        Supports pandas dataframes, numpy arrays, and python lists\n
+        Rows represent the subjects, columns - the items\n
+        """
+        self.rp = pd.DataFrame(response_patterns)
+        self.ce = None
+        self.eqe = None
+        
+        rp_numpy = self.rp.to_numpy()
+
+        # setting missing values (NaN) to 0
+        rp_no_nan = np.nan_to_num(rp_numpy, 0) # NaN to 0
+        not_rp_no_nan = np.logical_not(np.nan_to_num(rp_numpy, 1)).astype(int) # NaN to 1, negated to 0
+
+        # counterexamples computation
+        # all cases where a=0 and b=1 (counterexamples to b->a or a <= b)
+        self.ce = pd.DataFrame(not_rp_no_nan.T @ rp_no_nan, index=self.rp.columns, columns=self.rp.columns)
+        
+        # equivalence examples computation
+        # all cases where a=b, equivalent to ((a and b) or (~a and ~b))
+        a_and_b = rp_no_nan.T @ rp_no_nan
+        not_a_and_not_b = (not_rp_no_nan).T @ (not_rp_no_nan)
+        self.eqe = pd.DataFrame(a_and_b + not_a_and_not_b, index=self.rp.columns, columns=self.rp.columns)
+
+        # valid CE cases computation
+        rp_isnt_nan = np.logical_not(np.isnan(rp_numpy)).astype(int)
+        self.valid_ce_cases = pd.DataFrame(rp_isnt_nan.T @ rp_isnt_nan, index=self.rp.columns, columns=self.rp.columns)
+    
+    def add(self, dataset_to_add: Self):
+        """
+        Add a second IITA_Dataset: concatenate the response patterns, add CE, EQE and valid CE cases\n
+        Item amounts must match, else ValueError
+        """
+        if (self.items != dataset_to_add.items):
+            raise ValueError('Item amounts must match')
+        
+        self.rp = pd.concat(self.rp, dataset_to_add.rp)
+        self.ce = self.ce + dataset_to_add.ce
+        self.eqe = self.eqe + dataset_to_add.eqe
+        self.valid_ce_cases = self.valid_ce_cases + dataset_to_add.valid_ce_cases
+
+    @property 
+    def relative_ce(self) -> pd.DataFrame:
+        """
+        Returns the counterexamples matrix accounting for missing values
+        """
+        return self.ce / self.valid_ce_cases
+    
+    __iadd__ = add

{iita_python-1.2.1 → iita_python-1.4}/iita_python/quasiorder.py

@@ -20,31 +20,20 @@ class QuasiOrder:
                 if (self.full_matrix[i][j]):
                     edge_list.append([i+buff, j+buff])
         
-        return edge_list
+        return edge_list   
 
-def unfold_examples(
-        matrix: pd.DataFrame
-    ) -> npt.NDArray:
+def ind_gen(counterexamples: pd.DataFrame, n: int) -> list[QuasiOrder]:
     """
-    Turns an item/item metric DataFrame into
-    a list of tuples of the form (x, [i, j]), where matrix[i, j] = x.\n
+    Inductively generates quasiorders from counterexample count DataFrame\n
     """
 
-    dfmatrix = pd.DataFrame(matrix)
+    dfce = pd.DataFrame(counterexamples)
 
-    n = dfmatrix.shape[0]
+    n = dfce.shape[0]
     pos = np.arange(n, dtype=np.int_)
     i = np.repeat(pos, n)
     j = np.tile(pos, n)
-    res = np.array(list(zip(dfmatrix.to_numpy()[i, j], i, j)))
-    return res[res[:, 1] != res[:, 2]]
-
-def ind_gen(counterexamples: npt.NDArray, n: int) -> list[QuasiOrder]:
-    """
-    Inductively generates quasiorders from counterexample edge list\n
-    Counterexamples is expected to be of the form returned by unfold_examples (array of (x, i, j) tuples)\n
-    """
-    ce = counterexamples
+    ce = np.array(list(zip(dfce.to_numpy()[i, j], i, j)))
 
     if (len(ce) == 0): raise ValueError("Counterexamples can't be empty")
 

{iita_python-1.2.1 → iita_python-1.4/iita_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iita_python
-Version: 1.2.1
+Version: 1.4
 Summary: IITA algorithm in python
 Author-email: Aliaksei Badnarchuk <alexejbodnarchuk@gmail.com>
 Requires-Python: >=3.9

iita_python-1.2.1/iita_python/__init__.py

@@ -1,4 +0,0 @@
-from .dataset import Dataset
-from .quasiorder import ind_gen, unfold_examples
-
-__all__ = ['Dataset', 'unfold_examples', 'ind_gen']

iita_python-1.2.1/iita_python/_version.py

@@ -1,34 +0,0 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
-
-__version__ = version = '1.2.1'
-__version_tuple__ = version_tuple = (1, 2, 1)
-
-__commit_id__ = commit_id = 'gda19693c6'

iita_python-1.2.1/iita_python/dataset.py

@@ -1,95 +0,0 @@
-import numpy as np
-import numpy.typing as npt
-from typing import Self, List
-import pandas as pd
-
-class Dataset():
-    #aliases for response_patterns, counterexamples, equiv_examples
-    @property
-    def rp(self) -> pd.DataFrame:
-        return self._rp
-    @rp.setter
-    def rp(self, inp: pd.DataFrame) -> None:
-        self._rp = inp
-    response_patterns = rp
-
-    @property
-    def ce(self) -> pd.DataFrame:
-        return self._ce
-    @ce.setter
-    def ce(self, inp: pd.DataFrame) -> None:
-        self._ce = inp
-    counterexamples = ce
-
-    @property
-    def eqe(self) -> pd.DataFrame:
-        return self._eqe
-    @eqe.setter
-    def eqe(self, inp: pd.DataFrame) -> None:
-        self._eqe = inp
-    equiv_examples = eqe
-
-    @property
-    def items(self):
-        return self.rp.shape[1]
-    
-    @property
-    def subjects(self):
-        return self.rp.shape[0]
-    
-    @property
-    def filled_vals(self):
-        return (~np.isnan(self.rp)).sum(axis=0)
-
-    def __init__(self, response_patterns: pd.DataFrame | npt.NDArray | List[List[int]]):
-        """
-        Computes the counterexamples and equivalence examples from response patterns\n
-        Supports pandas dataframes, numpy arrays, and python lists\n
-        Rows represent the subjects, columns - the items\n
-        """
-        self._rp = pd.DataFrame(response_patterns, index=None, columns=None)
-        self._ce = None
-        self._eqe = None
-        
-        #counterexamples computation   
-        self.ce = pd.DataFrame(0, index=np.arange(self.items), columns=np.arange(self.items))
-
-        for i in range(self.subjects):
-            #for subject i, increment all cases where a=0 and b=1 (counterexamples to b->a or a <= b)
-            not_a = (self.rp.loc[i] == 0)
-            b = (self.rp.loc[i] == 1)
-            self.ce.loc[not_a, b] += 1
-        
-        #equivalence examples computation   
-        self.eqe = pd.DataFrame(0, index=np.arange(self.items), columns=np.arange(self.items))
-        for i in range(self.subjects):
-            #for subject i, increment all cases where a=b (examples of equivalence of a and b)
-            row = self.rp.loc[i].to_numpy()
-            self.eqe += np.equal.outer(row, row).astype(int)
-
-        self.valid_ce_cases = pd.DataFrame(0, index=np.arange(self.items), columns=np.arange(self.items))
-        for i in range(self.subjects):
-            #for subject i, increment all cases where neither a nor b are NaN (valid case for counterexamples)
-            not_nan = np.logical_not(self.rp.loc[i].isna())
-            self.valid_ce_cases += np.outer(not_nan, not_nan).astype(int)
-    
-    def add(self, dataset_to_add: Self):
-        """
-        Add a second IITA_Dataset: concatenate the response patterns, add counterexamples and equivalence examples\n
-        Item amounts must match, else ValueError
-        """
-        if (self.items != dataset_to_add.items):
-            raise ValueError('Item amounts must match')
-        
-        self.rp = pd.concat(self.rp, dataset_to_add.rp)
-        self.ce = self.ce + dataset_to_add.ce
-        self.eqe = self.eqe + dataset_to_add.eqe
-
-    @property 
-    def relative_ce(self) -> pd.DataFrame:
-        """
-        Returns the counterexamples matrix accounting for missing values
-        """
-        return self.ce / self.valid_ce_cases
-    
-    __iadd__ = add