mlquantify 0.1.23__tar.gz → 0.1.25__tar.gz

{mlquantify-0.1.23/mlquantify.egg-info → mlquantify-0.1.25}/PKG-INFO

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

mlquantify-0.1.25/VERSION.txt

@@ -0,0 +1 @@
+0.1.25

{mlquantify-0.1.23 → mlquantify-0.1.25}/mlquantify/adjust_counting/_adjustment.py

@@ -208,24 +208,23 @@ class MatrixAdjustment(BaseAdjustCount):
         pp. 1-8.
     """
 
-
     _parameter_constraints = {"solver": Options(["optim", "linear"])}
 
     def __init__(self, learner=None, solver=None):
         super().__init__(learner=learner)
         self.solver = solver
     
-    def _adjust(self, predictions, train_y_pred, y_train):
+    def _adjust(self, predictions, train_predictions, y_train):
         n_class = len(np.unique(y_train))
         self.CM = np.zeros((n_class, n_class))
-
         if self.solver == 'optim':
-            priors = np.array(list(CC().aggregate(train_y_pred, y_train).values()))
-            self.CM = self._compute_confusion_matrix(train_y_pred, y_train, priors)
+            class_counts = np.array([np.count_nonzero(y_train == _class) for _class in self.classes_])
+            priors = class_counts / len(y_train)
+            self.CM = self._compute_confusion_matrix(train_predictions, y_train, priors)
             prevs_estim = self._get_estimations(predictions > priors, y_train)
             prevalence = self._solve_optimization(prevs_estim, priors)
         else:
-            self.CM = self._compute_confusion_matrix(train_y_pred, y_train)
+            self.CM = self._compute_confusion_matrix(train_predictions, y_train)
             prevs_estim = self._get_estimations(predictions, y_train)
             prevalence = self._solve_linear(prevs_estim)
         
@@ -244,26 +243,31 @@ class MatrixAdjustment(BaseAdjustCount):
         return adjusted
 
     def _solve_optimization(self, prevs_estim, priors):
-        r"""Solve the system linearly.
+        r"""Solve the system using constrained optimization.
 
-        The solution is obtained by matrix inversion:
+        The solution is obtained by minimizing the discrepancy:
 
-        .. math::
+            || C @ \hat{\pi}_F - p ||
 
-            \hat{\pi}_F = \mathbf{C}^{-1} \mathbf{p}
+        subject to the constraints:
 
-        where :math:`\mathbf{C}` is the confusion matrix and :math:`\mathbf{p}` 
-        is the observed prevalence vector.
+            \hat{\pi}_F \ge 0,  sum_k \hat{\pi}_{F,k} = 1
+
+        where:
+            - C is the confusion matrix,
+            - p is the observed prevalence vector from the test set.
 
         Parameters
         ----------
-        p : ndarray of shape (n_classes,)
-            Observed prevalence vector from test set.
+        prevs_estim : ndarray of shape (n_classes,)
+            Observed prevalence vector from the test set.
+        priors : ndarray of shape (n_classes,)
+            Fallback class prior vector used if optimization fails.
 
         Returns
         -------
         ndarray of shape (n_classes,)
-            Adjusted prevalence estimates :math:`\hat{\pi}_F`.
+            Adjusted prevalence estimates \hat{\pi}_F.
         """
         def objective(prevs_pred):
             return np.linalg.norm(self.CM @ prevs_pred - prevs_estim)
