bayesboom 0.2.0__tar.gz

bayesboom-0.2.0/BayesBoom/R/__init__.py

@@ -0,0 +1,183 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+from .pretty import pretty
+
+from .ls import ls
+
+from .assign_classes import assign_classes, ClassAssigner
+
+from .base import (
+    corr,
+    data_frame,
+    data_range,
+    first_true,
+    invert_order,
+    order,
+    paste,
+    paste0,
+    print_time_interval,
+    print_timestamp,
+    recycle,
+    remove_common_prefix,
+    remove_common_suffix,
+    scan,
+    table,
+    unique_match,
+    var,
+    which,
+)
+
+from .bayes import (
+    Ar1CoefficientPrior,
+    BetaPrior,
+    DirichletPrior,
+    DoubleModel,
+    GammaModel,
+    GaussianSuf,
+    MarkovModel,
+    MarkovConjugatePrior,
+    MarkovSuf,
+    MixtureComponent,
+    MultilevelMultinomialModel,
+    MultinomialModel,
+    MvnBase,
+    MvnPrior,
+    MvnGivenSigma,
+    NormalPrior,
+    NormalInverseGammaModel,
+    PoissonModel,
+    RegSuf,
+    ScottZellnerMvnPrior,
+    SdPrior,
+    UniformPrior,
+    WishartPrior,
+)
+
+from .cbind import cbind
+
+from .density import Density
+
+from .autoclean import AutoClean
+
+from .empirical_distribution import NumericEmpiricalDistribution, ECDF
+
+from .encoding import (
+    register_encoding_json_encoder,
+    Encoder,
+    MainEffectEncoder,
+    MainEffectEncoderJsonEncoder,
+    MainEffectEncoderJsonDecoder,
+    EffectEncoder,
+    OneHotEncoder,
+    IdentityEncoder,
+    InteractionEncoder,
+    MissingDummyEncoder,
+    SuccessEncoder,
+    SuccessEncoderJsonEncoder,
+    SuccessEncoderJsonDecoder,
+    DatasetEncoder,
+    DatasetEncoderJsonEncoder,
+    DatasetEncoderJsonDecoder,
+)
+
+from .frequency_distribution import FrequencyDistribution
+
+from .graphics_device import get_current_graphics_device
+
+from .lm import LinearModel, lm, AnovaTable
+
+from .mcmc import suggest_burn, report_progress
+
+from .pandas_json import (
+    PdDataFrameJsonEncoder,
+    PdDataFrameJsonDecoder,
+    PdSeriesJsonEncoder,
+    PdSeriesJsonDecoder,
+    PdIndexJsonEncoder,
+    PdIndexJsonDecoder,
+)
+
+from .plots import (
+    abline,
+    AddSegments,
+    barplot,
+    boxplot,
+    BoxplotTrue,
+    compare_den,
+    compare_dynamic_distributions,
+    ensure_ax,
+    hist,
+    histabunch,
+    hosmer_lemeshow_plot,
+    lines,
+    lty,
+    mosaic_plot,
+    pairs,
+    plot,
+    plot_dynamic_distribution,
+    PlotDynamicDistribution,
+    plot_many_ts,
+    plot_grid_shape,
+    plot_ts,
+    points,
+    time_series_boxplot,
+    )
+
+from .plot_multilevel_probabilities import (
+    plot_multilevel_probabilities,
+    BarInfo,
+)
+
+from .probability import (
+    dmvn, rmvn,
+    dnorm, pnorm, qnorm, rnorm,
+    dgamma, pgamma, qgamma, rgamma,
+    rbeta,
+    rpois,
+    rmarkov,
+)
+
+from .stats import density, sd, mean, acf, kl_divergence
+
+from .summary import (
+    summary,
+    UnivariateSummary,
+    NumericSummary,
+    CategoricalSummary,
+    HighCardinalitySummary,
+    DateTimeSummary,
+)
+
+from .test_utilities import delete_if_present
+
+from .boom_py_utils import (
+    is_all_numeric,
+    is_iterable,
+    to_boom_array,
+    to_boom_data_table,
+    to_boom_date,
+    to_boom_datetime_vector,
+    to_boom_mixed_data,
+    to_pd_datetime64,
+    to_boom_vector,
+    to_boom_matrix,
+    to_boom_labelled_matrix,
+    to_boom_spd,
+    to_numpy,
+    to_pd_dataframe,
+    to_pd_timestamp,
+)
+
+from .boom_data_builders import (
+    DataBuilder,
+    DoubleDataBuilder,
+    IntDataBuilder,
+    LabelledCategoricalDataBuilder,
+    LabelledMarkovDataBuilder,
+    MarkovSufDataBuilder,
+    MultilevelCategoricalDataBuilder,
+    UnlabelledCategoricalDataBuilder,
+    UnlabelledMarkovDataBuilder,
+    VectorDataBuilder,
+)

