mlquantify 0.1.18__py3-none-any.whl → 0.1.19__py3-none-any.whl

mlquantify/model_selection/_protocol.py

@@ -8,6 +8,7 @@ from mlquantify.utils._sampling import (
     simplex_uniform_kraemer,
     simplex_uniform_sampling,
 )
+from mlquantify.utils._random import check_random_state
 from mlquantify.utils._validation import validate_data
 from abc import ABC, abstractmethod
 from logging import warning
@@ -170,6 +171,8 @@ class APP(BaseProtocol):
     def _iter_indices(self, X: np.ndarray, y: np.ndarray):
         
         n_dim = len(np.unique(y))
+
+        rng = check_random_state(self.random_state)
         
         for batch_size in self.batch_size:
             prevalences = simplex_grid_sampling(n_dim=n_dim,
@@ -178,9 +181,8 @@ class APP(BaseProtocol):
                                               min_val=self.min_prev,
                                               max_val=self.max_prev)
             for prev in prevalences:
-                indexes = get_indexes_with_prevalence(y, prev, batch_size)
+                indexes = get_indexes_with_prevalence(y, prev, batch_size, random_state=rng)
                 yield indexes
-                
 
             
 
@@ -221,10 +223,10 @@ class NPP(BaseProtocol):
         self.repeats = repeats
 
     def _iter_indices(self, X: np.ndarray, y: np.ndarray):
-        
+        rng = check_random_state(self.random_state)
         for _ in range(self.n_samples):
             for batch_size in self.batch_size:
-                idx = np.random.choice(X.shape[0], batch_size, replace=True)
+                idx = rng.choice(X.shape[0], batch_size, replace=True)
                 for _ in range(self.repeats):
                     yield idx
             
@@ -289,6 +291,8 @@ class UPP(BaseProtocol):
     def _iter_indices(self, X: np.ndarray, y: np.ndarray):
         
         n_dim = len(np.unique(y))
+
+        rng = check_random_state(self.random_state)
         
         for batch_size in self.batch_size:
             if self.algorithm == 'kraemer':
@@ -296,16 +300,17 @@ class UPP(BaseProtocol):
                                            n_prev=self.n_prevalences,
                                            n_iter=self.repeats,
                                            min_val=self.min_prev,
-                                           max_val=self.max_prev)
+                                           max_val=self.max_prev,
+                                           random_state=rng)
             elif self.algorithm == 'uniform':
                 prevalences = simplex_uniform_sampling(n_dim=n_dim,
                                               n_prev=self.n_prevalences,
                                               n_iter=self.repeats,
                                               min_val=self.min_prev,
-                                              max_val=self.max_prev)
-
+                                              max_val=self.max_prev,
+                                              random_state=rng)
             for prev in prevalences:
-                indexes = get_indexes_with_prevalence(y, prev, batch_size)
+                indexes = get_indexes_with_prevalence(y, prev, batch_size, random_state=rng)
                 yield indexes
 
 
@@ -347,12 +352,12 @@ class PPP(BaseProtocol):
                         repeats=repeats)
     
     def _iter_indices(self, X: np.ndarray, y: np.ndarray):
-        
+        rng = check_random_state(self.random_state)
         for batch_size in self.batch_size:    
             for prev in self.prevalences:
                 if isinstance(prev, float):
                     prev = [1-prev, prev]
                 
-                indexes = get_indexes_with_prevalence(y, prev, batch_size)
+                indexes = get_indexes_with_prevalence(y, prev, batch_size, random_state=rng)
                 yield indexes
         

mlquantify/utils/_sampling.py

@@ -1,8 +1,9 @@
 import numpy as np
+from mlquantify.utils import check_random_state
 import itertools
 
 
-def get_indexes_with_prevalence(y, prevalence: list, sample_size:int):
+def get_indexes_with_prevalence(y, prevalence: list, sample_size:int, random_state: int = None):
     """
     Get indexes for a stratified sample based on the prevalence of each class.
     
@@ -23,6 +24,7 @@ def get_indexes_with_prevalence(y, prevalence: list, sample_size:int):
         List of indexes for the stratified sample.
     """      
     classes = np.unique(y)
+    rng = check_random_state(random_state)
         
     # Ensure the sum of prevalences is 1
     assert np.isclose(sum(prevalence), 1), "The sum of prevalences must be 1"
@@ -43,12 +45,12 @@ def get_indexes_with_prevalence(y, prevalence: list, sample_size:int):
         class_indexes = np.where(y == class_)[0]
 
         # Sample the indexes for the current class
-        sampled_class_indexes = np.random.choice(class_indexes, size=num_samples, replace=True)
+        sampled_class_indexes = rng.choice(class_indexes, size=num_samples, replace=True)
         
         sampled_indexes.extend(sampled_class_indexes)
         total_sampled += num_samples
 