@@ -294,19 +298,27 @@ class CDE(SoftLearnerQMixin, AggregationMixin, BaseQuantifier):
     r"""CDE-Iterate for binary classification prevalence estimation.
 
     Threshold :math:`\tau` from false positive and false negative costs:
+
     .. math::
+
         \tau = \frac{c_{FP}}{c_{FP} + c_{FN}}
 
     Hard classification by thresholding posterior probability :math:`p(+|x)` at :math:`\tau`:
+
     .. math::
+
         \hat{y}(x) = \mathbf{1}_{p(+|x) > \tau}
 
     Prevalence estimation via classify-and-count:
+
     .. math::
+
         \hat{p}_U(+) = \frac{1}{N} \sum_{n=1}^N \hat{y}(x_n)
 
     False positive cost update:
+    
     .. math::
+
         c_{FP}^{new} = \frac{p_L(+)}{p_L(-)} \times \frac{\hat{p}_U(-)}{\hat{p}_U(+)} \times c_{FN}
 
     Parameters
@@ -365,6 +377,31 @@ class CDE(SoftLearnerQMixin, AggregationMixin, BaseQuantifier):
 
 
     def aggregate(self, predictions, y_train):
+        """Aggregate predictions and apply matrix- or rate-based bias correction. 
+        
+        Parameters
+        ----------
+        predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on test data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        y_train : ndarray of shape (n_samples,)
+            True class labels of the training data.
+        
+        Returns
+        -------
+        ndarray of shape (n_classes,)
+            Class prevalence estimates.
+
+        Examples
+        --------
+        >>> from mlquantify.adjust_counting import CDE
+        >>> import numpy as np
+        >>> q = CDE()
+        >>> predictions = np.random.rand(200)
+        >>> train_predictions = np.random.rand(200) # generated via cross-validation
+        >>> y_train = np.random.randint(0, 2, 200)
+        >>> q.aggregate(predictions, train_predictions, y_train)
+        {0: 0.51, 1: 0.49}
+        """
 
         self.classes_ = check_classes_attribute(self, np.unique(y_train))
         predictions = validate_predictions(self, predictions)
@@ -465,7 +502,7 @@ class FM(SoftLearnerQMixin, MatrixAdjustment):
         \min_{\hat{\pi}_F} \| \mathbf{C} \hat{\pi}_F - \mathbf{p} \|^2
 
     subject to constraints:
-
+    
     .. math::
 
         \hat{\pi}_F \geq 0, \quad \sum_k \hat{\pi}_{F,k} = 1
@@ -478,7 +515,7 @@ class FM(SoftLearnerQMixin, MatrixAdjustment):
     ----------
     learner : estimator, optional
         Base classifier with `fit` and `predict_proba` methods.
-        If None, a default estimator will be used.
+        If None, it is expected that user will use the `aggregate` method directly.
 
     Attributes
     ----------
@@ -505,13 +542,28 @@ class FM(SoftLearnerQMixin, MatrixAdjustment):
     def __init__(self, learner=None):
         super().__init__(learner=learner, solver='optim')
     
-    def _compute_confusion_matrix(self, posteriors, y_true, priors):
+    def _compute_confusion_matrix(self, predictions, y_true, priors):
+        n_classes = len(self.classes_)
+        self.CM = np.zeros((n_classes, n_classes))
+
         for i, _class in enumerate(self.classes_):
             indices = (y_true == _class)
-            self.CM[:, i] = self._get_estimations(posteriors[indices] > priors, y_true[indices])
+            preds_sub = predictions[indices]
+
+            mask = preds_sub > priors               # (n_i, n_classes)
+            masked = np.where(mask, preds_sub, -np.inf)
+            best_classes = np.argmax(masked, axis=1)
+
+            hard_preds = np.zeros_like(preds_sub, dtype=bool)
+            rows = np.arange(preds_sub.shape[0])
+            hard_preds[rows, best_classes] = True
+
+            self.CM[:, i] = self._get_estimations(hard_preds, y_true[indices])
+        
         return self.CM
 
 
+
 class AC(CrispLearnerQMixin, MatrixAdjustment):
     r"""Adjusted Count method.
 

{mlquantify-0.1.23 → mlquantify-0.1.25}/mlquantify/adjust_counting/_base.py

@@ -114,7 +114,6 @@ class BaseCount(AggregationMixin, BaseQuantifier):
     
     @abstractmethod
     def aggregate(self, predictions):
-        """Aggregate predictions into class prevalence estimates."""
         ...
 
 
@@ -156,7 +155,7 @@ class BaseAdjustCount(AggregationMixin, BaseQuantifier):
     Parameters
     ----------
     learner : object, optional
