BayesianEstimationTool 1.0.0__py3-none-any.whl

BayesianEstimationTool/BayesianEstimationTool_CheatSheet.py

@@ -0,0 +1,245 @@
+"""Generate BayesianEstimationTool_CheatSheet.pdf.
+
+The cheat-sheet content is intentionally kept at the top of this file so this
+source is useful as a readable reference even without generating the PDF.
+
+Dependency:
+    pip install reportlab
+
+Run:
+    python BayesianEstimationTool_CheatSheet.py
+
+The PDF is written beside this file. The generator uses only ReportLab's
+built-in Helvetica/Courier PDF fonts, so it does not depend on system fonts.
+It automatically chooses the largest body font that keeps the cheat sheet on
+one US Letter page.
+"""
+
+
+# -----------------------------------------------------------------------------
+# Cheat-sheet content
+# -----------------------------------------------------------------------------
+
+TITLE = "BayesianEstimationTool (BET) Cheat Sheet"
+
+PURPOSE = (
+    "`Estimator` organizes hierarchical Bayesian estimation for datasets containing multiple related "
+    "entries. Models may contain global parameters shared across entries and standardized local Zs that vary by "
+    "entry. `Train` infers the population/global posterior, training local Zs, and local-Z correlation. `Test` carries "
+    "the learned population state to new entries and can either sample locals from the trained population or infer them from "
+    "new observations with a method. `ScoreTrainSamples` and `ScoreTestSamples` evaluate predictions. `Save` and `Load` preserve the "
+    "learned state and the settings needed to reconstruct how estimation was performed. Inference is supplied through an "
+    "Method interface; built-in methods include NUTS and SVI."
+)
+
+DEPENDENCIES = "jax, numpyro, numpy"
+
+INSTALLATION = (
+    "Install in editable mode with `python -m pip install -e \"/path/to/BayesianEstimationTool\"` then import with "
+    "`import BayesianEstimationTool as bet`. Editable installation means "
+    "repository code changes are used without reinstalling. For repository examples, the parent folder may instead be added "
+    "to `sys.path`."
+)
+
+CONVENTIONS = [
+    ("`import BayesianEstimationTool as bet`", "Public import; construct the main object with `bet.Estimator(...)` and supply inference through the `Method` argument."),
+    ("`arg{}`", "dictionary whose values have no entry dimension; used for one entry's data, local Zs, model output, globals, or other named values."),
+    ("`arg{[]}`", "dictionary containing arrays spanning multiple entries or posterior samples."),
+    ("`arg[]`", "1D sequence."),
+    ("`Fn(...) -> value`", "function argument or method together with the value it returns."),
+    ("`globalDistributions{}`", "global-parameter prior dictionary: `{name: NumPyro distribution}`. BET creates the NumPyro sample sites internally; the dictionary keys become the global parameter names."),
+    ("`likelihoods{}`", "single-entry likelihood dictionary: `{name: (observation, distribution)}`. BET vectorizes it across entries and creates the NumPyro observation sites internally."),
+    ("*Italic arguments*", "accept `None` as a valid input."),
+]
+
+FUNCTIONS = [
+    (
+        'Estimator(data{[]}, ModelFn(globalParams{}, localZs{}, data{}) -> modelOut{}, *localZNames[]*, *GlobalPriorFn(dataShapes{}) -> globalDistributions{}*, lkjConcentration=2.0, *rngSeed*) -> Estimator',
+        "Creates an Estimator. **localZNames** defines standardized entry-level parameters. With multiple locals, the Estimator learns their correlation with an LKJ Cholesky prior controlled by **lkjConcentration**. **GlobalPriorFn** receives the per-entry shapes of the full data and returns `{name: NumPyro distribution}`. BET creates the named NumPyro sample sites and passes their sampled values to **ModelFn** and likelihood functions as `globalParams{}`. **rngSeed** initializes the Estimator's persistent RNG.",
+    ),
+    (
+        'Train(trainDataIdxs[], TrainLikelihoodFn(globalParams{}, localZs{}, data{}, modelOut{}) -> likelihoods{}, Method=method, printSummary=False, *rngSeed*, saveLocalZs=True, saveModelOut=False) -> methodOutput',
+        "Fits **trainDataIdxs** using **Method**. **TrainLikelihoodFn** is evaluated one entry at a time and returns `{name: (observation, NumPyro distribution)}`; BET batches the returned observations/distributions and creates the observation sites internally. A Method instance supplies an explicit configuration. A Method class reconstructs the saved training Method arguments; if its class name differs from the saved Method name, BET warns and still attempts reconstruction. The Estimator stores global posterior samples and the learned Cholesky state; **saveLocalZs** stores transformed training-local Z samples and **saveModelOut** stores model-output samples. **printSummary** uses the Estimator's generic posterior summary unless the Method replaces or augments it.",
+    ),
+    (
+        'Test(testDataIdxs[], *TestLikelihoodFn(globalParams{}, localZs{}, data{}, modelOut{}) -> likelihoods{}*, *Method=method*, *nGlobalSamples*, nLocalZSamples=2000, printSummary=False, *rngSeed*, saveModelOut=False) -> None | methodOutput[]',
+        'Tests on new entries. **TestLikelihoodFn**, when supplied, follows the same single-entry `{name: (observation, distribution)}` contract as training. **nGlobalSamples=None** uses the median trained global/Cholesky state; a positive integer samples that many trained states. With **TestLikelihoodFn=None**, no Method is needed and the Estimator draws **nLocalZSamples** locals from the trained population. With a likelihood, a Method instance supplies an explicit configuration. A Method class reconstructs saved arguments: BET uses the previous Method-based test configuration when available, otherwise the training configuration. If the supplied class name differs from the saved Method name, BET warns and still attempts reconstruction.',
+    ),
+    (
+        'ScoreTrainSamples(ScoreFn(modelOut{}, data{}) -> score{}, *nSamples*, *rngSeed*) -> scores{[]}',
+        'Scores training predictions. **nSamples=None** uses all available joint training-posterior samples; otherwise the Estimator selects that many. Saved model outputs are reused when available, otherwise they are regenerated from saved parameters.',
+    ),
+    (
+        'ScoreTestSamples(ScoreFn(modelOut{}, data{}) -> score{}, *nSamples*, *rngSeed*) -> scores{[]}',
+        'Scores the latest test state. **nSamples=None** uses all stored local Z samples; otherwise that many are selected for each stored global state. Saved model outputs are reused when available, otherwise they are regenerated.',
+    ),
+    (
+        'Save(*fileName*, saveTrainLocalZs=True, saveTestLocalZs=True, saveTrainModelOut=False, saveTestModelOut=False, saveAllData=False) -> None | record{}',
+        'Writes compressed `.npz` state, or returns a nested record when **fileName=None**. Saved metadata includes method class names and constructor arguments so the estimation setup can be reconstructed without serializing method machinery. Functions are not serialized.',
+    ),
+    (
+        'Estimator.Load(fileName, *ModelFn*, *GlobalPriorFn*, *data*) -> Estimator | record{}',
+        'Loads saved state. With **ModelFn=None**, returns the saved record without reconstructing an Estimator. Otherwise model functions are supplied explicitly; **data** is required unless the data were saved with `saveAllData=True`.',
+    ),
+    (
+        'Nuts(numWarmup=2000, numSamples=2000, numChains=4, acceptProb=0.95, denseMass=False, medianSamples=50) -> Nuts',
+        'Creates a NUTS inference Method, exposed as `bet.Nuts`. Pass `bet.Nuts(...)` for an explicit configuration or `bet.Nuts` to reconstruct saved Method arguments. **medianSamples** controls `init_to_median`; **acceptProb** is the target acceptance probability. NUTS retains posterior samples from the MCMC trajectory and prints NumPyro convergence diagnostics including n_eff and r_hat.',
+    ),
+    (
+        'Svi(numSteps=10000, numSamples=2000, stepSize=0.01, numParticles=1, progressBar=True, medianSamples=50, multivariate=False) -> Svi',
+        'Creates an SVI inference Method, exposed as `bet.Svi`. Pass `bet.Svi(...)` for an explicit configuration or `bet.Svi` to reconstruct saved Method arguments. Uses `init_to_median`; **numSamples** is the number of posterior samples drawn from the fitted guide for the Estimator. By default the guide is mean-field `AutoNormal`; **multivariate=True** uses `AutoMultivariateNormal`, which can represent posterior covariance but scales less favorably for large latent spaces.',
+    ),
+]
+
+
+# -----------------------------------------------------------------------------
+# PDF generation
+# -----------------------------------------------------------------------------
+
+from pathlib import Path
+import html
+import re
+
+try:
+    from reportlab.lib import colors
+    from reportlab.lib.pagesizes import letter
+    from reportlab.lib.units import inch
+    from reportlab.platypus import BaseDocTemplate, Frame, KeepTogether, PageTemplate, Paragraph
+    from reportlab.lib.styles import ParagraphStyle
+except ImportError as exc:
+    raise SystemExit(
+        "Generating the PDF requires ReportLab. Install it with: pip install reportlab"
+    ) from exc
+
+
+OUTPUT_FILE = Path(__file__).with_name("BayesianEstimationTool_CheatSheet.pdf")
+MIN_BODY_FONT = 7.0
+MAX_BODY_FONT = 11.5
+FONT_STEP = 0.1
+
+
+def _markup(text):
+    """Convert the tiny readable markup used above to ReportLab paragraph markup."""
+    text = html.escape(text, quote=False).replace("->", "->")
+    text = re.sub(r"`([^`]+)`", r"<font name='Courier'>\1</font>", text)
+    text = re.sub(r"\*\*([^*]+)\*\*", r"<b>\1</b>", text)
+    text = re.sub(r"\*([^*]+)\*", r"<i>\1</i>", text)
+    return text
+
+
+def _signature_markup(text):
+    """Render signatures bold overall, with None-accepting arguments italicized."""
+    text = html.escape(text, quote=False).replace("->", "-&gt;")
+    text = re.sub(r"\*([^*]+)\*", r"<i>\1</i>", text)
+    return text
+
+
+def _build_pdf(body_font):
+    """Build the PDF at one candidate font size and return its page count."""
+    page_width, page_height = letter
+    margin = 0.38 * inch
+    header_height = 0.38 * inch
+    usable_height = page_height - 2 * margin - header_height
+
+    frame = Frame(
+        margin,
+        margin,
+        page_width - 2 * margin,
+        usable_height,
+        leftPadding=4,
+        rightPadding=4,
+        topPadding=2,
+        bottomPadding=2,
+    )
+
+    def draw_header(canvas, doc):
+        canvas.saveState()
+        canvas.setFont("Helvetica-Bold", 16)
+        canvas.drawString(margin, page_height - margin - 10, TITLE)
+        canvas.setStrokeColor(colors.HexColor("#888888"))
+        canvas.setLineWidth(0.5)
+        canvas.line(margin, page_height - margin - 16, page_width - margin, page_height - margin - 16)
+        canvas.restoreState()
+
+    purpose_style = ParagraphStyle(
+        "Purpose",
+        fontName="Helvetica",
+        fontSize=body_font + 0.8,
+        leading=(body_font + 0.8) * 1.18,
+        spaceAfter=4,
+    )
+    heading_style = ParagraphStyle(
+        "Heading",
+        fontName="Helvetica-Bold",
+        fontSize=body_font + 2.5,
+        leading=(body_font + 2.5) * 1.12,
+        spaceBefore=2.5,
+        spaceAfter=4.0,
+    )
+    conventions_style = ParagraphStyle(
+        "Conventions",
+        fontName="Helvetica",
+        fontSize=body_font,
+        leading=body_font * 1.18,
+        spaceAfter=2.5,
+        backColor=colors.HexColor("#F4F4F4"),
+        borderPadding=4,
+    )
+    entry_style = ParagraphStyle(
+        "Entry",
+        fontName="Helvetica",
+        fontSize=body_font,
+        leading=body_font * 1.17,
+        spaceBefore=2.2,
+        spaceAfter=1.6,
+        leftIndent=14,
+        firstLineIndent=-14,
+    )
+
+    convention_lines = [f"<b>{_markup(symbol)}</b> - {_markup(description)}" for symbol, description in CONVENTIONS]
+
+    story = [
+        Paragraph("<b>Purpose:</b> " + _markup(PURPOSE) + "<br/><b>Dependencies:</b> " + _markup(DEPENDENCIES) + "<br/><b>Installation:</b> " + _markup(INSTALLATION), purpose_style),
+        Paragraph("Conventions", heading_style),
+        Paragraph("<br/>".join(convention_lines), conventions_style),
+        Paragraph("Main Functions", heading_style),
+    ]
+
+    for signature, description in FUNCTIONS:
+        story.append(
+            KeepTogether([
+                Paragraph(f"<b>{_signature_markup(signature)}:</b>  {_markup(description)}", entry_style)
+            ])
+        )
+
+    doc = BaseDocTemplate(
+        str(OUTPUT_FILE),
+        pagesize=letter,
+        leftMargin=margin,
+        rightMargin=margin,
+        topMargin=margin,
+        bottomMargin=margin,
+    )
+    doc.addPageTemplates(PageTemplate(id="Main", frames=[frame], onPage=draw_header))
+    doc.build(story)
+    return doc.page
+
+
+def generate_pdf():
+    """Use the largest body font that keeps the cheat sheet on one page."""
+    steps = round((MAX_BODY_FONT - MIN_BODY_FONT) / FONT_STEP)
+    candidate_sizes = [round(MAX_BODY_FONT - i * FONT_STEP, 1) for i in range(steps + 1)]
+
+    for body_font in candidate_sizes:
+        if _build_pdf(body_font) == 1:
+            print(f"Wrote {OUTPUT_FILE.name} at {body_font:.1f} pt body font.")
+            return
+
+    raise RuntimeError(
+        f"Cheat sheet does not fit on one page even at {MIN_BODY_FONT:.1f} pt. "
+        "Shorten the content or lower MIN_BODY_FONT."
+    )
+
+
+if __name__ == "__main__":
+    generate_pdf()

