MLQuantify

https://luizfernandolj.github.io/mlquantify/stable/
Admin
MLQuantify is a Python package providing a comprehensive toolkit for class prevalence estimation,...
Tokens:285,134
Snippets:2,511
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install mlquantify from source

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/getting_started.rst.txt

Install the latest development version of mlquantify by cloning the repository and installing from source.

```bash
git clone https://github.com/luizfernandolj/mlquantify.git
cd mlquantify
pip install .
```

--------------------------------

### Install mlquantify from source

Source: https://luizfernandolj.github.io/mlquantify/stable/getting_started.html

Install the latest development version of mlquantify by cloning the GitHub repository and installing from local source.

```bash
git clone https://github.com/luizfernandolj/mlquantify.git
cd mlquantify
pip install .

```

--------------------------------

### Install mlquantify using pip

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/install.rst.txt

Use this command to install the mlquantify library. Pip will automatically handle the installation of its dependencies.

```bash
pip install mlquantify
```

--------------------------------

### KDEyQuantifier Example with Custom Implementation

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.matching.KDEyQuantifier.html

Demonstrates how to create a custom KDEyQuantifier by subclassing and implementing necessary methods. This example uses Logistic Regression and synthetic data to show the fitting and prediction process.

```python
>>> from mlquantify.matching._density import KDEyQuantifier
>>> from mlquantify.base_aggregative import SoftPredictionMixin, AggregativeMixin
>>> from mlquantify.matching._base import BaseMatchingQuantifier
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.datasets import make_classification
>>> import numpy as np
>>> class MyKDEy(KDEyQuantifier):
...     def _precompute_density_terms(self, train_scores=None,
...                                   train_labels=None, train_representation=None):
...         pass  # no precomputation needed
...     def _solve_prevalence(self, test_representation, train_representations):
...         alpha = np.mean(test_representation)
...         return np.array([1 - alpha, alpha]), None
>>> X, y = make_classification(n_samples=200, random_state=42)
>>> MyKDEy(estimator=LogisticRegression()).fit(X, y).predict(X)
{0: ..., 1: ...}
```

--------------------------------

### Full Evaluation Example with Multiple Metrics

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/modules/evaluation_metrics.rst.txt

This example demonstrates a comprehensive evaluation workflow using multiple metrics (MAE, RAE, NKLD) and utilities like APP for protocol splitting and EMQ for quantification. It requires scikit-learn and numpy.

```python
from mlquantify.model_selection import APP
from mlquantify.metrics import MAE, RAE, NKLD
from mlquantify.utils import get_prev_from_labels
from mlquantify.likelihood import EMQ
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

X, y = make_classification(n_samples=2000, weights=[0.8, 0.2],
                           random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.5, random_state=42)

q = EMQ(LogisticRegression())
q.fit(X_train, y_train)

protocol = APP(batch_size=100, n_prevalences=21, repeats=10,
               random_state=42)

maes, raes, nklds = [], [], []
for idx in protocol.split(X_test, y_test):
    X_s, y_s = X_test[idx], y_test[idx]
    tp = get_prev_from_labels(y_s)
    pp = q.predict(X_s)
    maes.append(MAE(tp, pp))
    raes.append(RAE(tp, pp))
    nklds.append(NKLD(tp, pp))

print(f"MAE:  {np.mean(maes):.4f}")
print(f"RAE:  {np.mean(raes):.4f}")
print(f"NKLD: {np.mean(nklds):.4f}")
```

--------------------------------

### Install PyTorch

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/modules/neural.rst.txt

Neural quantifiers depend on PyTorch. Install it using pip.

```bash
pip install torch
```

--------------------------------

### Implementing a Soft Aggregative Quantifier

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.base_aggregative.SoftPredictionMixin.html

Demonstrates how to create a custom quantifier by inheriting from SoftPredictionMixin, AggregativeMixin, and BaseQuantifier. This example shows the necessary setup for using soft predictions with an aggregative approach, including defining the estimator and the predict method.

