iita-python 1.2__tar.gz → 1.3__tar.gz

{iita_python-1.2/iita_python.egg-info → iita_python-1.3}/PKG-INFO

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

iita_python-1.3/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.2 → iita_python-1.3}/iita_python/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.2'
-__version_tuple__ = version_tuple = (1, 2)
+__version__ = version = '1.3'
+__version_tuple__ = version_tuple = (1, 3)
 
-__commit_id__ = commit_id = 'gb97b590cd'
+__commit_id__ = commit_id = 'g087a84930'

{iita_python-1.2 → iita_python-1.3}/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
@@ -90,12 +90,10 @@ class AdditionalCEDataset(Dataset):
         """
         super().__init__(response_patterns)
 
-        self.pairwise_diff_ce = lambda self, relative=False: (
-            relativify(pairwise_diff_ce) if relative else pairwise_diff_ce
-        )(self.rp)
+        self.pairwise_diff_ce = lambda: pairwise_diff_ce(self.rp)
         self.pairwise_diff_ce.__doc__ = pairwise_diff_ce.__doc__
 
-        self.missing_value_substitution_ce = lambda self, relative=False: (
+        self.missing_value_substitution_ce = lambda relative=False: (
             relativify(missing_value_substitution_ce) if relative else missing_value_substitution_ce
         )(self.rp)
         self.missing_value_substitution_ce.__doc__ = missing_value_substitution_ce.__doc__

{iita_python-1.2 → iita_python-1.3}/iita_python/dataset.py

@@ -47,30 +47,30 @@ class Dataset():
         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._rp = pd.DataFrame(response_patterns)
         self._ce = None
         self._eqe = None
         
         #counterexamples computation   
-        self.ce = pd.DataFrame(0, index=np.arange(self.items), columns=np.arange(self.items))
+        self.ce = pd.DataFrame(0, index=self.rp.columns, columns=self.rp.columns)
 
         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)
+            not_a = (self.rp.iloc[i] == 0)
+            b = (self.rp.iloc[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))
+        self.eqe = pd.DataFrame(0, index=self.rp.columns, columns=self.rp.columns)
         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()
+            row = self.rp.iloc[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))
+        self.valid_ce_cases = pd.DataFrame(0, index=self.rp.columns, columns=self.rp.columns)
         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())
+            not_nan = np.logical_not(self.rp.iloc[i].isna())
             self.valid_ce_cases += np.outer(not_nan, not_nan).astype(int)
     
     def add(self, dataset_to_add: Self):

{iita_python-1.2 → iita_python-1.3}/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 → iita_python-1.3/iita_python.egg-info}/PKG-INFO

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

iita_python-1.2/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']