BayesianEstimationTool/Method.py

@@ -0,0 +1,10 @@
+class Method:
+    _printMode=None
+
+    def _Fit(self,ModelFn,rngKey,samplePrefixes):
+        raise NotImplementedError
+
+    _Print=None
+
+    def _SaveArgs(self):
+        raise NotImplementedError

BayesianEstimationTool/MethodValidation.py

@@ -0,0 +1,61 @@
+"""Structural validation of BET inference Method instances.
+
+This checks interfaces and saved configuration only; it does not run inference.
+"""
+import inspect
+
+
+def ValidateMethod(method):
+    """Validate a configured BET Method; raise a specific error or return True.
+
+    _Fit must accept (ModelFn, rngKey, samplePrefixes) positionally and
+    return {"output": ..., "samples": {site_name: sample_array, ...}}
+    when executed. Runtime return values are deliberately not inspected here.
+    """
+    if method is None or inspect.isclass(method):
+        raise TypeError("Method must be a configured instance, not None or a class.")
+    from .Method import Method as BaseMethod
+    for name in ("_Fit", "_SaveArgs"):
+        if getattr(type(method), name, None) is getattr(BaseMethod, name):
+            raise TypeError(f"Method must override inherited {name}(); the base implementation raises NotImplementedError.")
+    for name, nargs in (("_Fit", 3), ("_SaveArgs", 0)):
+        fn = getattr(method, name, None)
+        if not callable(fn):
+            raise TypeError(f"Method must implement callable {name}().")
+        try:
+            signature = inspect.signature(fn)
+        except (TypeError, ValueError):
+            continue
+        try:
+            signature.bind(*([None] * nargs))
+        except TypeError as exc:
+            raise TypeError(f"Method.{name} must accept {nargs} positional arguments; got {signature}.") from exc
+    mode = getattr(method, "_printMode", None)
+    if mode not in (None, "before", "after", "replace"):
+        raise ValueError("Method._printMode must be None, 'before', 'after', or 'replace'.")
+    if mode is not None:
+        fn = getattr(method, "_Print", None)
+        if not callable(fn):
+            raise TypeError("Method._Print must be callable when _printMode is set.")
+        try:
+            signature = inspect.signature(fn)
+        except (TypeError, ValueError):
+            pass
+        else:
+            try:
+                signature.bind(None, None, None, None)
+            except TypeError as exc:
+                raise TypeError(f"Method._Print must accept output, localNames, globalNames, title; got {signature}.") from exc
+    try:
+        args = method._SaveArgs()
+    except Exception as exc:
+        raise ValueError("Method._SaveArgs() raised an exception.") from exc
+    if not isinstance(args, dict):
+        raise TypeError("Method._SaveArgs() must return a dictionary.")
+    if any(not isinstance(key, str) for key in args):
+        raise TypeError("Method._SaveArgs() keys must be strings.")
+    try:
+        inspect.signature(type(method)).bind(**args)
+    except (TypeError, ValueError) as exc:
+        raise TypeError("Method._SaveArgs() keys must be accepted by the Method constructor.") from exc
+    return True