```python
>>> from mlquantify.base import BaseQuantifier
>>> from mlquantify.base_aggregative import AggregativeMixin, SoftPredictionMixin
>>> from sklearn.linear_model import LogisticRegression
>>> import numpy as np
>>> class MySoftAggregativeQuantifier(SoftPredictionMixin, AggregativeMixin, BaseQuantifier):
...     def __init__(self, estimator=None):
...         self.estimator = estimator if estimator is not None else LogisticRegression()
...     def fit(self, X, y):
...         self.estimator.fit(X, y)
...         self.classes_ = np.unique(y)
...         return self
...     def predict(self, X):
...         proba = self.estimator.predict_proba(X)
...         return proba.mean(axis=0)
>>> quantifier = MySoftAggregativeQuantifier()
>>> X = np.random.rand(100, 10)
>>> y = np.random.randint(0, 2, size=100)
>>> quantifier.fit(X, y).predict(X)
array(...)
```

--------------------------------

### DiagonalDisplay from Protocol Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.visualization.DiagonalDisplay.html

Demonstrates how to use DiagonalDisplay.from_protocol to visualize quantification results from a protocol. This involves setting up a quantifier, data, and specifying the protocol.

```python
from mlquantify.visualization import DiagonalDisplay
from mlquantify.counting import CC
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=400, random_state=0)
disp = DiagonalDisplay.from_protocol(
    CC(LogisticRegression()), X, y, protocol="app", n_prevalences=11)
disp.ax_.set_title("CC")
```

--------------------------------

### DummyRepresentation Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.representations.BaseRepresentation.html

Demonstrates how to create a custom representation by subclassing BaseRepresentation and implementing `_fit` and `transform`. This example shows setting `class_representations_` and transforming data.

```python
from mlquantify.representations import BaseRepresentation
import numpy as np

class DummyRepresentation(BaseRepresentation):
    def _fit(self, X, y, sample_weight=None):
        self.class_representations_ = np.array([[0], [1]])
    def transform(self, X):
        return X

X = [[0], [1], [0], [1]]
y = [0, 1, 0, 1]
rep = DummyRepresentation().fit(X, y)
print(rep.class_representations_)
```

--------------------------------

### Example Usage of BaseConfidenceRegion

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.confidence.BaseConfidenceRegion.html

Demonstrates how to create a concrete implementation of BaseConfidenceRegion by subclassing it. This example shows how to define methods for computing the region, getting the point estimate, and checking if a point is contained within the region.

```python
>>> import numpy as np
>>> class DummyRegion(BaseConfidenceRegion):
...     def _compute_region(self):
...         self.mean_ = np.mean(self.prev_estims, axis=0)
...     def get_region(self):
...         return self.mean_
...     def get_point_estimate(self):
...         return self.mean_
...     def contains(self, point):
...         return np.allclose(point, self.mean_, atol=0.1)
>>> X = np.random.dirichlet(np.ones(3), size=100)
>>> region = DummyRegion(X, confidence_level=0.9)
>>> region.get_point_estimate().round(3)
array(...)

```

--------------------------------

### PWK.get_metadata_routing

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.neighbors.PWK.html

Get metadata routing of this object. Please check User Guide on how the routing mechanism works.

```APIDOC
## PWK.get_metadata_routing

### Description
Get metadata routing of this object.

### Returns
- **routing** (MetadataRequest): A `MetadataRequest` encapsulating routing information.
```

--------------------------------

### KDEyML Initialization and Prediction Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.matching.KDEyML.html

Demonstrates how to initialize KDEyML with a LogisticRegression estimator, fit it to data, and make predictions. It also shows how to use the aggregate method with pre-computed posterior scores.

```python
from mlquantify.matching import KDEyML
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=200, random_state=42)
q = KDEyML(estimator=LogisticRegression()).fit(X, y)
q.predict(X)
# call aggregate with pre-computed posterior scores
scores = q.estimator_.predict_proba(X)
q.aggregate(scores, scores, y)
```

--------------------------------

### get_metadata_routing

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.compose.LinearComposeQuantifier.html

Get metadata routing of this object. Please check User Guide on how the routing mechanism works.

```APIDOC
## get_metadata_routing()

### Description
Get metadata routing of this object. Please check User Guide on how the routing mechanism works.

### Returns
* **routing** (MetadataRequest) - A `MetadataRequest` encapsulating routing information.
```

--------------------------------

### get_metadata_routing

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.compose.BaseComposeQuantifier.html

Get metadata routing of this object. Please check User Guide on how the routing mechanism works.

```APIDOC
## get_metadata_routing

### Description
Get metadata routing of this object. Please check User Guide on how the routing mechanism works.

### Returns
- **routing** (MetadataRequest) - A `MetadataRequest` encapsulating routing information.
```

