Saravanan666/pypi-org huggingface dataset:
Package: bayes-jones
Main
Status:Develop
Status:Mission:To make ionospheric calibrationfaster, easier, and more powerfulWhat is it?Bayes is:a set of tools for Bayesian inference of Jones matrices using JAXNS as the engine;coded in JAX in a manner that allows lowering the entire inference algorithm to XLA primitives, which are
JIT-compiled for high performanceDocumentationYou can read the documentationhere.InstallNotes:BayesJones requires >= Python 3.8.It is always highly recommended to use a unique virtual environment for each project.
To useminiconda, have it installed, and run# To create a new env, if necessarycondacreate-nbayes_jones_pypython=3.11
condaactivatebayes_jones_pyFor end usersInstall directly from PyPi,pipinstallbayes_jonesFor developmentClone repogit clone https://www.github.com/JoshuaAlbert/bayes_jones.git, and install:cdbayes_jones
pipinstall-rrequirements.txt
pipinstall-rrequirements-tests.txt
pipinstall-rrequirements-examples.txt
pipinstall.Quick startCheckout the exampleshere.Change Log14 Dec, 2023 -- BayesJones 0.0.1 released for SaLF 9 conference.Star History
Package: bayes-kit
bayes-kitbayes-kitis an open-source Python package for black-box Bayesian
inference with minimial dependencies for maximal flexiblity.Bayesian modelsinvolve specifying a posterior log density for
parameters conditioned on data.  Bayesian models are typically
specified in terms of a prior distribution over parameters and a
sampling distribution which generates observed data conditioned on the
parameters.  Users are free to define models using arbitrary Python
code, such asdirect implementation inNumPy,Python's foreign function interface to Fortran, C++, etc., orautomatic differentiation libraries such asStan,PyTorch,JAX, orTensorFlow Probability.Bayesian inferenceinvolves conditioning on data and averaging over
uncertainty.  Specifically,bayes-kitcan compute
* parameter estimates,
* posterior predictions for new observations, and
* event probability forecasts,
all with Bayesian uncertainty quantification.Black-boxalgorithms are agnostic to model structure.  Algorithms inbayes-kitmay require only log densities, whereas the
high-performance algorithms further require gradients of the log
density function.Markov chain Monte Carlo samplersMarkov chain Monte Carlo (MCMC) samplers provide a sequence of random
draws from target log density, which may be used for Monte Carlo
estimates of posterior expectations and quantiles for uncertainty
quantification.Hamiltonian Monte Carlo samplerHamiltonian Monte Carlo simulates Hamiltonian dynamics with a
potential energy function equal to the negative log density. It
requires a target log density, gradient function, and optionally a
metric.Random-walk Metropolis samplerRandom-walk Metropolis is a diffusive sampler that requires a
target log density function and a symmetric pseudorandom proposal
generator.Dependenciesbayes-kithas minimal dependencies, requiring onlyNumPy.LicensingCodein this repository is released under theMIT License.Documentationin this repository is released under theCC BY 4.0 License.
Package: bayesKMeans
Example of work:from bayeskmeans.bayes_kmeans import BayesKMeans
from bayeskmeans.bayes_visualize import BayesKMeansVisualize
from sklearn.datasets import make_blobsdata = make_blobs(n_samples=1000, n_features=2, centers=21, cluster_std=5, center_box=(-300, 300))
data = data[0]bayesKMeans = BayesKMeans(data)bayesKMeans.find_k()print(bayesKMeans.found_k)visual = BayesKMeansVisualize(bayesKMeans)
visual.show_bayesian_plot()
Package: bayeslite
# BayesliteBayeslite is a BQL database built on SQLite3.  BQL is an extension to
SQL that supports queries about the probable implications of data.Bayeslite is part of an ongoing research project.  For more
information, contactbayesdb@mit.edu.## DependenciesBayeslite is written in Python 2.7, using the sqlite3 module with
SQLite3 >=3.8.0.Bayeslite depends on:[Crosscat](https://github.com/probcomp/crosscat),
a general-purpose nonparametric Bayesian population model which
serves as a default in the absence of a domain-specific model.[apsw](https://rogerbinns.github.io/apsw/), a sqlite3 wrapper for
Python more articulated than the builtin sqlite3 module[numpy](http://www.numpy.org), a library of vectorized numerical
algorithms[requests](http://www.python-requests.org/), an HTTP/HTTPS library,
which we use to track users.The bayeslite automatic tests depend on:[pytest](https://pytest.org/)[pandas](http://pandas.pydata.org), a library for tabular data
structuresThe bayeslite documentation depends on:[Sphinx](http://sphinx-doc.org/)## TestTo check that everything will work, before installing:` $ ./check.sh `## InstallTo install system-wide, or into the current virtual environment:` $ python setup.py build $ python setup.py install `## UseImport thebayeslitemodule.  See the documentation for details on
the Python API.## DocumentationTo build the documentation (requires sphinx):` $ make doc `The result will be placed inbuild/doc, with one subdirectory per
output format.To build only one output format, e.g. HTML because you don’t want to
install TeX:` $ make html `
Package: bayeslite-apsw
A Python wrapper for the SQLite embedded relational database engine.WARNING: This is a bayeslite custom edition.  This is not the normalapsw.  It is a temporary kludge until the `apsw' package on pypiworks.  This was customized by running::python setup.py fetch --sqlite --version=3.9.2so that it includes a copy of a working version of sqlite3 instead ofrelying on whatever version your system may have installed.In contrast to other wrappers such as pysqlite it focuses on beinga minimal layer over SQLite attempting just to translate thecomplete SQLite API into Python.
Package: bayes_logistic
This package will fit Bayesian logistic regression models with arbitrary
prior means and covariance matrices, although we work with the inverse covariance matrix which is the log-likelihood
Hessian.Either the full Hessian or a diagonal approximation may be used.Individual data points may be weighted in an arbitrary manner.Finally, p-values on each fitted parameter may be calculated and this can be used
for variable selection of sparse models.Free software: BSD licenseDocumentation:https://bayes_logistic.readthedocs.org.DemoExample NotebookHistory0.2.0 (2015-09-02)First release on PyPI.
Package: bayes-lol-client
Bayes LoL ClientThis library is used to make queries to the Bayes EMH API, which provides data for League of Legends esports games.
The (in progress) documentation can be foundhere.Installpip install bayes_lol_clientIf you wish to install the latest development version:pip install -U git+https://github.com/arbolitoloco1/bayes_lol_clientBayes CredentialsIn order to use the Bayes API, you must have login credentials, which will be prompted the first time you use the library.
These will be stored in a file in your user config path.EMH DocsThe full documentation to use EMH can be foundhere.
Package: bayesml
PurposeBayesML is a library designed for promoting research, education,
and application of machine learning based on Bayesian statistics
and Bayesian decision theory.
Through these activities, BayesML aims to contribute to society.CharacteristicsBayesML has the following characteristics.The structure of the library reflects the philosophy of
Bayesian statistics and Bayesian decision theory:
updating the posterior distribution learned from the data
and outputting the optimal estimate based on the Bayes criterion.Many of our learning algorithms are much faster than general-purpose
Bayesian learning algorithms such as MCMC methods because they
effectively use the conjugate property of a probabilistic data
generative model and a prior distribution.
Moreover, they are suitable for online learning.All packages have methods to visualize the probabilistic data
generative model, generated data from that model, and the posterior
distribution learned from the data in 2~3 dimensional space.
Thus, you can effectively understand the characteristics of
probabilistic data generative models and algorithms through
the generation of synthetic data and learning from them.
Package: bayesmsd
BayesMSD: properly fitting MSDsWhile inspection of MSD curves is one of the most ubiquitous ways of analyzing
particle tracking data, it is also well known that extracting model parameters
from MSD curves is a statistical minefield[^1]. This problem can be addressed
quite nicely in the language of Gaussian processes, allowing statistically
rigorous MSD fits. This provides, for example, error bars on estimated model
parameters, which are quite noticeably missing from the current literature.For aQuickstart
intro, more
extensiveTutorials &
Examplesand the fullAPI referencerefer
to thedocumentation hosted at
ReadTheDocs.To installbayesmsdyou can use the latest stable version fromPyPI$pipinstall--upgradebayesmsdor the very latest updates right from GitHub:$pipinstallgit+https://github.com/OpenTrajectoryAnalysis/bayesmsdWhen cloning the repo and installing in editable mode, make sure to usemake setupto setup the parts of the local environment that are not tracked in git
(seeDevelopers):$gitclonehttps://github.com/OpenTrajectoryAnalysis/bayesmsd
$cdbayesmsd&&makesetup
$pipinstall-e.[^1]: Vestergaard, Blainey, Flyvbjerg,Optimal estimation of diffusion coefficients from single-particle trajectories,Physical Review E, 2014;DOIDevelopersWe use GNUmaketo automate recurrent tasks. Targets include:make setup: set up the local environment after cloning. Requiresnbstripoutwhich is used toremove
output and empty cells from the example
notebooks.make recompile: (re-)compile cython codemake build: build wheels for distribution on PyPImake tests: run unittestsmake docs: build Sphinx documentation
Package: bayesn
BayeSNHierarchical Bayesian SED modelling of type Ia supernova light curvesDeveloped and maintained by: Matt Grayling (@mattgrayling), Stephen Thorp (@stevet40), Gautham Narayan (@gnarayan), and
Kaisey S. Mandel (@CambridgeAstroStat) on behalf of the BayeSN Team (@bayesn).AboutBayeSN is a probabilistic optical-NIR SED model for type Ia supernovae, allowing for hierarchical analysis of the
population distribution of physical properties as well as cosmology-independent distance estimation for individual
SNe. This repository contains an implementation of the BayeSN SED model built with numpyro and jax, with support for
GPU acceleration, as discussed in Grayling+2024 (submitted to MNRAS).Installation and usageBayeSN can be pip-installed via the commandpip install bayesn.Detailed instructions on how to install and run the BayeSN model can be found here:https://bayesn.readthedocs.io/en/latest/index.htmlSupportOur goal with BayeSN is for the package to be clear and easy to use. If you find something unclear, come across any bugs
or think of any functionality that would add a lot of value for you, please raise a Github issue.Citing the code/modelIf you utilise the BayeSN model in any way, please cite Mandel+2022 (MNRAS 510, 3, 3939-3966), and if you make use of
this code please cite Grayling+2024 (submitted to MNRAS). In addition, if you use any of the pre-trained models included
within BayeSN please cite the corresponding papers which present those models:M20 model: Mandel et al. 2022 (MNRAS 510, 3, 3939-3966)T21 model: Thorp et al. 2021 (MNRAS 508, 3, 4310-4331)W22 model: Ward et al. 2023 (ApJ 956, 2, 111)Things to noteFiltersBayeSN includes a set of built-in filters for convenience, as detailed in the documentation. However, you can also add
your own  filters through a yaml file to allow for new and updated filter responses to be used without needing a package
update.GPU AccelerationThis code has been designed with GPU acceleration in mind, and running on a GPU should yield a considerable (~100 times)
increase in performance. However, it is important to note that GPUs will show the most benefit running large scale jobs.
If you want to fit samples of 100s of SNe, the fit time per object will be considerably shorter than fitting just a
handful. With only 1 object, you are likely better off running on CPU than GPU.Redshift requirementAt the present time, BayeSN is designed for use with spectroscopic redshifts, which are kept fixed during inference.
However, fitting with redshift as a free parameter based on a photometric redshift prior is feasible and planned in
future.
Package: bayes-nets-sample
Bayes Nets and SamplingAbout:Developed code from scratch to compute an input probability query on a given Bayes net on discrete random variables using Prior sampling, Rejection Sampling, Likelihood weighting and Gibbs sampling.I had also written helper function to generate samples from any input univariate discrete distribution and then use it in your Bayes Net sampling code.BayesNets Class:I implemented a BayesNets Class to do all the required task and computations.Basically I created a single class to do all the calculation, extractions of details from the file as well as implement all the sampling methods and sample generation.Install the Python Packagepip install bayes-nets-sampleImport the Python Packagefrom bayes import bayesNetsTo see the Sample .txt filefrom bayes.sample_input_txt import SampleInputTXT
SampleInputTXT().generate_sample()To Get more information about the BayesNets Class as well as its methods:run the following command:help(BayesNets)Lets Start By Creating an object of BayesNets and extract the information from the file:bayesNet = BayesNets(filepath = "example_bayesnet.txt")Let's Print The Extracted Information:print(bayesNet)Let's See how a single sample is generated:bayesNet.generateSample()Now Lets Calculate the Query result using Prior Sampling Method:With verbose = TruebayesNet.doPriorSampling(TOTAL_SAMPLE = 10000, verbose = True)Now Lets Calculate the Query result using Prior Sampling Method:With verbose = FalseJust to see the final result.bayesNet.doPriorSampling(TOTAL_SAMPLE = 10000, verbose = False)Now Lets Calculate the Query result using Rejection Sampling Method:With verbose = TruebayesNet.doRejectionSampling(TOTAL_SAMPLE_REQUIRED = 10000, verbose = True)Now Lets Calculate the Query result using Rejection Sampling Method:With verbose = FalseJust to see the final result.bayesNet.doRejectionSampling(TOTAL_SAMPLE_REQUIRED = 10000, verbose = False)Let's See how a single weighted sample is generated:bayesNet.generateWeightedSample(verbose = True)Now Lets Calculate the Query result using Likelihood Weighting Method:With verbose = TruebayesNet.doLikelihoodWeighting(TOTAL_SAMPLE = 10000, verbose = True)Now Lets Calculate the Query result using Likelihood Weighting Method:With verbose = FalseJust to see the final result.bayesNet.doLikelihoodWeighting(TOTAL_SAMPLE = 10000, verbose = False)Sample File5, B, E, A, J, M
B, +b, -b
E, +e, -e
A, +a, -a
J, +j, -j
M, +m, -m
B |
+b, 0.001
-b, 0.999
E |
+e, 0.002
-e, 0.998
A | B,E
+b, +e, +a, 0.95
+b, +e, -a, 0.05
+b, -e, +a, 0.94
+b, -e, -a, 0.06
-b, +e, +a, 0.29
-b, +e, -a, 0.71
-b, -e, +a, 0.001
-b, -e, -a, 0.999
J | A
+a, +j, 0.9
+a, -j, 0.1
-a, +j, 0.05
-a, -j, 0.95
M | A
+a, +m, 0.7
+a, -m, 0.3
-a, +m, 0.01
-a, -m, 0.99
Query: P( B=+b| J=+j)
Package: bayesnf
Bayesian Neural Fields for Spatiotemporal PredictionThis is not an officially supported Google product.Spatially referenced time series (i.e., spatiotemporal) datasets are
ubiquitous in scientific, engineering, and business-intelligence
applications. This repository contains an implementation of the Bayesian
Neural Field (BayesNF) a novel spatiotemporal modeling method that
integrates hierarchical probabilistic modeling for accurate uncertainty
estimation with deep neural networks for high-capacity function
approximation.Bayesian Neural Fields infer joint probability distributions over field
values at arbitrary points in time and space, which makes the model
suitable for many data-analysis tasks including spatial interpolation,
temporal forecasting, and variography. Posterior inference is conducted
using variationally learned surrogates trained via mini-batch stochastic
gradient descent for handling large-scale data.Installationbayesnfcan be installed from the Python Package Index
(PyPI) using:python -m pip install bayesnfThe typical install time is 1 minute. This software is tested on Python 3.9
with a standard Debian GNU/Linux setup. The large-scale experiments inscripts/were run using TPU v3-8 accelerators. For running BayesNF
locally on medium to large-scale data, a GPU is required at minimum.Documentation and TutorialsPlease visithttps://google.github.io/bayesnfQuick start# Load a dataframe with "long" format spatiotemporal data.df_train=pd.read_csv('chickenpox.5.train.csv',index_col=0,parse_dates=['datetime'])# Build a BayesianNeuralFieldEstimatormodel=BayesianNeuralFieldMAP(width=256,depth=2,freq='W',seasonality_periods=['M','Y'],num_seasonal_harmonics=[2,10],feature_cols=['datetime','latitude','longitude'],target_col='chickenpox',observation_model='NORMAL',timetype='index',standardize=['latitude','longitude'],interactions=[(0,1),(0,2),(1,2)])# Fit the model.model=model.fit(df_train,seed=jax.random.PRNGKey(0),ensemble_size=ensemble_size,num_epochs=num_epochs)# Make predictions of means and quantiles on test data.df_test=pd.read_csv('chickenpox.5.test.csv',index_col=0,parse_dates=['datetime'])yhat,yhat_quantiles=model.predict(df_test,quantiles=(0.025,0.5,0.975))
Package: bayeso
BayesO: A Bayesian Optimization Framework in PythonSimple, but essential Bayesian optimization package.https://bayeso.orgOnline documentationInstallationWe recommend installing it withvirtualenv.
You can choose one of three installation options.Using PyPI repository (for user installation)To install the released version in PyPI repository, command it.$pipinstallbayesoUsing source code (for developer installation)To installbayesofrom source code, command$pipinstall.in thebayesoroot.Using source code (for editable development mode)To use editable development mode, command$pipinstall-rrequirements.txt
$pythonsetup.pydevelopin thebayesoroot.UninstallationIf you would like to uninstallbayeso, command it.$pipuninstallbayesoRequired PackagesMandatory pacakges are inlcuded inrequirements.txt.
The followingrequirementsfiles include the package list, the purpose of which is described as follows.requirements-optional.txt: It is an optional package list, but it needs to be installed to execute some features ofbayeso.requirements-dev.txt: It is for developing thebayesopackage.requirements-examples.txt: It needs to be installed to execute the examples included in thebayesorepository.Supported Python VersionWe test our package in the following versions.Python 3.7Python 3.8Python 3.9Python 3.10Python 3.11Examples and TestsWe provide alist of examplesand alist of tests.Citation@article{KimJ2023joss,
    author={Kim, Jungtaek and Choi, Seungjin},
    title={{BayesO}: A {Bayesian} optimization framework in {Python}},
    journal={Journal of Open Source Software},
    volume={8},
    number={90},
    pages={5320},
    year={2023}
}LicenseMIT License
Package: bayes_on_redis
# What is BayesOnRedis?Bayesian classifier on top of Redis## Why on Redis?[Redis](http://code.google.com/p/redis) is a persistent in-memory database with supports for various data structures such as lists, sets, and ordered sets.
All this data types can be manipulated with atomic operations to push/pop elements, add/remove elements, perform server side union, intersection, difference between sets, and so forth.Because of Redis properties:It is extremely easy to implement simple algorithm such as bayesian filter.The persistence of Redis means that the Bayesian implementation can be used in real production environment.Even though I don’t particularly care about performance at the moment. Redis benchmarks give me confidence that the implementation can scale to relatively large training data.## How to install? (Ruby version)gem install bayes_on_redis## Getting started# Create instance of BayesOnRedis and pass your Redis information.
# Of course, use real sentences for much better accuracy.
# Unless if you want to train spam related things.
bor = BayesOnRedis.new(:redis_host => ‘127.0.0.1’, :redis_port => 6379, :redis_db => 5)# Teach it
bor.train “good”, “sweet awesome kick-ass cool pretty smart”
bor.train “bad”, “sucks lame boo death bankrupt loser sad”# Then ask it to classify text.
bor.classify(“awesome kick-ass ninja can still be lame.”)## for PythonistasBayesOnRedis is also available in Python. With the same API.## Contributing[Forkhttp://github.com/didip/bayes_on_redis](http://github.com/didip/bayes_on_redis) and send pull requests.
Package: bayespy
BayesPy provides tools for Bayesian inference with Python.  The user
constructs a model as a Bayesian network, observes data and runs
posterior inference.  The goal is to provide a tool which is
efficient, flexible and extendable enough for expert use but also
accessible for more casual users.Currently, only variational Bayesian inference for
conjugate-exponential family (variational message passing) has been
implemented.  Future work includes variational approximations for
other types of distributions and possibly other approximate inference
methods such as expectation propagation, Laplace approximations,
Markov chain Monte Carlo (MCMC) and other methods. Contributions are
welcome.Project informationCopyright (C) 2011-2017 Jaakko Luttinen and other contributors (see below)BayesPy including the documentation is licensed under the MIT License. See
LICENSE file for a text of the license or visithttp://opensource.org/licenses/MIT.Latest releaseDocumentationhttp://bayespy.orgRepositoryhttps://github.com/bayespy/bayespy.gitBug reportshttps://github.com/bayespy/bayespy/issuesAuthorJaakko Luttinenjaakko.luttinen@iki.fiChatMailing listbayespy@googlegroups.comContinuous integrationBranchTest statusTest coverageDocumentationmaster (stable)develop (latest)Similar projectsVIBES(http://vibes.sourceforge.net/) allows variational inference to be
performed automatically on a Bayesian network.  It is implemented in
Java and released under revised BSD license.Bayes Blocks(http://research.ics.aalto.fi/bayes/software/) is a C++/Python
implementation of the variational building block framework.  The
framework allows easy learning of a wide variety of models using
variational Bayesian learning.  It is available as free software under
the GNU General Public License.Infer.NET(http://research.microsoft.com/infernet/) is a .NET framework for
machine learning.  It provides message-passing algorithms and
statistical routines for performing Bayesian inference.  It is partly
closed source and licensed for non-commercial use only.PyMC(https://github.com/pymc-devs/pymc) provides MCMC methods in Python.
It is released under the Academic Free License.OpenBUGS(http://www.openbugs.info) is a
software package for performing Bayesian inference using Gibbs
sampling.  It is released under the GNU General Public License.Dimple(http://dimple.probprog.org/) provides
Gibbs sampling, belief propagation and a few other inference algorithms for
Matlab and Java.  It is released under the Apache License.Stan(http://mc-stan.org/) provides inference using
MCMC with an interface for R and Python.  It is released under the New BSD
License.PBNT - Python Bayesian Network Toolbox(http://pbnt.berlios.de/) is Bayesian network library in Python supporting
static networks with discrete variables.  There was no information about the
license.ContributorsThe list of contributors:Jaakko LuttinenHannu HartikainenDeebul NairChristopher CramerTill HoffmannEach file or the git log can be used for more detailed information.