-    np.random.shuffle(sampled_indexes)  # Shuffle after collecting all indexes
+    rng.shuffle(sampled_indexes)  # Shuffle after collecting all indexes
         
     return sampled_indexes
 
@@ -59,7 +61,8 @@ def simplex_uniform_kraemer(n_dim: int,
                             n_iter: int, 
                             min_val: float = 0.0, 
                             max_val: float = 1.0, 
-                            max_tries: int = 1000) -> np.ndarray:
+                            max_tries: int = 1000,
+                            random_state: int = None) -> np.ndarray:
     """
     Generates n_prev prevalence vectors of n_dim classes uniformly 
     distributed on the simplex, with optional lower and upper bounds.
@@ -91,28 +94,25 @@ def simplex_uniform_kraemer(n_dim: int,
     if min_val * n_dim > 1 or max_val * n_dim < 1:
         raise ValueError("Invalid bounds: they make it impossible to sum to 1.")
 
+    rng = check_random_state(random_state)
+
     effective_simplex_size = 1 - n_dim * min_val
     prevs = []
 
-    # Amostragem em blocos até atingir n_prev válidos
     tries = 0
-    batch_size = max(n_prev, 1000)  # Gera em blocos grandes para eficiência
+    batch_size = n_prev
 
     while len(prevs) < n_prev and tries < max_tries:
         tries += 1
-
-        # Geração de pontos uniformes no simplex reduzido
-        u = np.random.uniform(0, 1, (batch_size, n_dim - 1))
+    
+        u = rng.uniform(0, 1, (batch_size, n_dim - 1))
         u.sort(axis=1)
         simplex = np.diff(np.concatenate([np.zeros((batch_size, 1)), u, np.ones((batch_size, 1))], axis=1), axis=1)
 
-        # Escala para [min_val, max_val]
         scaled = min_val + simplex * effective_simplex_size
 
-        # Normaliza para garantir soma = 1
         scaled /= scaled.sum(axis=1, keepdims=True)
 
-        # Filtra apenas vetores válidos
         mask = np.all((scaled >= min_val) & (scaled <= max_val), axis=1)
         valid = scaled[mask]
 
@@ -122,11 +122,13 @@ def simplex_uniform_kraemer(n_dim: int,
     if not prevs:
         raise RuntimeError("No valid prevalences found with given constraints. Try adjusting min_val/max_val.")
     
-    if n_iter > 1:
-        prevs = np.tile(prevs, (n_iter, 1))
-
     result = np.vstack(prevs)
-    return result[:n_prev]
+    result = result[:n_prev]
+
+    if n_iter > 1:
+        result = np.repeat(result, n_iter, axis=0)
+    
+    return result
  
  
  
@@ -135,7 +137,7 @@ def simplex_grid_sampling(
     n_prev: int,
     n_iter: int,
     min_val: float,
-    max_val: float
+    max_val: float,
 ) -> np.ndarray:
     """
     Efficiently generates artificial prevalence vectors that sum to 1