--------------------------------

### UPP Initialization and Splitting Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.model_selection.UPP.html

Demonstrates how to initialize the UPP class with specified parameters and use its split method to generate evaluation batches. Shows the number of batches generated.

```python
from mlquantify.model_selection import UPP
import numpy as np
X, y = np.random.randn(200, 5), np.random.randint(0, 2, 200)
proto = UPP(batch_size=50, n_prevalences=5, random_state=0)
batches = list(proto.split(X, y))
len(batches)
```

--------------------------------

### Initialize and Fit FM Quantifier

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.counting.FM.html

Instantiate the FM quantifier with a Logistic Regression estimator and fit it to classification data. This example demonstrates the basic setup and fitting process.

```python
from mlquantify.counting import FM
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=200, n_classes=3, n_informative=5,
                           n_redundant=0, random_state=42)
q = FM(estimator=LogisticRegression()).fit(X, y)
q.predict(X)
```

--------------------------------

### GridSearchQ Initialization and Fitting Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.model_selection.GridSearchQ.html

Demonstrates how to initialize GridSearchQ with a quantifier, parameter grid, and protocol, then fit it to data. This snippet shows a typical workflow for hyperparameter tuning.

```python
from mlquantify.model_selection import GridSearchQ
from mlquantify.counting import CC
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=300, random_state=42)
param_grid = {'threshold': [0.3, 0.5, 0.7]}
gs = GridSearchQ(
    CC(LogisticRegression()),
    param_grid=param_grid,
    protocol='npp',
    n_repetitions=3,
).fit(X, y)
gs.best_params_
gs.predict(X)
```

--------------------------------

### PPP Initialization and Splitting Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.model_selection.PPP.html

Demonstrates how to initialize the PPP class with specific batch sizes and prevalences, and then use the split method to generate evaluation batches. This is useful for controlled evaluation at exact target operating points.

```python
from mlquantify.model_selection import PPP
import numpy as np
X, y = np.random.randn(200, 5), np.random.randint(0, 2, 200)
proto = PPP(batch_size=50, prevalences=[[0.2, 0.8], [0.5, 0.5]], random_state=0)
batches = list(proto.split(X, y))
len(batches)
```

--------------------------------

### MixtureNegativeLogLikelihoodLoss with 'ml' alias

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.losses.MixtureNegativeLogLikelihoodLoss.html

Shows an alternative way to get the MixtureNegativeLogLikelihoodLoss using its alias 'ml'. This example illustrates calculating the loss with different input values and rounding the result.

```python
from mlquantify.losses import get_loss
import numpy as np
loss = get_loss("ml")
prev = np.array([0.5, 0.5])
lkl = np.array([[0.2, 0.8], [0.7, 0.3]])
round(loss(prev, lkl), 4)

```

--------------------------------

### Initialize RegularizedMixtureNLLLoss with tau_0

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.losses.RegularizedMixtureNLLLoss.html

Instantiate the RegularizedMixtureNLLLoss with a specified tau_0 value for first-order smoothness penalty. This example demonstrates how to get the loss function and apply it to sample prevalence and likelihood data.

```python
>>> from mlquantify.losses import get_loss
>>> import numpy as np
>>> loss = get_loss("regularized_mixture_nll", tau_0=0.1)
>>> prev = np.array([0.3, 0.4, 0.3])
>>> lkl = np.array([[0.2, 0.5, 0.3], [0.6, 0.3, 0.1], [0.1, 0.2, 0.7]])
>>> loss(prev, lkl)  
1.0997116368050508
```

--------------------------------

### Full Evaluation Example with Metrics

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/evaluation_metrics.html

Demonstrates a complete evaluation workflow using mlquantify. Includes data generation, model training, and calculation of MAE, RAE, and NKLD metrics over multiple splits.

```python
from mlquantify.model_selection import APP
from mlquantify.metrics import MAE, RAE, NKLD
from mlquantify.utils import get_prev_from_labels
from mlquantify.likelihood import EMQ
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

X, y = make_classification(n_samples=2000, weights=[0.8, 0.2],
                           random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.5, random_state=42)

q = EMQ(LogisticRegression())
q.fit(X_train, y_train)

protocol = APP(batch_size=100, n_prevalences=21, repeats=10,
               random_state=42)

maes, raes, nklds = [], [], []
for idx in protocol.split(X_test, y_test):
    X_s, y_s = X_test[idx], y_test[idx]
    tp = get_prev_from_labels(y_s)
    pp = q.predict(X_s)
    maes.append(MAE(tp, pp))
    raes.append(RAE(tp, pp))
    nklds.append(NKLD(tp, pp))

print(f"MAE:  {np.mean(maes):.4f}")
print(f"RAE:  {np.mean(raes):.4f}")
print(f"NKLD: {np.mean(nklds):.4f}")

```