-        Supervised learner implementing `fit`, `predict`, or `predict_proba`.
+        Supervised learner implementing `fit` and (`predict` or `predict_proba`) depending on the quantifier.
 
     Attributes
     ----------
@@ -164,7 +163,7 @@ class BaseAdjustCount(AggregationMixin, BaseQuantifier):
         Underlying classification model.
     train_predictions : ndarray of shape (n_samples_train, n_classes)
         Predictions on training data from cross-validation.
-    train_y_values : ndarray of shape (n_samples_train,)
+    y_train : ndarray of shape (n_samples_train,)
         True labels corresponding to training predictions.
     classes : ndarray of shape (n_classes,)
         Unique class labels.
@@ -225,17 +224,44 @@ class BaseAdjustCount(AggregationMixin, BaseQuantifier):
             )
         
         self.train_predictions = train_predictions
-        self.train_y_values = y_train_labels
+        self.y_train = y_train_labels
         return self
     
     def predict(self, X):
         """Predict class prevalences for the given data."""
+        X = validate_data(self, X)
         predictions = getattr(self.learner, _get_learner_function(self))(X)
-        prevalences = self.aggregate(predictions, self.train_predictions, self.train_y_values)
+        prevalences = self.aggregate(predictions, self.train_predictions, self.y_train)
         return prevalences
 
     def aggregate(self, predictions, train_predictions, y_train):
-        """Aggregate predictions and apply matrix- or rate-based bias correction."""
+        """Aggregate predictions and apply matrix- or rate-based bias correction. 
+        
+        Parameters
+        ----------
+        predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on test data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        train_predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on training data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        y_train : ndarray of shape (n_samples,)
+            True class labels of the training data.
+        
+        Returns
+        -------
+        ndarray of shape (n_classes,)
+            Class prevalence estimates.
+
+        Examples
+        --------
+        >>> from mlquantify.adjust_counting import AC
+        >>> import numpy as np
+        >>> q = AC()
+        >>> predictions = np.random.rand(200)
+        >>> train_predictions = np.random.rand(200) # generated via cross-validation
+        >>> y_train = np.random.randint(0, 2, 200)
+        >>> q.aggregate(predictions, train_predictions, y_train)
+        {0: 0.51, 1: 0.49}
+        """
         self.classes_ = check_classes_attribute(self, np.unique(y_train))
         
         predictions = validate_predictions(self, predictions)

{mlquantify-0.1.23 → mlquantify-0.1.25}/mlquantify/adjust_counting/_counting.py