@@ -181,7 +183,7 @@ def simplex_grid_sampling(
 
     # Repetição se necessário
     if n_iter > 1:
-        prevs = np.tile(prevs, (n_iter, 1))
+        prevs = np.repeat(prevs, n_iter, axis=0)
 
     return prevs
 
@@ -193,7 +195,8 @@ def simplex_uniform_sampling(
     n_prev: int,
     n_iter: int,
     min_val: float,
-    max_val: float
+    max_val: float,
+    random_state: int = None
 ) -> np.ndarray:
     """
     Generates uniformly distributed prevalence vectors within the simplex,
@@ -265,9 +268,8 @@ def bootstrap_sample_indices(
     np.ndarray
         Array containing indices for a bootstrap sample.
     """
-    if random_state is not None:
-        np.random.seed(random_state)
+    rng = check_random_state(random_state)
 
     for _ in range(n_bootstraps):
-        indices = np.random.choice(n_samples, size=batch_size, replace=True)
+        indices = rng.choice(n_samples, size=batch_size, replace=True)
         yield indices

mlquantify/utils/prevalence.py

@@ -3,27 +3,36 @@ import pandas as pd
 from collections import defaultdict
 
 
-def get_prev_from_labels(y, format="dict") -> dict:
+def get_prev_from_labels(y, format="dict", classes: list = None):
     """
     Get the real prevalence of each class in the target array.
-    
+
     Parameters
     ----------
     y : np.ndarray or pd.Series
         Array of class labels.
-        
+    format : str, default="dict"
+        Format of the output. Can be "array" or "dict".
+    classes : list, optional
+        List of unique classes. If provided, the output will be sorted by these classes.
+
     Returns
     -------
-    dict
-        Dictionary of class labels and their corresponding prevalence.
+    dict or np.ndarray
+        Dictionary of class labels and their corresponding prevalence or array of prevalences.
     """
     if isinstance(y, np.ndarray):
         y = pd.Series(y)
+
+    counts = y.value_counts(normalize=True).sort_index()
+
+    if classes is not None:
+        counts = counts.reindex(classes, fill_value=0.0)
+
     if format == "array":
-        prevalences = y.value_counts(normalize=True).sort_index().values
-        return prevalences
-    real_prevs = y.value_counts(normalize=True).to_dict()
-    real_prevs = dict(sorted(real_prevs.items()))
+        return counts.values
+
+    real_prevs = counts.to_dict()
     return real_prevs
 
 

{mlquantify-0.1.18.dist-info → mlquantify-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlquantify
-Version: 0.1.18
+Version: 0.1.19
 Summary: Quantification Library
 Home-page: https://github.com/luizfernandolj/QuantifyML/tree/master
 Maintainer: Luiz Fernando Luth Junior

{mlquantify-0.1.18.dist-info → mlquantify-0.1.19.dist-info}/RECORD

@@ -23,7 +23,7 @@ mlquantify/mixture/_base.py,sha256=1-yW64FPQXB_d9hH9KjSlDnmFtW9FY7S2hppXAd1DBg,5
 mlquantify/mixture/_classes.py,sha256=Dx0KWS-RtVVmJwXvPKIVWitsJhgcYRRiypLYrgE66x4,16420
 mlquantify/mixture/_utils.py,sha256=CKlC081nrkJ8Pil7lrPZvNZC_xfpXV8SsuQq3M_LHgA,4037
 mlquantify/model_selection/__init__.py,sha256=98I0uf8k6lbWAjazGyGjbOdPOvzU8aMRLqC3I7D3jzk,113
-mlquantify/model_selection/_protocol.py,sha256=2k0M_7YwZf7YLoQ8ElR2xMvLySVgtE_EvWieMXTIzTA,12499
+mlquantify/model_selection/_protocol.py,sha256=XhkNUN-XAuGkihm0jwQL665ps2G9bevxme_yrETNQHo,12902
 mlquantify/model_selection/_search.py,sha256=1UoP3tZ-pdfM25C-gOS89qjGKcDgQEeU7GTbwtsLKHU,10695
 mlquantify/model_selection/_split.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
 mlquantify/neighbors/__init__.py,sha256=rIOuSaUhjqEXsUN9HNZ62P53QG0N7lJ3j1pvf8kJzms,93
@@ -43,11 +43,11 @@ mlquantify/utils/_get_scores.py,sha256=VlTvgg_t4D9MzcgsH7YvP_wIL5AZ8XmEtGpbFivdV
 mlquantify/utils/_load.py,sha256=cMGXIs-8mUB4blAmagyDNNvAaV2hysRgeInQMl5fDHg,303
 mlquantify/utils/_parallel.py,sha256=XotpX9nsj6nW-tNCmZ-ahTcRztgnn9oQKP2cl1rLdYM,196
 mlquantify/utils/_random.py,sha256=7F3nyy7Pa_kN8xP8P1L6MOM4WFu4BirE7bOfGTZ1Spk,1275
-mlquantify/utils/_sampling.py,sha256=QQxE2WKLdiCFUfPF6fKgzyrsOUIWYf74w_w8fbYVc2c,8409
+mlquantify/utils/_sampling.py,sha256=3W0vUuvLvoYrt-BZpSM0HM1XJEZr0XYIdkOcUP5hp-8,8350
 mlquantify/utils/_tags.py,sha256=Rz78TLpxgVxBKS0mKTlC9Qo_kn6HaEwVKNXh8pxFT7M,1095
 mlquantify/utils/_validation.py,sha256=zn4OHfa704YBaPKskhiThUG7wS5fvDoHBpcEgb1i8qM,18078
-mlquantify/utils/prevalence.py,sha256=FXLCJViQb2yDbyTXeGZt8WsPPnSZINhorQYZTKXOn14,1772
-mlquantify-0.1.18.dist-info/METADATA,sha256=XrQ188Icw5RZEAN8tvHRHTsRm1IKB1iwR_tm6G7uB0w,4701
-mlquantify-0.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mlquantify-0.1.18.dist-info/top_level.txt,sha256=tGEkYkbbFElwULvqENjam3u1uXtyC1J9dRmibsq8_n0,11
-mlquantify-0.1.18.dist-info/RECORD,,
+mlquantify/utils/prevalence.py,sha256=LG-KXJ5Eb4w26WMpu4PoBpxMSHaqrmTQqdRlyqNRJ1o,2020
+mlquantify-0.1.19.dist-info/METADATA,sha256=nQ0BqrdrpxbBTHhFh6p2M9qXqQsehRAdqIB5cpNbr1s,4701
+mlquantify-0.1.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mlquantify-0.1.19.dist-info/top_level.txt,sha256=tGEkYkbbFElwULvqENjam3u1uXtyC1J9dRmibsq8_n0,11
+mlquantify-0.1.19.dist-info/RECORD,,