--------------------------------

### Wrap Base Quantifier with Ensemble Meta-Quantifier

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/meta_quantification.rst.txt

Demonstrates how to wrap an existing base quantifier (DyS with LogisticRegression) with an EnsembleQ meta-quantifier. This example shows the basic setup for fitting and predicting using the augmented quantifier.

```python
# Take any quantifier...
from mlquantify.matching import DyS
from sklearn.linear_model import LogisticRegression
base = DyS(LogisticRegression())

# ...and wrap it with a meta-quantifier
from mlquantify.meta import EnsembleQ
q = EnsembleQ(base, size=30, n_jobs=-1)
q.fit(X_train, y_train)
print(q.predict(X_test))
```

--------------------------------

### APP Initialization and Splitting Data

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.model_selection.APP.html

Demonstrates how to initialize the APP object with specified parameters and use its split method to generate evaluation batches. This is useful for setting up a comprehensive evaluation protocol for quantification models.

```python
from mlquantify.model_selection import APP
import numpy as np
X, y = np.random.randn(200, 5), np.random.randint(0, 2, 200)
proto = APP(batch_size=50, n_prevalences=5, random_state=0)
batches = list(proto.split(X, y))
len(batches)
```

--------------------------------

### ACC Example with Logistic Regression

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/modules/adjust_counting.rst.txt

Demonstrates how to use the ACC (Adjusted Classify and Count) method with a Logistic Regression classifier. This snippet shows the setup for binary classification using generated data and train-test split.

```python
from mlquantify.counting import ACC
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
```

--------------------------------

### NPP Initialization and Data Splitting Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.model_selection.NPP.html

Demonstrates how to initialize the NPP class with specified batch size and number of samples, and then use the split method to generate evaluation batches. This is useful for creating stratified sampling strategies that maintain the original class distribution.

```python
from mlquantify.model_selection import NPP
import numpy as np
X, y = np.random.randn(200, 5), np.random.randint(0, 2, 200)
proto = NPP(batch_size=50, n_samples=3, random_state=0)
batches = list(proto.split(X, y))
len(batches)
```

--------------------------------

### Full Evaluation Pipeline Example

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/model_selection_evaluation.rst.txt

Demonstrates a complete evaluation pipeline for quantification models, including data generation, model training, protocol splitting, prediction, and error calculation using MAE. Ensure necessary imports are present.

```python
from mlquantify.likelihood import EMQ
from mlquantify.model_selection import APP
from mlquantify.metrics import MAE
from mlquantify.utils import get_prev_from_labels
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

X, y = make_classification(n_samples=2000, weights=[0.7, 0.3],
                           random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.5, random_state=42)

q = EMQ(LogisticRegression())
q.fit(X_train, y_train)

protocol = APP(batch_size=100, n_prevalences=21,
               repeats=10,
               random_state=42)

errors = []
for idx in protocol.split(X_test, y_test):
    X_s, y_s = X_test[idx], y_test[idx]
    tp = get_prev_from_labels(y_s)
    pp = q.predict(X_s)
    errors.append(MAE(tp, pp))

print(f"Mean MAE: {np.mean(errors):.4f} ± {np.std(errors):.4f}")
```

--------------------------------

### Initialize and Fit TX Quantifier

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.counting.TX.html

Demonstrates how to initialize the TX quantifier with a RandomForestClassifier and fit it to sample data. Requires importing TX, a classifier, and data generation utilities.

```python
from mlquantify.counting import TX
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=100, n_classes=2, n_informative=5, random_state=42)
quantifier = TX(estimator=RandomForestClassifier(random_state=42))
_ = quantifier.fit(X, y)
```

--------------------------------

### Initialize and Fit QuaNet

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.neural.QuaNet.html

Instantiate QuaNet with a base estimator and device, then fit it to training data. Requires PyTorch and an estimator with a `transform` method.

```python
from mlquantify.neural import QuaNet
q = QuaNet(estimator=my_embedding_classifier, device='cpu')
q.fit(X_train, y_train)
q.predict(X_test)
```