@@ -15,7 +15,7 @@ class CC(CrispLearnerQMixin, BaseCount):
     r"""Classify and Count (CC) quantifier.
 
     Implements the Classify and Count method for quantification, describe as a
-    baseline approach in the literature [1][2].
+    baseline approach in the literature [1]_, [2]_.
 
     Parameters
     ----------
@@ -51,17 +51,15 @@ class CC(CrispLearnerQMixin, BaseCount):
     >>> q.fit(X, y)
     >>> q.predict(X)
     {0: 0.47, 1: 0.53}
-    >>> q2 = CC()
-    >>> predictions = np.random.rand(200)
-    >>> q2.aggregate(predictions)
-    {0: 0.51, 1: 0.49}
 
     References
     ----------
-    .. [1] Forman, G. (2005). "Counting Positives Accurately Despite Inaccurate Classification",
-           *ECML*, pp. 564-575.
-    .. [2] Forman, G. (2008). "Quantifying Counts and Costs via Classification",
-           *Data Mining and Knowledge Discovery*, 17(2), 164-206.
+    .. dropdown:: References
+
+        .. [1] Forman, G. (2005). "Counting Positives Accurately Despite Inaccurate Classification",
+            *ECML*, pp. 564-575.
+        .. [2] Forman, G. (2008). "Quantifying Counts and Costs via Classification",
+            *Data Mining and Knowledge Discovery*, 17(2), 164-206.
     """
     
     _parameters_constraints = {
@@ -76,6 +74,29 @@ class CC(CrispLearnerQMixin, BaseCount):
         self.threshold = threshold
 
     def aggregate(self, predictions, y_train=None):
+        """Aggregate predictions into class prevalence estimates. 
+        
+        Parameters
+        ----------
+        predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on test data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        y_train : ndarray of shape (n_samples,)
+            True class labels of the training data. None by default.
+        
+        Returns
+        -------
+        ndarray of shape (n_classes,)
+            Class prevalence estimates.
+
+        Examples
+        --------
+        >>> from mlquantify.adjust_counting import CC
+        >>> import numpy as np
+        >>> q = CC()
+        >>> predictions = np.random.rand(200)
+        >>> q.aggregate(predictions)
+        {0: 0.51, 1: 0.49}
+        """
         predictions = validate_predictions(self, predictions, self.threshold, y_train)
         
         if y_train is None:
@@ -92,12 +113,8 @@ class CC(CrispLearnerQMixin, BaseCount):
 class PCC(SoftLearnerQMixin, BaseCount):
     r"""Probabilistic Classify and Count (PCC) quantifier.
     
-    Implements the Probabilistic Classify and Count method for quantification as described in:
-    [1] Forman, G. (2005). *Counting Positives Accurately Despite Inaccurate Classification.*
-        ECML, pp. 564-575.
-    [2] Forman, G. (2008). *Quantifying Counts and Costs via Classification.*
-        Data Mining and Knowledge Discovery, 17(2), 164-206.
-        
+    Implements the Probabilistic Classify and Count method for quantification as described in [1]_, [2]_:
+    
         
     Parameters
     ----------
@@ -112,6 +129,11 @@ class PCC(SoftLearnerQMixin, BaseCount):
         Underlying classification model.
     classes : ndarray of shape (n_classes,)
         Unique class labels observed during training.
+
+    .. dropdown:: References
+    
+        .. [1] Forman, G. (2005). *Counting Positives Accurately Despite Inaccurate Classification.* ECML, pp. 564-575.
+        .. [2] Forman, G. (2008). *Quantifying Counts and Costs via Classification.* Data Mining and Knowledge Discovery, 17(2), 164-206.
         
         
     Examples
@@ -125,16 +147,35 @@ class PCC(SoftLearnerQMixin, BaseCount):
     >>> q.fit(X, y)
     >>> q.predict(X)
     {0: 0.48, 1: 0.52}
-    >>> q2 = PCC()
-    >>> predictions = np.random.rand(200, 2)
-    >>> q2.aggregate(predictions)
-    {0: 0.50, 1: 0.50}
     """
 
     def __init__(self, learner=None):
         super().__init__(learner=learner)
 
     def aggregate(self, predictions, y_train=None):
+        """Aggregate predictions into class prevalence estimates. 
+        
+        Parameters
+        ----------
+        predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on test data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        y_train : ndarray of shape (n_samples,)
+            True class labels of the training data. None by default.
+        
+        Returns
+        -------
+        ndarray of shape (n_classes,)
+            Class prevalence estimates.
+
+        Examples
+        --------
+        >>> from mlquantify.adjust_counting import PCC
+        >>> import numpy as np
+        >>> q = PCC()
+        >>> predictions = np.random.rand(200, 2)
+        >>> q.aggregate(predictions)
+        {0: 0.50, 1: 0.50}
+        """
         predictions = validate_predictions(self, predictions)
         
         # Handle categorical predictions (1D array with class labels)

{mlquantify-0.1.23 → mlquantify-0.1.25}/mlquantify/confidence.py

@@ -96,14 +96,15 @@ class ConfidenceInterval(BaseConfidenceRegion):
     The confidence region is defined as:
 
     .. math::
-        CI_α(π) = 
-        \\begin{cases}
-        1 & \\text{if } L_i \\le π_i \\le U_i, \\forall i=1,...,n \\\\
-        0 & \\text{otherwise}
-        \\end{cases}
 
-    where :math:`L_i` and :math:`U_i` are the empirical 
-    α/2 and 1−α/2 quantiles for class i.
+        CI_{\alpha}(\pi) =
+        \begin{cases}
+        1 & \text{if } L_i \le \pi_i \le U_i, \forall i=1,\dots,n \\
+        0 & \text{otherwise}
+        \end{cases}
+
+    where :math:`L_i` and :math:`U_i` are the empirical
+    :math:`\alpha/2` and :math:`1-\alpha/2` quantiles for class :math:`i`.
 
     Parameters
     ----------
@@ -163,11 +164,12 @@ class ConfidenceEllipseSimplex(BaseConfidenceRegion):
     Defines a multivariate confidence region based on a chi-squared threshold:
 
     .. math::
-        CE_α(π) =
-        \\begin{cases}
-        1 & \\text{if } (π - μ)^T Σ^{-1} (π - μ) \\le χ^2_{n-1}(1-α) \\\\
-        0 & \\text{otherwise}
-        \\end{cases}
+
+        CE_{\alpha}(\pi) =
+        begin{cases}
+        1 & \text{if} (\pi - \mu)^T \Sigma^{-1} (\pi - \mu) \le \chi^2_{n-1}(1-\alpha) \\
+        0 & \text{otherwise}
+        end{cases}
 
     Parameters
     ----------
@@ -237,17 +239,18 @@ class ConfidenceEllipseCLR(ConfidenceEllipseSimplex):
     Applies the Centered Log-Ratio (CLR) transformation:
 
     .. math::
-        T(π) = [\log(π_1/g(π)), ..., \log(π_n/g(π))], \\
-        g(π) = (\prod_i π_i)^{1/n}
+
+        T(\pi) = [\log(\pi_1/g(\pi)), ..., \log(\pi_n/g(\pi))], g(\pi) = (\prod_i \pi_i)^{1/n}
 
     A confidence ellipse is then built in the transformed space:
 
     .. math::
-        CT_α(π) =
-        \\begin{cases}
-        1 & \\text{if } (T(π) - μ_{CLR})^T Σ^{-1} (T(π) - μ_{CLR}) \\le χ^2_{n-1}(1-α) \\\\
-        0 & \\text{otherwise}
-        \\end{cases}
+    
+        CT_\alpha(\pi) =
+        \begin{cases}
+        1 & \text{if } (T(\pi) - \mu_{CLR})^T \Sigma^{-1} (T(\pi) - \mu_{CLR}) \le \chi^2_{n-1}(1-\alpha) \\
+        0 & \text{otherwise}
+        \end{cases}
 
     Parameters
     ----------

{mlquantify-0.1.23 → mlquantify-0.1.25}/mlquantify/likelihood/_classes.py

@@ -16,36 +16,53 @@ class EMQ(SoftLearnerQMixin, AggregationMixin, BaseQuantifier):
     Estimates class prevalences under prior probability shift by alternating 
     between expectation **(E)** and maximization **(M)** steps on posterior probabilities. 
 
-    E-step:
-    .. math::
-        p_i^{(s+1)}(x) = \frac{q_i^{(s)} p_i(x)}{\sum_j q_j^{(s)} p_j(x)}
+    .. dropdown:: Mathematical Formulation
 
-    M-step:
-    .. math::
-        q_i^{(s+1)} = \frac{1}{N} \sum_{n=1}^N p_i^{(s+1)}(x_n)
+        E-step:
 
-    where 
-    - :math:`p_i(x)` are posterior probabilities predicted by the classifier
-    - :math:`q_i^{(s)}` are class prevalence estimates at iteration :math:`s`
-    - :math:`N` is the number of test instances.
+        .. math::
 
-    Calibrations supported on posterior probabilities before **EM** iteration:
+            p_i^{(s+1)}(x) = \frac{q_i^{(s)} p_i(x)}{\sum_j q_j^{(s)} p_j(x)}
 
-    Temperature Scaling (TS):
-    .. math::
-        \hat{p} = \text{softmax}\left(\frac{\log(p)}{T}\right)
+        M-step:
 
-    Bias-Corrected Temperature Scaling (BCTS):
-    .. math::
-        \hat{p} = \text{softmax}\left(\frac{\log(p)}{T} + b\right)
+        .. math::
 
-    Vector Scaling (VS):
-    .. math::
-        \hat{p}_i = \text{softmax}(W_i \cdot \log(p_i) + b_i)
+            q_i^{(s+1)} = \frac{1}{N} \sum_{n=1}^N p_i^{(s+1)}(x_n)
 
-    No-Bias Vector Scaling (NBVS):
-    .. math::
-        \hat{p}_i = \text{softmax}(W_i \cdot \log(p_i))
+        where:
+
+        - :math:`p_i(x)` are posterior probabilities predicted by the classifier
+
+        - :math:`q_i^{(s)}` are class prevalence estimates at iteration :math:`s`
+
+        - :math:`N` is the number of test instances.
+
+        Calibrations supported on posterior probabilities before **EM** iteration:
+
+        Temperature Scaling (TS):
+
+        .. math::
+
+            \hat{p} = \text{softmax}\left(\frac{\log(p)}{T}\right)
+
+        Bias-Corrected Temperature Scaling (BCTS):
+
+        .. math::
+
+            \hat{p} = \text{softmax}\left(\frac{\log(p)}{T} + b\right)
+
+        Vector Scaling (VS):
+
+        .. math::
+
+            \hat{p}_i = \text{softmax}(W_i \cdot \log(p_i) + b_i)
+
+        No-Bias Vector Scaling (NBVS):
+
+        .. math::
+
+            \hat{p}_i = \text{softmax}(W_i \cdot \log(p_i))
 
     Parameters
     ----------

{mlquantify-0.1.23 → mlquantify-0.1.25}/mlquantify/utils/_validation.py

@@ -94,12 +94,12 @@ def validate_y(quantifier: Any, y: np.ndarray) -> None:
             f"Predictions must be 1D or 2D array, got array with ndim={y.ndim} and shape={y.shape}."
         )
 
