Saravanan666/pypi-org huggingface dataset:
Package: gaus-bin-dist
gaus-bin-distThis package contains modules for working with Gaussian and Binomial Distributions.Filesgaus_bin_dist/: Distributions packageBinomialdistribution.py: Binomial classGaussiandistribution.py: Gaussian classGeneraldistribution.py: Distribution class__init__.py: Initialization scriptlicense.txt: MIT licensenumbers.txt: Test file for Gaussian classnumbers_binomial.txt: Test file for Binomial classsetup.cfg: Configuration file for code packagingsetup.py: Script for code packagingtest.py: Unit testsInstallationDownload onPyPior use following command:pip install gaus-bin-distPython Interpreter ExampleInitialization>>>fromgaus_bin_distimportGaussian,Binomial>>>Gaussian(10,7)mean10,standarddeviation7>>>Binomial(0.4,25)mean10.0,standarddeviation2.449489742783178,p0.4,n25Addition>>>gaussian_one=Gaussian(25,3)>>>gaussian_two=Gaussian(30,4)>>>gaussian_one+gaussian_twomean55,standarddeviation5.0>>>binomial_one=Binomial(0.4,20)>>>binomial_two=Binomial(0.4,60)>>>binomial_one+binomial_twomean32.0,standarddeviation4.381780460041329,p0.4,n80Probability Density Function>>>gaussian_one.pdf(25)# gaussian_one PDF at x = 250.1329807601338109>>>binomial_one.pdf(5)# binomial_one PDF at x = 50.07464701952887093Gaussian Visualizations>>>gaussian=Gaussian()>>>gaussian.read_data_file('numbers.txt')>>>gaussian.replace_stats_with_data()# returns (mean, stdev)(78.0909090909091,92.87459776004906)>>>gaussian.plot_histogram()>>>gaussian.plot_histogram_pdf()Binomial Visualizations>>>binomial=Binomial()>>>binomial.read_data_file('numbers_binomial.txt')>>>binomial.replace_stats_with_data()# returns (p, n)(0.6153846153846154,13)>>>binomial.plot_histogram()>>>binomial.plot_pdf()
Package: gauss-binomial-mp99
gauss-binomial-mp99 packageThe package contains methods for performing computations pertaining to Guassian and Binomial distributions.Installation>>> pip install gauss-binomial-mp99FilesGeneraldistribution.py
The parent class, contains__init__andread_data_filemethods.Import:>>> from gauss_binomial_mp99 import Gaussian, Binomial
>>> gauss = Gaussian()
>>> gauss.read_data_file('sample.txt')Gaussiandistribution.pyGaussian distribution class for calculating and visualizing a Gaussian distribution. Methods to compute Gaussian distribution features include-calculate_mean(): Function to calculate the mean of the data set.calculate_stdev(): Function to calculate the standard deviation of the data set.plot_histogram(): Function to output a histogram of the instance variable data using matplotlib pyplot library.pdf(x): Probability density function calculator for the gaussian distribution.plot_histogram_pdf: Function to plot the normalized histogram of the data and a plot of the probability density function along the same rangeDefault:mu= 0 andsigma=1Form: guass(mu, sigma)Example:>>> gauss.calculate_mean()
78.0909090909091
>>> gauss.calculate_stdev()
92.87459776004906Provides the functionality of adding two Gaussian distribution objects.Binomialdistribution.pyBinomial distribution class for calculating and visualizing a Binomial distribution. Methods to compute Gaussian distribution features include-calculate_mean(): Function to calculate the mean from p= probability and n= sizecalculate_stdev(): Function to calculate the standard deviation from p and n.plot_bar(): Function to output a histogram of the instance variable data using matplotlib pyplot library.pdf(x): Probability density function calculator for the gaussian distribution.plot_bar_pdf: Function to plot the pdf of the binomial distribution.Default:p= 0.5 andn=20Form: bin(p, n)>>> bin= Binomial(.45, 78)
>>> bin.pdf(34)
0.08798942891783665Provides the functionality of adding two Binomial distribution objects with the same probablity.
Package: gauss-binomial-probability
Gaussian-Binomial-distributions packageThis package contains the code for calculating the probability density function of gaussian and binomial distribution by providing the data file. From the data file, the package contains two classes called gaussian and binomial which can calculate the further details such as mean and standard deviation from the data file provided (data file should be .txt).
Moreover, the classes can be further use to calculate probability density and plot the respective graphs.And one can use it further for adding two or more Gaussian function or Binomial functions.FilesBelow is the brief information about the files used:init.py is the file for importing the Binomial and Gaussian class from the respective modulesGeneral Distribution (Generaldistribution.py) - This module of python package contains the code ofclass Distributionfor calculating and visualizing a probability distribution. Additionally, there is a method calledread_data_file, which is the function to read in data from a txt file. The txt file should have one number (float) per line. The numbers are stored in the data attribute.Gaussian Distribution (Gaussindistribution.py) - This module contains the class for calculating and visulizing a Gaussian distribution which inherits the properties of Distribution fromGeneraldistribution.py.Binomial Distribution (Binomialdistribution.py) - Binomial distribution class for calculating and visualizing a Binomial distribution.Installation guide for the packageYou can install the gauss-binomial-probability from PyPI:pip install gauss_binomial_probability
Package: gauss-binomial-statdist
About the Package:The package was an assignment in a course I had taken about Machine Learning.The package is about making the Gaussian, and the Binomial distribution easy to work with .There's The Gaussian sub Module, and the Binomial sub Module as well.Features:With The package , you can :Read from the dataset.calculate the mean for the Gaussian distribution, and the Binomial distribution as well.calculate the standard deviation .Plot the histogram of the data.Calculate the probability density function for the distribution.Plot the probability density function.Add two Gaussian Distributions .Add two Binomial Distributions (if only they have the same probability p, the complex case is not developed yet may be soon).
Package: gauss-binom-test
Gaussian and Binomial DistributionsA basic package for calculating and visualizing Gaussian and Binomial Distributions.
This is only a test.How to import the classes using the interpret$python>>> from gauss_binom_test import Gaussian, BinomialFeaturesCalculate the Gaussian and Binomial pdf of a data setCalculate the mean and standard deviationCalculate the sum of two pdfsPlot the histogram of data points and normalizdd histogram of the pdfExampleOpen the Python interpreter:Create a standard normalmdistribution (zero mean and standard deviation equal to one)>>> gaussian_normal = Gaussian()>>> gaussian_normalmean 0, standard deviation 1Create a Gaussian distribution with mean=5 and stdv=2>>> gaussian_one = Gaussian(5,2)mean 5, standard deviation 2Addition of two Gaussian distributions>>> gaussian_sum = gaussian_normal + gaussian_one>>> gaussian_sum.mean()5>>> sample stdev>>> gaussian_sum.stdev()2.2360679Addition of three Gaussian distributions>>> gaussian_sum = Gaussian(1,2) + Gaussian(2,3) + Gaussian(3,4)>>> gaussian_sum>>> mean 6, standard deviation 5.3851648**Calculate the value of the Gaussian distribution function at a given point **>>> gaussian_one = Gaussian(5,2)>>> gaussian_one.pdf(6)0.17603266338Generate a Binomial distribution of 20 trials and 0.5 probability of an event occurring>>> binom_one = Binomial(.5, 20)>>> binom_onemean 10.0, standard deviation 2.23606797749979, p 0.5, n 20Calculate the probability of occurring 5 successes for a Binomial distribution of 20 trials and p=0.5>>> Binomial(.5, 20).pdf(5)0.0147857666015625Adding two binomial distributions>>> binom_sum = Binomial(.5, 20) + Binomial(.5, 10)mean 15.0, standard deviation 2.7386127875258306, p 0.5, n 30
Package: gauss-cli
Gauss CLIGauss CLI Tool , it's a package to solve N*N equation with gauss elimination method.Demo with  source codehttps://replit.com/@messabih-khalil/gaussCLI#main.pyInstallationto install gauss-cli just run :pipinstallgauss-cliUsage/ExamplesfromgaussCLI.gaussCliimportGaussCLI# run gauss cligc=GaussCLI()Screenshots
Package: gaussFilter
gaussFiltergaussFilter is a Python package that provides a function for applying a Gaussian filter to images using OpenCV.InstallationYou can installgaussFilterusing pip:pipinstallgaussFilterUsageimportcv2fromgaussFilterimportapply_gaussian_filter# Load an imageimage=cv2.imread('path/to/your/image.jpg')# Apply the Gaussian filter with desired sigma and kernel sizefiltered_image=apply_gaussian_filter(image,sigma=1.5,kernel_size=5)# Display the original and filtered imagescv2.imshow('Original Image',image)cv2.imshow('Filtered Image',filtered_image)cv2.waitKey(0)cv2.destroyAllWindows()##ContributingContributions are welcome! If you find any issues or have suggestions for improvements, please open an issue or submit a pull request on the GitHub repository.LicenseThis package is distributed under the MIT License. See theLICENSEfile for more information.
Package: gaussianansatz
Gaussian Ansatz (v0.0.1)TheGaussian Ansatzis a machine learning framework for performing frequentist inference, complete with local uncertainty estimation, as described in"Learning Uncertainties the Frequentist Way: Calibration and Correlation in High Energy Physics" (arxiv:2205.03413). These models can be used to quickly estimate local resolutions of an inference $z$ given a measurement $x$, even if $x$ is very high-dimensional.InstallationFrom PyPIIn your Python environment runpython -m pip install GaussianAnsatzFrom this repository locallyIn your Python environment from the top level of this repository runpython -m pip install .From GitHubIn your Python environment runpython -m pip install "GaussianAnsatz @ git+https://github.com/rikab/GaussianAnsatz.git"Example UsageFor an example of how to use the Gaussian Ansatz, see the notebookexamples/minimal_working_example.ipynb. This notebook contains example code for loading data, using pre-built DNN Gaussian Ansatz, pre-training and training, and extracting inferences with uncertainty estimates.Additional, more complicated examples can be found in theJECsubfolder. The files here correspond exactly to the jet energy studies, as described in"Learning Uncertainties the Frequentist Way: Calibration and Correlation in High Energy Physics" (arxiv:2205.03413)DependenciesTo use theGaussian Ansatz, the following packages must be installed as prerequisites:Tensorflow: A standard tensor operation library.Energyflow: A suite of particle physics tools, including Energy Flow Networks and Particle FLow NetworksStandard python packages:numpy,scipy,matplotlibCitationIf you use theGaussian Ansatz, please cite both the corresponding paper, "Learning Uncertainties the Frequentist Way: Calibration and Correlation in High Energy Physics"?:@article{Gambhir:2022gua,
author = "Gambhir, Rikab and Nachman, Benjamin and Thaler, Jesse",
title = "{Learning Uncertainties the Frequentist Way: Calibration and Correlation in High Energy Physics}",
eprint = "2205.03413",
archivePrefix = "arXiv",
primaryClass = "hep-ph",
reportNumber = "MIT-CTP 5431",
doi = "10.1103/PhysRevLett.129.082001",
journal = "Phys. Rev. Lett.",
volume = "129",
number = "8",
pages = "082001",
year = "2022"}Changelogv0.0.1: 17 April 2023. Now pip-installable!v0.0.0: 6 May 2022. Public release.Based on the work in"Learning Uncertainties the Frequentist Way: Calibration and Correlation in High Energy Physics" (arxiv:2205.03413)Bugs, Fixes, Ideas, or Questions? Contact me atrikab@mit.edu
Package: gaussian-binomial-distribution-calculation
Gaussian-Binomial-Distribution PackageA python module to calculate and plot Gaussian and binomial distributions.Uploading a Package[optional] commands[pipenv run] python3 setup.py sdist bdist_wheel
[pipenv run] twine check dist/*
[pipenv run] twine upload dist/*Distribution Formulas UsedCalculated mean, standard deviation, variance and probability density function in both distibutions.Gaussian Distribution formulasBinomial Distribution formulasExample to use the packageAfter installing the package, create a fileexample_test.pyand add following linesfrom gaussian_binomial_distribution_calculation import Gaussian, Binomial


gaussian_one = Gaussian(10, 7) 

gaussian_two = Gaussian(15, 21)

gaussian_sum = gaussian_one + gaussian_two

binomial_one = Binomial(.4, 25)

binomial_two = Binomial(.4, 30)

binomial_sum = binomial_one + binomial_two
print("-----Gaussian mean, standard deviation, and probability density function---")
print(gaussian_one.mean)
print(binomial_one.stdev)
print(gaussian_one.pdf(4))
print("First gaussian",gaussian_one)
print("Second gaussian",gaussian_two)
print("--------sum calculation-----------")
print("sum of two gaussian distribution",gaussian_sum)
print("-----Binomial mean, standard deviation, and probability density function---")
print(binomial_one.mean)
print(binomial_one.stdev)
print(binomial_one.pdf(4))
print("First binomial",binomial_one)
print("Second binomial",binomial_two)
print("--------sum calculation-----------")
print("sum of two binomial distribution", binomial_sum)The following program result-----Gaussian mean, standard deviation, and probability density function---
10
2.449489742783178
0.03947074079064297
First gaussian mean 10, standard deviation 7
Second gaussian mean 15, standard deviation 21
--------sum calculation-----------
sum of two gaussian distribution mean 25, standard deviation 22.135943621178654
-----Binomial mean, standard deviation, and probability density function---
10.0
2.449489742783178
0.00710406209537996
First binomial mean 10.0, standard deviation 2.449489742783178, p 0.4, n 25
Second binomial mean 12.0, standard deviation 2.6832815729997477, p 0.4, n 30
--------sum calculation-----------
sum of two binomial distribution mean 22.0, standard deviation 5.132771315782925, p 0.4, n 55
Package: gaussian-binomial-probability-distribution
This package contain Gaussian distribution and Binomial distribution## Gaussian DistributionAttributes:meanstandard deviationMethods:read_data_file(file_name) - to read in data from a txt filecalculate_mean() - to calculate mean of data setcalculate_stdev() - to calculate standard deviation of data setplot_histogram() - to output a histogram of the instance variable datapdf() - to calculate probability density functionplot_histogram_pdf() - to plot the normalized histogram of the data and a plot of the probability density function## Binomial DistributionAttributes:probabilitysize of trialmeanstandard deviationMethods:read_data_file(file_name) - to read in data from a txt filecalculate_mean() - to calculate mean from p and ncalculate_stdev() - to calculate standard deviation from p and nreplace_stats_with_data() - to calculate p and n from the data setplot_bar() - to output a histogram of the instance variable datapdf() - to calculate probability density functionplot_bar_pdf() - to plot the pdf of the binomial distribution## Installation` pip installgaussian-binomial-probability-distributions`## How to use distribution packageOpen python environment and import the package` python from distributions import Gaussian from distributions import Binomial `
Package: gaussiancl
gaussianclangular power spectra transformation for Gaussian random fieldsThis is a minimal Python package for working with the angular power spectra of
spherical random fields constructed by transforming Gaussian random fields.It can solve for the Gaussian angular power spectrum that will yield a given
target angular power spectrum under a given transformation, such as lognormal.The package can be installed using pip:pip install gaussianclThen import thegaussianclfunction from the package:from gaussiancl import gaussianclFor more information, please see thedocumentation.Current functionality covers the absolutely minimal use case.  Please open an
issue on GitHub if you would like to see anything added.
Package: gaussian-distributions-kueen
distributions-kueen packageThis is a simple distributions package for calculating Gaussian and Binomial distributions.FilesGeneraldistribution.py
Generic distribution class for calculating and visualizing a probability distribution.Gaussiandistribution.py
Gaussian distribution class for calculating and visualizing a Gaussian distribution.Binomialdistribution.py
Binomial distribution class for calculating and visualizing a Binomial distribution.Installationpip install distributions-kueen
Package: gaussianlda
Gaussian LDAAnother implementation of the paperGaussian LDA for Topic Models with Word Embeddings.This is a Python implementation based as closely as possible on
theJava implementationreleased by the paper's authors.InstallationYou'll first need to install thecholdatepackage,following its installation
instructions. (It's not
possible to include this as a dependency for the PyPi package.)Then install gaussianlda using Pip:pip install gaussianldaUsageThe package provides two classes for training Gaussian LDA:Cholesky only,gaussianlda.GaussianLDATrainer: Simple Gibbs sampler
with optional Cholesky decomposition trick.Cholesky+aliasing,gaussianlda.GaussianLDAAliasTrainer:
Cholesky decomposition (not optional) and the Vose aliasing trick.The trainer is prepared by instantiating the training class:corpus: List of documents, where each document is a list of int IDs
of words. These are IDs into the vocabulary and the embeddings matrix.vocab_embeddings: (V, D) Numpy array, where V is the number of words
in the vocabulary and D is the dimensionality of the embeddings.vocab: Vocabulary, given as a list of words, whose position corresponds
to the indices using in the data. This is not strictly needed for training,
but is used to output topics.num_tables: Number of topics to learn.alpha,kappa: Hyperparameters to the doc-topic Dirichlet and
the inverse Wishart priorsave_path: Path to write the model out to after each iteration.mh_steps(aliasing only): Number of Montecarlo-Hastings steps for
each topic sample.Then you set the sampler running for a specified number of iterations
over the training data by callingtrainer.sample(num_iters).ExampleimportnumpyasnpfromgaussianldaimportGaussianLDAAliasTrainer# A small vocabulary as a list of wordsvocab="money business bank finance sheep cow goat pig".split()# A random embedding for each word# Really, you'd want to load something more useful!embeddings=np.random.sample((8,100),dtype=np.float32)corpus=[[0,2,1,1,3,0,6,1],[3,1,1,3,7,0,1,2],[7,5,4,7,7,4,6],[5,6,1,7,7,5,6,4],]# Prepare a trainertrainer=GaussianLDAAliasTrainer(corpus,embeddings,vocab,2,0.1,0.1)# Set training runningtrainer.sample(10)
Package: gaussianmaster
GaussianMaster is here!aussianMaster Package is a modest Python3.X package allowing faster and more automated extractionand manipulation on data from Gaussian calculations. It currently supports extraction form results ofoptimalization and modredundant (scan) runs. The detailed description of the contents is presentedon:https://github.com/panpochec/GaussianMasterYou can contact me directly using lysy.pochec@gmail.comHave fun!And may the odds be ever in your favour
Package: gaussian-process
Wrapper for“sklearn.gp_minimize”for a simpler parameter specification using nested dictionaries.How do I install this package?As usual, just download it using pip:pipinstallgaussian_processTests CoverageSince some software handling coverages sometime get slightly different results, here’s three of them:Keras model optimization using a gaussian processThe following example show a complete usage of GaussianProcess
for tuning the parameters of a Keras model.importsilence_tensorflowfromkeras.modelsimportSequentialfromkeras.layersimportDense,Dropoutfromkeras.datasetsimportboston_housingfromextra_keras_utilsimportset_seedfromtypingimportCallable,Dictimportnumpyasnpfromholdouts_generatorimportholdouts_generator,random_holdoutsfromgaussian_processimportTQDMGaussianProcess,Space,GaussianProcessclassMLP:def__init__(self,holdouts:Callable):self._holdouts=holdoutsdefmlp(self,dense_layers:Dict,dropout_rate:float)->Sequential:returnSequential([*[Dense(**kwargs)forkwargsindense_layers],Dropout(dropout_rate),Dense(1,activation="relu"),])defmodel_score(self,train:np.ndarray,test:np.ndarray,structure:Dict,fit:Dict):model=self.mlp(**structure)model.compile(optimizer="nadam",loss="mse")returnmodel.fit(*train,epochs=1,validation_data=test,verbose=0,**fit).history["val_loss"][-1]defscore(self,structure:Dict,fit:Dict):return-np.mean([self.model_score(training,test,structure,fit)for(training,test),_inself._holdouts()])if__name__=="__main__":set_seed(42)generator=holdouts_generator(*boston_housing.load_data()[0],holdouts=random_holdouts([0.1],[2]))mlp=MLP(generator)space=Space({"structure":{"dense_layers":[{"units":(8,16,32),"activation":("relu","selu")},{"units":[8,16,32],"activation":("relu","selu")}],"dropout_rate":[0.0,1.0]},"fit":{"batch_size":[100,1000]}})gp=GaussianProcess(mlp.score,space)n_calls=3results=gp.minimize(n_calls=n_calls,n_random_starts=1,callback=[TQDMGaussianProcess(n_calls=n_calls)],random_state=42)results=gp.minimize(n_calls=n_calls,n_random_starts=1,callback=[TQDMGaussianProcess(n_calls=n_calls)],random_state=42)print(gp.best_parameters)print(gp.best_optimized_parameters)gp.clear_cache()
Package: gaussianprocessderivatives
A Python package for smoothing data and estimating first- and second-order derivatives and their errors.Covariance functions can either be linear, squared exponential, neural network-like, or squared exponential with a linear trend.An example workflow to smooth data (x, y), where the columns of y are replicates, is>>> import gaussian process as gp>>> g= gp.maternGP({0: (-4, 4), 1: (-4, 4), 2: (-4, -2)}, x, y)The dictionary sets bounds on the hyperparameters, so that 0: (-4, 4) means that the bounds on the first hyperparameter are 1e-4 and 1e4.>>> g.info()explains what each hyperparameter does.Once g is instantiated,>>> g.findhyperparameters()>>> g.results()>>> g.predict(x, derivs= 2)optimises the hyperparameters and determines a smoothed version of the data and estimates the derivatives.The results can be visualised by>>> import matplotlib.pylab as plt>>> plt.figure()>>> plt.subplot(2,1,1)>>> g.sketch('.')>>> plt.subplot(2,1,2)>>> g.sketch('.', derivs= 1)>>> plt.show()and are available as g.f and g.fvar (smoothed data and error), g.df and g.dfvar (estimate of dy/dx), and g.ddf and g.ddfvar (estimate of d2y/dx2).
Package: gaussian_processes
# Gaussian Processes[![Build Status](https://travis-ci.org/jhamrick/gaussian_processes.png?branch=master)](https://travis-ci.org/jhamrick/gaussian_processes)
[![Coverage Status](https://coveralls.io/repos/jhamrick/gaussian_processes/badge.png?branch=master)](https://coveralls.io/r/jhamrick/gaussian_processes?branch=master)gaussian_processesis a Python package for using and analyzing [Gaussian Processes](http://en.wikipedia.org/wiki/Gaussian_process).[Documentation](http://jhamrick.github.io/gaussian_processes/)[GitHub Repository](https://github.com/jhamrick/gaussian_processes)[PyPI](https://pypi.python.org/pypi/gaussian_processes)
Package: gaussianrunner
GaussianRunnerA Python script to run Gaussian automatically and in batches.InstallationBefore you use GaussianRunner, please installGaussianfirst.pipinstallgaussianrunnerYou can test whether the program is running normally:pythonsetup.pypytestExamplesSimple examplefromgaussianrunnerimportGaussianRunner,GaussianAnalystlogfiles=GaussianRunner(keywords="opt freq b3lyp/6-31g(d,p)").runGaussianInParallel("SMILES",["C","C=C","CC","CO","OCCO","C=O","CN","O=O","O"])GaussianAnalyst(properties=["free_energy"]).readFromLOGs(logfiles)[{"name":"C.log","free_energy":-40.49868},{"name":"C=C.log","free_energy":-78.563562},{"name":"CC.log","free_energy":-79.786915},{"name":"CO.log","free_energy":-115.69529},{"name":"OCCO.log","free_energy":-230.198798},{"name":"C=O.log","free_energy":-114.498144},{"name":"CN.log","free_energy":-95.822381},{"name":"O=O.log","free_energy":-150.272624},{"name":"O.log","free_energy":-76.416031},]Running across nodes with MPIFirst, installMPI4PYandMPICH 2:condainstallmpi4pyThen runmpiexample.pywith MPI:mpirun-n9--hostfilehostfilepythonmpiexample.pyThere should be hostfile in the folder.