--------------------------------

### IdentityCalibrator Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.calibration.Calibrator.html

An example of a simple IdentityCalibrator subclass that returns predictions unchanged. This demonstrates the basic structure required for a Calibrator subclass.

```python
>>> from mlquantify.calibration import Calibrator
>>> class IdentityCalibrator(Calibrator):
...     def fit(self, y_true, y_pred):
...         return self
...     def predict(self, y_pred):
...         return y_pred
```

--------------------------------

### Multiclass EMQ Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/likelihood.html

Demonstrates the native multiclass capability of EMQ. This example uses `make_classification` to generate multiclass data and `LogisticRegression` as the estimator.

```python
from mlquantify.likelihood import EMQ
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=800, n_classes=4,
                           n_informative=6, n_redundant=0,
                           random_state=42)
X_train, X_test = X[:600], X[600:]
y_train, y_test = y[:600], y[600:]

q = EMQ(LogisticRegression())
q.fit(X_train, y_train)
print(q.predict(X_test))
# {0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25}
```

--------------------------------

### Initialize and Fit GKDEyML

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.matching.GKDEyML.html

Demonstrates how to initialize GKDEyML with a Logistic Regression estimator and fit it to sample data. This is useful for setting up the quantifier for subsequent predictions.

```python
from mlquantify.matching import GKDEyML
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=200, n_classes=3, n_informative=5,
                           n_redundant=0, random_state=42)
q = GKDEyML(estimator=LogisticRegression()).fit(X, y)
q.predict(X)
```

--------------------------------

### Example Usage of BaseMatchingQuantifier

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.matching.BaseMatchingQuantifier.html

Demonstrates how to create a custom subclass of BaseMatchingQuantifier by implementing the _solve_prevalence method. This example uses KDERepresentation and numpy for illustration.

```python
from mlquantify.matching import BaseMatchingQuantifier
from mlquantify.representations import KDERepresentation
import numpy as np
class MyMatching(BaseMatchingQuantifier):
    def __init__(self):
        super().__init__(representation=KDERepresentation())
    def _solve_prevalence(self, test_representation, train_representations):
        # Dummy implementation for illustration
        prevalences = np.random.dirichlet(np.ones(len(train_representations)))
        distance = np.random.rand()
        return prevalences, distance
q = MyMatching()   # subclasses implement _solve_prevalence
```

--------------------------------

### Initialize and Use PPP Protocol

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/modules/protocols.rst.txt

Instantiate the PPP protocol with a specified batch size and a list of target prevalences. This protocol allows for targeted evaluation at exact operating points. The example shows iterating through splits to obtain data subsets and calculate true and predicted prevalences.

```python
from mlquantify.model_selection import PPP
from mlquantify.utils import get_prev_from_labels

protocol = PPP(batch_size=100,
               prevalences=[[0.1, 0.9], [0.5, 0.5], [0.9, 0.1]],
               random_state=42)
for idx in protocol.split(X_test, y_test):
    X_s, y_s = X_test[idx], y_test[idx]
    true_prev = get_prev_from_labels(y_s)
    pred_prev = q.predict(X_s)
```

--------------------------------

### HistogramRepresentation Fit Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.representations.BaseRepresentation.html

Shows how to fit a HistogramRepresentation to data. This example generates random data, fits the representation, and checks the shape of the resulting `class_representations_`.

```python
from mlquantify.representations import HistogramRepresentation
import numpy as np

X = np.random.default_rng(0).uniform(0, 1, (100, 1))
y = (X[:, 0] > 0.5).astype(int)
rep = HistogramRepresentation(bins=(5,)).fit(X, y)
print(rep.class_representations_.shape)
```

--------------------------------

### Full Evaluation Pipeline Example

Source: https://luizfernandolj.github.io/mlquantify/stable/model_selection_evaluation.html

Demonstrates a complete evaluation pipeline using EMQ for quantification, APP for protocol generation, MAE for error measurement, and standard scikit-learn tools for data splitting and classification.