BayesianEstimationTool/NutsMethod.py

@@ -0,0 +1,57 @@
+from .Method import Method
+from numpyro.infer import init_to_median,NUTS,MCMC
+from numpyro.diagnostics import summary
+import numpy as np
+
+
+class Nuts(Method):
+    _printMode="replace"
+
+    def __init__(self,numWarmup=2000,numSamples=2000,numChains=4,acceptProb=0.95,denseMass=False,medianSamples=50):
+        if isinstance(numWarmup,(bool,np.bool_)) or not isinstance(numWarmup,(int,np.integer)): raise TypeError(f"numWarmup must be an integer; got {type(numWarmup).__name__}.")
+        if numWarmup<0: raise ValueError("numWarmup must be >= 0.")
+        for value,name in ((numSamples,"numSamples"),(numChains,"numChains"),(medianSamples,"medianSamples")):
+            if isinstance(value,(bool,np.bool_)) or not isinstance(value,(int,np.integer)): raise TypeError(f"{name} must be an integer; got {type(value).__name__}.")
+            if value<=0: raise ValueError(f"{name} must be > 0.")
+        if isinstance(acceptProb,(bool,np.bool_)) or not isinstance(acceptProb,(int,float,np.integer,np.floating)): raise TypeError(f"acceptProb must be a real number; got {type(acceptProb).__name__}.")
+        if not np.isfinite(acceptProb): raise ValueError("acceptProb must be finite.")
+        if not 0<acceptProb<1: raise ValueError("acceptProb must be between 0 and 1.")
+        if not isinstance(denseMass,(bool,np.bool_)): raise TypeError(f"denseMass must be bool; got {type(denseMass).__name__}.")
+        self.numWarmup=numWarmup
+        self.numSamples=numSamples
+        self.numChains=numChains
+        self.acceptProb=acceptProb
+        self.denseMass=denseMass
+        self.medianSamples=medianSamples
+
+    def _Fit(self,ModelFn,rngKey,samplePrefixes):
+        kernel=NUTS(ModelFn,init_strategy=init_to_median(num_samples=self.medianSamples),target_accept_prob=self.acceptProb,dense_mass=self.denseMass)
+        mcmc=MCMC(kernel,num_warmup=self.numWarmup,num_samples=self.numSamples,num_chains=self.numChains,chain_method="parallel")
+        mcmc.run(rngKey,extra_fields=("num_steps","accept_prob"))
+        post=mcmc.get_samples(group_by_chain=False)
+        samples={name:value for name,value in post.items() if any(name.startswith(prefix) for prefix in samplePrefixes)}
+        return {"output":mcmc,"samples":samples}
+
+    def _Print(self,output,localNames,globalNames,title=None):
+        stats=summary(output.get_samples(group_by_chain=True),prob=0.95)
+        localNames=list(localNames)
+        globalNames=[] if globalNames is None else list(globalNames)
+        if title is not None: print(title)
+        print(f"{'parameter':<20} {'mean':>10} {'std':>10} {'median':>10} {'2.5%':>10} {'97.5%':>10} {'n_eff':>10} {'r_hat':>8}")
+        for prefix,names in (("__globalParam__",globalNames),("__localZ__",localNames)):
+            for name in names:
+                statName=f"{prefix}{name}"
+                if statName not in stats: continue
+                shape=np.shape(stats[statName]["mean"])
+                if not shape: self._PrintRow(name,stats[statName])
+                else:
+                    for inds in np.ndindex(shape): self._PrintRow(f"{name}[{','.join(map(str,inds))}]",stats[statName],inds)
+
+    def _SaveArgs(self):
+        return {"numWarmup":self.numWarmup,"numSamples":self.numSamples,"numChains":self.numChains,"acceptProb":self.acceptProb,"denseMass":self.denseMass,"medianSamples":self.medianSamples}
+
+    def _PrintRow(self,label,stats,inds=()):
+        def get(key):
+            x=np.asarray(stats[key])
+            return x[inds] if inds else x.item()
+        print(f"{label:<20} {get('mean'):>10.3f} {get('std'):>10.3f} {get('median'):>10.3f} {get('2.5%'):>10.3f} {get('97.5%'):>10.3f} {get('n_eff'):>10.1f} {get('r_hat'):>8.2f}")