bayesboom-0.2.0/BayesBoom/R/assign_classes.py

@@ -0,0 +1,138 @@
+import BayesBoom.boom as boom
+from .boom_py_utils import to_boom_matrix, to_boom_vector
+import numpy as np
+import pandas as pd
+
+
+def assign_classes(posterior_class_probabilities,
+                   global_target=None,
+                   max_kl=1.0,
+                   append_prob: bool = False):
+    """
+    Assign class memberships to a collection of object, while maintaining an
+    empirical distribution of assigned classes close to a global target
+    distribution.
+
+    Args:
+      posterior_class_probabilities: A Matrix, numpy array, or DataFrame, with
+        each row corresponding to an object, and each column to a potential
+        class value.  posterior_class_probabilities[i, j] is the posterior
+        probability that object i belongs to class j.
+      global_target: A vector containing the discrete probability
+        distribution of class membership for the population.  If None, then the
+        global target is taken as the (row-)mean of the
+        posterior_class_probabilities matrix.
+      max_kl: The largest tolerable Kullback-Liebler divergence between the
+        empirical distribution of the assigned values, and the global target
+        distribution.
+      append_prob: If True then append a column to the output giving the
+        posterior probability of the assigned class.
+
+    Returns:
+      If append_prob is True then the return value is a pd.Series of integers
+      indicating the class assignment for each object.  If append_prob is True
+      then the class assignments are the first column in a two column data
+      frame.  The second column is the posterior probability of the class
+      assignement (taken from posterior_class_probabilities).
+    """
+    if global_target is None:
+        global_target = np.mean(posterior_class_probabilities, axis=0)
+
+    assigner = ClassAssigner()
+    assigner.set_max_kl(max_kl)
+    return assigner.assign(posterior_class_probabilities,
+                           global_target=global_target,
+                           append_prob=append_prob)
+
+
+class ClassAssigner:
+    """
+    Assign class memberships to a collection of object, while maintaining an
+    empirical distribution of assigned classes close to a global target
+    distribution.
+
+    A wrapper for the boom.ClassAssigner.  Wrapping allows care to be taken with
+    input types.
+    """
+
+    def __init__(self):
+        self._assigner = boom.ClassAssigner()
+
+    def set_initial_temperature(self, temp):
+        """
+        Set the temperature to use at the start of a simulated annealing run.
+        """
+        self._assigner.set_initial_temperature(float(temp))
+
+    def set_max_kl(self, kl):
+        """
+        Set the largest tolerable Kullback-Liebler divergence between the
+        empirical distribution of the assigned values, and the global
+        target distribution.
+        """
+        self._assigner.set_max_kl(float(kl))
+
+    def set_max_iterations(self, niter):
+        """
+        Set the maximum number of simulated annealing iterations (function
+        evaluations) per SA run.
+        """
+        self._assigner.set_max_iterations(int(niter))
+
+    def assign(self,
+               marginal_posteriors,
+               global_target,
+               append_prob: bool = False,
+               rng=boom.GlobalRng.rng):
+        """
+        Assign class memberships to a collection of object, while maintaining an
+        empirical distribution of assigned classes close to a global target
+        distribution.
+
+        Args:
+          marginal_posteriors: A matrix, numpy array, or DataFrame with each row
+            corresponding to an object, and each column to a potential class
+            value. marginal_posteriors[i, j] is the posterior probability that
+            object i belongs to class j.
+          global_target: A boom.Vector containing the discrete probability
+            distribution of class membership for the  population.
+          append_prob: If True then append a column to the output giving the
+            posterior probability of the assigned class.
+          rng:  A boom.RNG used to drive the simulated annealing algorithm.
+
+        Returns:
+           If append_prob is True then the return value is a pd.Series of
+           integers indicating the class assignment for each object.  If
+           append_prob is True then the class assignments are the first column
+           in a two column data frame.  The second column is the posterior
+           probability of the class assignement (taken from
+           posterior_class_probabilities).
+        """
+        return_index = getattr(marginal_posteriors, "index", None)
+
+        ans = self._assigner.assign(
+            to_boom_matrix(marginal_posteriors),
+            to_boom_vector(global_target),
+            rng=rng)
+        if append_prob:
+            post = np.array(marginal_posteriors)
+            nobs = post.shape[0]
+            prob = post[range(nobs), ans]
+            ans = pd.DataFrame(
+                {
+                    "class": ans,
+                    "prob": prob,
+                },
+                index=return_index
+            )
+        else:
+            ans = pd.Series(ans, index=return_index, dtype="int")
+        return ans
+
+    @property
+    def kl(self):
+        """
+        The Kullback-Liebler divergence between the most recently produced
+        set of assignments and the global target distribution.
+        """
+        return self._assigner.kl