```python
from mlquantify.likelihood import EMQ
from mlquantify.model_selection import APP
from mlquantify.metrics import MAE
from mlquantify.utils import get_prev_from_labels
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

X, y = make_classification(n_samples=2000, weights=[0.7, 0.3],
                           random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.5, random_state=42)

q = EMQ(LogisticRegression())
q.fit(X_train, y_train)

protocol = APP(batch_size=100, n_prevalences=21, repeats=10,
               random_state=42)

errors = []
for idx in protocol.split(X_test, y_test):
    X_s, y_s = X_test[idx], y_test[idx]
    tp = get_prev_from_labels(y_s)
    pp = q.predict(X_s)
    errors.append(MAE(tp, pp))

print(f"Mean MAE: {np.mean(errors):.4f} ± {np.std(errors):.4f}")

```

--------------------------------

### QuaNet Example

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/modules/neural.rst.txt

Example of using QuaNet with a Logistic Regression estimator. QuaNet requires the estimator to be pre-fitted if estimator_fitted=True is passed, otherwise it fits the estimator internally.

```python
# Requires PyTorch
from mlquantify.neural import QuaNet
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=2000, n_features=20,
                           weights=[0.7, 0.3], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42)

# QuaNet uses the classifier's predict_proba as embedding
q = QuaNet(
    estimator=LogisticRegression(),
    device='cpu',
    hidden_size=64,
    max_epoch=50,
    patience=5,
)
q.fit(X_train, y_train)
print(q.predict(X_test))
```

--------------------------------

### Example Usage of MatchingKernelQuantifier

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.matching.MatchingKernelQuantifier.html

Demonstrates how to use the MatchingKernelQuantifier class by creating a custom subclass, fitting it with sample data, and making predictions. Requires importing necessary modules from mlquantify and sklearn.

```python
>>> from mlquantify.matching._kernel import MatchingKernelQuantifier
>>> from sklearn.datasets import make_classification
>>> import numpy as np
>>> class MyKernelQ(MatchingKernelQuantifier):
...     def fit(self, X, y):
...         self.classes_ = np.unique(y)
...         return self._fit(X, y)
...     def predict(self, X):
...         return self._predict(X)
>>> X, y = make_classification(n_samples=200, random_state=42)
>>> MyKernelQ().fit(X, y).predict(X)
{0: ..., 1: ...}
```

--------------------------------

### Minimize Prevalence Blocks Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.solvers.minimize_prevalence_blocks.html

Demonstrates a toy binary example with two histogram blocks using `minimize_prevalence_blocks`. This function is useful for aggregating prevalence estimates from different blocks.

```python
import numpy as np
from mlquantify.solvers._blocks import minimize_prevalence_blocks
# Toy binary example with two histogram blocks
test_rep = np.array([0.4, 0.6, 0.3, 0.7])
train_reps = np.array([[0.5, 0.5, 0.5, 0.5],
                       [0.2, 0.8, 0.2, 0.8]])
 slices = [slice(0, 2), slice(2, 4)]
factory = lambda test_block, train_block: (
    lambda a: np.sum((test_block - ((1-a)*train_block[0] + a*train_block[1]))**2)
)
prevalence, loss = minimize_prevalence_blocks(
    factory, test_rep, train_reps, slices, n_classes=2
)
prevalence.shape
```

--------------------------------

### EnergyLoss Initialization and Basic Usage

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.losses.EnergyLoss.html

Demonstrates how to initialize the EnergyLoss object using get_loss and compute the loss with sample prevalence, cross-term vector, and distance matrix.

```python
>>> import numpy as np
>>> from mlquantify.losses import get_loss
>>> loss = get_loss("energy")
>>> p = np.array([0.4, 0.6])
>>> q = np.array([0.3, 0.7])
>>> M = np.eye(2)
>>> loss(p, q, M)
0.5599999999999999
```

--------------------------------

### Create a virtual environment (Windows)

Source: https://luizfernandolj.github.io/mlquantify/stable/install.html

Create a dedicated virtual environment for your project on Windows to manage dependencies effectively.

```bash
python -m venv mlquantify_env

```

--------------------------------

### Minimize Prevalence Example

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/solvers.html

Demonstrates how to use `minimize_prevalence` to find the optimal prevalence vector for a given objective function. This example uses the SLSQP solver for a binary classification problem.

```python
import numpy as np
from mlquantify.solvers import minimize_prevalence

def objective(p):
    target = np.array([0.4, 0.6])
    return np.sum((p - target) ** 2)

prevalences, value = minimize_prevalence(
    objective=objective,
    n_classes=2,
    solver="slsqp",
    random_state=0,
)

```

--------------------------------

### Initialize ACC with DyS and Logistic Regression

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.counting.ACC.html