BayesianEstimationTool/SviMethod.py

@@ -0,0 +1,53 @@
+from .Method import Method
+from jax import random
+from numpyro.infer import SVI as NumPyroSVI,Trace_ELBO,Predictive
+from numpyro.infer.autoguide import AutoNormal,AutoMultivariateNormal
+from numpyro.optim import Adam
+import numpy as np
+from numpyro.infer import init_to_median
+
+
+class Svi(Method):
+    _printMode="after"
+    def __init__(self,numSteps=10000,numSamples=2000,stepSize=0.01,numParticles=1,progressBar=True,medianSamples=50,multivariate=False):
+        for value,name in ((numSteps,"numSteps"),(numSamples,"numSamples"),(numParticles,"numParticles"),(medianSamples,"medianSamples")):
+            if isinstance(value,(bool,np.bool_)) or not isinstance(value,(int,np.integer)): raise TypeError(f"{name} must be an integer; got {type(value).__name__}.")
+            if value<=0: raise ValueError(f"{name} must be > 0.")
+        if not isinstance(progressBar,(bool,np.bool_)): raise TypeError(f"progressBar must be bool; got {type(progressBar).__name__}.")
+        if not isinstance(multivariate,(bool,np.bool_)): raise TypeError(f"multivariate must be bool; got {type(multivariate).__name__}.")
+        if isinstance(stepSize,(bool,np.bool_)) or not isinstance(stepSize,(int,float,np.integer,np.floating)):
+            raise TypeError(f"stepSize must be a real number; got {type(stepSize).__name__}.")
+        if not np.isfinite(stepSize) or stepSize<=0: raise ValueError("stepSize must be finite and > 0.")
+        self.numSteps=numSteps
+        self.numSamples=numSamples
+        self.stepSize=stepSize
+        self.numParticles=numParticles
+        self.progressBar=progressBar
+        self.medianSamples=medianSamples
+        self.multivariate=multivariate
+        self._params={}
+
+    def _Fit(self,ModelFn,rngKey,samplePrefixes):
+        fitKey,sampleKey=random.split(rngKey)
+        Guide=AutoMultivariateNormal if self.multivariate else AutoNormal
+        guide=Guide(ModelFn,init_loc_fn=init_to_median(num_samples=self.medianSamples))
+        svi=NumPyroSVI(ModelFn,guide,Adam(self.stepSize),Trace_ELBO(num_particles=self.numParticles))
+        output=svi.run(fitKey,self.numSteps,progress_bar=self.progressBar)
+        self._params=output.params
+        predictive=Predictive(ModelFn,guide=guide,params=self._params,num_samples=self.numSamples)
+        post=predictive(sampleKey)
+        samples={name:value for name,value in post.items() if any(name.startswith(prefix) for prefix in samplePrefixes)}
+        return {"output":output,"samples":samples}
+
+
+    def _Print(self,output,localNames,globalNames,title=None):
+        if title is not None: print(title)
+        losses=np.asarray(output.losses)
+        print(f"SVI steps: {len(losses)}")
+        if len(losses)>0:
+            print(f"Initial loss: {losses[0]:.6g}")
+            print(f"Final loss:   {losses[-1]:.6g}")
+
+    def _SaveArgs(self):
+        return {"numSteps":self.numSteps,"numSamples":self.numSamples,"stepSize":self.stepSize,"numParticles":self.numParticles,"progressBar":self.progressBar,"medianSamples":self.medianSamples,"multivariate":self.multivariate}
+