-def _get_valid_crisp_predictions(predictions, train_y_values=None, threshold=0.5):
+def _get_valid_crisp_predictions(predictions, y_train=None, threshold=0.5):
     predictions = np.asarray(predictions)
     dimensions = predictions.ndim
 
-    if train_y_values is not None:
-        classes = np.unique(train_y_values)
+    if y_train is not None:
+        classes = np.unique(y_train)
     else:
         classes = None
 
@@ -138,7 +138,7 @@ def _get_valid_crisp_predictions(predictions, train_y_values=None, threshold=0.5
     return predictions
 
 
-def validate_predictions(quantifier: Any, predictions: np.ndarray, threshold: float = 0.5, train_y_values=None) -> np.ndarray:
+def validate_predictions(quantifier: Any, predictions: np.ndarray, threshold: float = 0.5, y_train=None) -> np.ndarray:
     """
     Validate predictions using the quantifier's declared output tags.
     Raises InputValidationError if inconsistent with tags.
@@ -158,7 +158,7 @@ def validate_predictions(quantifier: Any, predictions: np.ndarray, threshold: fl
             f"Soft predictions for {quantifier.__class__.__name__} must be float, got dtype {predictions.dtype}."
         )
     elif estimator_type == "crisp" and np.issubdtype(predictions.dtype, np.floating):
-        predictions = _get_valid_crisp_predictions(predictions, train_y_values, threshold) 
+        predictions = _get_valid_crisp_predictions(predictions, y_train, threshold) 
     return predictions   
     
     
@@ -379,12 +379,6 @@ def validate_prevalences(quantifier, prevalences: np.ndarray | list | dict, clas
             f"prevalences must be a numpy array, list, or dict, got {type(prevalences).__name__}."
         )
     
-    # Validate all classes are present
-    if set(prev_dict.keys()) != set(classes):
-        raise InputValidationError(
-            f"prevalences keys must match classes. Got keys {set(prev_dict.keys())}, expected {set(classes)}."
-        )
-    
     # Normalize if requested
     if normalize:
         total = sum(prev_dict.values())

{mlquantify-0.1.23 → mlquantify-0.1.25/mlquantify.egg-info}/PKG-INFO

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

mlquantify-0.1.23/VERSION.txt

@@ -1 +0,0 @@
-0.1.23