This example demonstrates how to initialize the QuaDapt meta-estimator with DyS and LogisticRegression for adaptive correction. Ensure the wrapped quantifier uses soft predictions.

```python
from mlquantify.meta import QuaDapt
from mlquantify.matching import DyS
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=200, random_state=42)
q = QuaDapt(DyS(LogisticRegression())).fit(X, y)
```

--------------------------------

### PWK.get_params

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.neighbors.PWK.html

Get parameters for this estimator.

```APIDOC
## PWK.get_params

### Description
Get parameters for this estimator.

### Parameters
- **deep** (bool, default=True): If True, will return the parameters for this estimator and contained subobjects that are estimators.

### Returns
- **params** (dict): Parameter names mapped to their values.
```

--------------------------------

### EMQ Convergence Example

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/examples/plot_emq_convergence.rst.txt

This code manually implements the EMQ fixed-point iteration to observe its convergence. It simulates a shifted test sample and records the prevalence estimate at each iteration. This is useful for understanding the underlying mechanics of EMQ before using the production implementation.

```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

rng = np.random.default_rng(0)
X, y = make_classification(
    n_samples=6000, n_features=20, weights=[0.5, 0.5], random_state=0,
)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.5, random_state=0)

clf = LogisticRegression(max_iter=1000).fit(X_tr, y_tr)
train_prior = np.array([(y_tr == 0).mean(), (y_tr == 1).mean()])

# A strongly positive test sample (true positive prevalence = 0.80).
pos = np.where(y_te == 1)[0]
neg = np.where(y_te == 0)[0]
true_prev = 0.80
n = 800
idx = np.concatenate([
    rng.choice(pos, int(true_prev * n), replace=True),
    rng.choice(neg, n - int(true_prev * n), replace=True),
])
Px = clf.predict_proba(X_te[idx])

# The EMQ fixed-point iteration (same update as mlquantify's EMQ.EM).
qs = train_prior.copy()
history = [qs[1]]
for _ in range(25):
    ratio = qs / train_prior
    ps = Px * ratio
    ps /= ps.sum(axis=1, keepdims=True)
    qs = ps.mean(axis=0)
    history.append(qs[1])

fig, ax = plt.subplots(figsize=(7, 4.5))
ax.plot(history, "o-", color="#2a9d8f", label="EMQ estimate")
ax.axhline(true_prev, color="k", ls="--", lw=1, label=f"true = {true_prev:.2f}")
ax.axhline(train_prior[1], color="#e76f51", ls=":", lw=1,
           label=f"training prior = {train_prior[1]:.2f}")
ax.set_xlabel("EM iteration")
ax.set_ylabel("Estimated positive prevalence")
ax.set_title("EMQ converges from the training prior to the true prevalence")
ax.set_ylim(0, 1)
ax.legend(loc="center right")
fig.tight_layout()
```

--------------------------------

### get_params

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.compose.LinearComposeQuantifier.html

Get parameters for this estimator.

```APIDOC
## get_params(deep=True)

### Description
Get parameters for this estimator.

### Parameters
* **deep** (bool, optional) - If True, will return the parameters for this estimator and contained subobjects that are estimators. Defaults to True.

### Returns
* **params** (dict) - Parameter names mapped to their values.
```

--------------------------------

### Instantiate and Fit AggregativeBootstrap

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.meta.AggregativeBootstrap.html

Demonstrates how to initialize AggregativeBootstrap with a base quantifier (EMQ with LogisticRegression) and fit it to classification data. This sets up the object for subsequent prediction and aggregation with uncertainty.

```python
from mlquantify.meta import AggregativeBootstrap
from mlquantify.likelihood import EMQ
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=200, random_state=42)
q = AggregativeBootstrap(
    EMQ(LogisticRegression()),
    n_train_bootstraps=10,
    n_test_bootstraps=10,
).fit(X, y)
q.predict(X)
```

--------------------------------

### get_params

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.compose.BaseComposeQuantifier.html

Get parameters for this estimator.

```APIDOC
## get_params

### Description
Get parameters for this estimator.

### Parameters
#### Path Parameters
- **deep** (bool) - Optional - If True, will return the parameters for this estimator and contained subobjects that are estimators. Default is `True`.

### Returns
- **params** (dict) - Parameter names mapped to their values.
```

--------------------------------