BayesianEstimationTool/__init__.py

@@ -0,0 +1,6 @@
+from .BayesianEstimationTool import Estimator
+from .NutsMethod import Nuts
+from .SviMethod import Svi
+from .MethodValidation import ValidateMethod
+
+__all__=["Estimator","Nuts","Svi","ValidateMethod"]

bayesianestimationtool-1.0.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: BayesianEstimationTool
+Version: 1.0.0
+Summary: Hierarchical Bayesian estimation and prediction for mechanistic models
+License-Expression: Apache-2.0
+Project-URL: Repository, https://github.com/rafaelrbravo/BayesianEstimationTool
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax
+Requires-Dist: numpyro
+Requires-Dist: numpy
+Requires-Dist: cloudpickle
+Dynamic: license-file
+
+# BayesianEstimationTool (BET)
+
+BayesianEstimationTool fits population-level parameters and individual-specific latent variables with NumPyro inference methods.
+
+## Documentation
+
+Start here:
+
+- **[Manual (Markdown)](docs/Manual.md)** — model contracts, likelihoods, masking, JAX modeling, inference, persistence, and testing.
+- **[Manual (PDF)](docs/Manual.pdf)** — printable manual. If GitHub cannot preview the PDF, download it to view locally.
+- **[Cheatsheet (Markdown)](docs/Cheatsheet.md)** — compact API reference and common workflows.
+- **[Cheatsheet (PDF)](docs/Cheatsheet.pdf)** — one-page printable reference. If GitHub cannot preview the PDF, download it to view locally.
+
+**Manual.md is the authoritative manual.** Its PDF is rendered directly from that file using GitHub-like styling and print pagination. The cheatsheet is a separate compact, Python-generated reference. To regenerate locally, install `requests`, `playwright`, and `reportlab`, install Playwright Chromium (`python -m playwright install chromium`), and set `GITHUB_TOKEN` to a token permitted to call GitHub's Markdown API for this repository. The manual generator uses GitHub's Markdown rendering API and Playwright; the cheatsheet generator uses ReportLab:
+
+```bash
+python docs/generators/markdown_to_pdf.py docs/Manual.md
+python docs/generators/cheatsheet.py
+```
+
+The GitHub Actions test workflow regenerates the PDFs (and the Python-authored cheatsheet Markdown), checks that the cheatsheet is exactly one PDF page, uploads the outputs as a `bet-docs` artifact, and runs the test suite.
+
+## Installation
+
+BET requires Python 3.10 or newer. **After the first release is published**, install the latest version from [PyPI](https://pypi.org/project/BayesianEstimationTool/):
+
+```bash
+python -m pip install BayesianEstimationTool
+```
+
+To install the specific first release:
+
+```bash
+python -m pip install BayesianEstimationTool==1.0.0
+```
+
+Alternatively, install directly from the tagged GitHub source:
+
+```bash
+python -m pip install "git+https://github.com/rafaelrbravo/BayesianEstimationTool.git@v1.0.0"
+```
+
+You can also download a wheel (`.whl`) or source archive (`.tar.gz`) from [GitHub Releases](https://github.com/rafaelrbravo/BayesianEstimationTool/releases) and install it with `python -m pip install PATH_TO_DOWNLOADED_FILE`. These release assets become available after publishing.
+
+Verify installation:
+
+```bash
+python -c "import BayesianEstimationTool as bet; print(bet.Estimator)"
+```
+
+For editable development from a source checkout, run `python -m pip install -e .` in the repository root. The conda recipe in `conda-recipe/meta.yaml` is for local builds; BET is not yet published on conda-forge.
+
+See the manual for the minimal model and training examples.

bayesianestimationtool-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+BayesianEstimationTool/BayesianEstimationTool.py,sha256=yG7BLFbnLeU66kjMwI-46zcvlyimTd6pKK8rQRYAzHw,36485
+BayesianEstimationTool/BayesianEstimationTool_CheatSheet.py,sha256=HZPvU0UfX9RmDBVc01cWZY-OPMPiTAnsf7geVBmh9MY,13364
+BayesianEstimationTool/Method.py,sha256=zn7ju_9nILgnpwfbHUAsTidRfhjmLDS2jdKIqwoEbi0,196
+BayesianEstimationTool/MethodValidation.py,sha256=RH6Srn9UueJV8SAnQg8Bgs1ycAdAlq2FgftIYYofHHQ,2796
+BayesianEstimationTool/NutsMethod.py,sha256=g6nI_WsZbpSnu1G_8m7Da6bmJw0ckDVJJagUVWV1tgY,3678
+BayesianEstimationTool/SviMethod.py,sha256=M76zQo56nsGyrnQS4DDrh8ftiAQMnRacjLJt2kvfogk,3050
+BayesianEstimationTool/__init__.py,sha256=7p9sf6KXsM-P8JrsWto0Vtx9tCm2QGHJLU3eyNVWg_4,200
+bayesianestimationtool-1.0.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+bayesianestimationtool-1.0.0.dist-info/METADATA,sha256=74OYZ9VylmD73kByKSViM6A5sJqp3YQnJkpTYoBb0C0,3221
+bayesianestimationtool-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+bayesianestimationtool-1.0.0.dist-info/top_level.txt,sha256=ZlzIcp6AOhAeZRPEGQRe1WQRgdLEK7w4LtDZZzMWS5w,23
+bayesianestimationtool-1.0.0.dist-info/RECORD,,

bayesianestimationtool-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+