### Initialize and Fit EDx Quantifier

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.matching.EDx.html

Demonstrates how to initialize the EDx quantifier with default parameters and fit it to a dataset. The `fit` method trains the quantifier on the provided feature matrix (X) and labels (y).

```python
from mlquantify.matching import EDx
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=200, n_classes=3, n_informative=5,
                           n_redundant=0, random_state=42)
q = EDx().fit(X, y)
q.predict(X)
```

--------------------------------

### MLPE.get_params

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.likelihood.MLPE.html

Gets the parameters of the MLPE estimator.

```APIDOC
## get_params(deep=True)

### Description
Get parameters for this estimator.

### Parameters

*   **deep** bool, default=True
    If True, will return the parameters for this estimator and contained subobjects that are estimators.

### Returns

*   **params** dict
    Parameter names mapped to their values.
```

--------------------------------

### Initialize and Fit EMQ

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.likelihood.EMQ.html

Demonstrates how to initialize an EMQ instance with a Logistic Regression estimator and fit it to sample data. It also shows how to predict prevalences and aggregate results using pre-computed posteriors.

```python
from mlquantify.likelihood import EMQ
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=200, random_state=42)
q = EMQ(estimator=LogisticRegression()).fit(X, y)
q.predict(X)

# call aggregate with pre-computed posteriors
proba_train = q.estimator_.predict_proba(X)
proba_test = q.estimator_.predict_proba(X)
q.aggregate(proba_test, proba_train, y)
```

--------------------------------

### Initialize and Fit MS Quantifier

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.counting.MS.html

Demonstrates how to initialize the MS quantifier with a base estimator and fit it to training data. Requires a classifier with predict_proba method.

```python
from mlquantify.counting import MS
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=100, n_classes=2, n_informative=5, random_state=42)
quantifier = MS(estimator=RandomForestClassifier(random_state=42))
_ = quantifier.fit(X, y)
```

--------------------------------

### GPACC.get_params

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.counting.GPACC.html

Gets the parameters of the GPACC estimator.

```APIDOC
## get_params

### Description
Get parameters for this estimator.

### Parameters

*   **deep** (bool, default=True): If True, will return the parameters for this estimator and contained subobjects that are estimators.

### Returns

*   **params** (dict): Parameter names mapped to their values.
```

--------------------------------

### Basic EnsembleQ Initialization and Usage

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/modules/ensemble.rst.txt

Demonstrates how to initialize EnsembleQ with a base quantifier (DyS with LogisticRegression), set ensemble size and protocol, and then fit and predict. Uses parallel processing for training.

```python
from mlquantify.meta import EnsembleQ
from mlquantify.matching import DyS
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=1000, weights=[0.8, 0.2],
                           random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42)

q = EnsembleQ(
    quantifier=DyS(LogisticRegression()),
    size=30,
    protocol='uniform',
    n_jobs=-1,
)
q.fit(X_train, y_train)
print(q.predict(X_test))
```

--------------------------------

### get_n_combinations

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.model_selection.BaseProtocol.html

Get the number of combinations for the current protocol.

```APIDOC
## Method get_n_combinations

Get the number of combinations for the current protocol.
```

--------------------------------

### Initialize and Fit TMAX Quantifier

Source: https://luizfernandolj.github.io/mlquantify/stable/modules/generated/mlquantify.counting.TMAX.html

Demonstrates how to initialize the TMAX quantifier with a RandomForestClassifier and fit it to sample data. Requires importing TMAX, a classifier, and data generation utilities.

```python
from mlquantify.counting import TMAX
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=100, n_classes=2, n_informative=5, random_state=42)
quantifier = TMAX(estimator=RandomForestClassifier(random_state=42))
_ = quantifier.fit(X, y)
```

--------------------------------

### Initialize and Fit QuaDapt

Source: https://luizfernandolj.github.io/mlquantify/stable/_sources/modules/ensemble.rst.txt

Initializes QuaDapt with a base quantifier and distance measure, then fits it to the training data.

```python
from mlquantify.meta import QuaDapt
   from mlquantify.matching import DyS
   from sklearn.linear_model import LogisticRegression

   q = QuaDapt(
       quantifier=DyS(LogisticRegression()),
       measure='topsoe',
       merging_factors=[0.1, 0.3, 0.5, 0.7, 0.9],
   )
   q.fit(X_train, y_train)
   print(q.predict(X_test))
```
Tokens:
Raw