Saravanan666/pypi-org huggingface dataset:
Package: pymc3020
pymc3020Installpip install pymc3020UsageUsage
=====
  python -m mc3020 [options] <model_path> [another_model_path..]

Options
=======
--help, -h                                        show this help message and exit
--pwd=WORKING_DIRECTORY, -d WORKING_DIRECTORY     code generation base folder          default: $PWD
--gendir=GEN_WORKSPACE, -g GEN_WORKSPACE          code generation workspace folder     default: $PWD/code_generation
--outdir=OUTPUT_DIRECTORY, -o OUTPUT_DIRECTORY    source output folder                 default: $PWD
--variant=VARIANT, -t VARIANT                     code generation dialect              default: cExample:python -m mc3020 -o ../src ../models                               # from gen folder of project
python -m mc3020 -t sysc -d ~/git/myproject/gen -o src ../models   # from a folder outside the projectPackage for releasepython setup.py sdist
twine upload dist/*
Package: pymc3-hmm
PyMC3 HMMHidden Markov models inPyMC3.FeaturesFully implemented PyMC3Distributionclasses for HMM state sequences (DiscreteMarkovChain) and mixtures that are driven by them (SwitchingProcess)A forward-filtering backward-sampling (FFBS) implementation (FFBSStep) that works with NUTS—or any other PyMC3 samplerA conjugate Dirichlet transition matrix sampler (TransMatConjugateStep)Support for time-varying transition matrices in the FFBS sampler and all the relevantDistributionclassesTo use these distributions and step methods in your PyMC3 models, simply import them from thepymc3_hmmpackage.See theexamples directoryfor demonstrations of the aforementioned features.  You can also useBinderto run the examples yourself.InstallationCurrently, the package can be installed viapipdirectly from GitHub$pipinstallgit+https://github.com/AmpersandTV/pymc3-hmmDevelopmentFirst, pull in the source from GitHub:$gitclonegit@github.com:AmpersandTV/pymc3-hmm.gitNext, you can runmake condaormake venvto set up a virtual environment.Once your virtual environment is set up, install the project, its dependencies, and thepre-commithooks:$pipinstall-rrequirements.txt
$pre-commitinstall--install-hooksAfter making changes, be sure to runmake blackin order to automatically format the code and thenmake checkto run the linters and tests.LicenseApache License, Version 2.0
Package: pymc3-models
PyMC3 ModelsCustom PyMC3 models built on top of the scikit-learn API. Check out thedocs.FeaturesReusable PyMC3 models including LinearRegression and HierarchicalLogisticRegressionA base class, BayesianModel, for building your own PyMC3 modelsInstallationThe latest release of PyMC3 Models can be installed from PyPI usingpip:pipinstallpymc3_modelsThe current development branch of PyMC3 Models can be installed from GitHub, also usingpip:pipinstallgit+https://github.com/parsing-science/pymc3_models.gitTo run the package locally (in a virtual environment):git clone https://github.com/parsing-science/pymc3_models.git
cd pymc3_models
virtualenv venv
source venv/bin/activate
pip install -r requirements.txtUsageSince PyMC3 Models is built on top of scikit-learn, you can use the same methods as with a scikit-learn model.frompymc3_modelsimportLinearRegressionLR=LinearRegression()LR.fit(X,Y)LR.predict(X)LR.score(X,Y)ContributeFor more info, seeCONTRIBUTING.Contributor Code of ConductPlease note that this project is released with aContributor Code of Conduct. By participating in this project you agree to abide by its terms. SeeCODE_OF_CONDUCT.AcknowledgmentsThis library is built on top ofPyMC3andscikit-learn.LicenseApache License, Version 2.0
Package: pymc3-quap
pymc3-quapThe quadratic approximation is a very fast method to approximate the posterior with a multivariate normal.NOTE: The quadratic approximation only works well if the posterior is uni-modal and roughly symmetrical.Exampleimportnumpyasnpimportpymc3aspmimportarvizasazfromquapimportquapy=np.array([2642,3503,4358]*10)# Normal with unknown mean and log-variance, with uniform priorswithpm.Model()asm:logsigma=pm.Uniform("logsigma",-100,100)mu=pm.Uniform("mu",-10000,10000)yobs=pm.Normal("y",mu=mu,sigma=pm.math.exp(logsigma),observed=y)idata,posterior=quap([mu,logsigma])az.plot_posterior(idata)idatais anarviz.InferenceDatawith samples from the approximate posterior for compatibility with the Arviz ecosystem.posterioris the exact approximate posteriorscipy.stats.multivariate_normalTrue posterior and quadratic approximation for the example above.Installpip install pymc3-quap
Package: pymca
At this point this module just makes sure that pip install pymca install current PyMca5 version. It is more natural for the user to type pip install pymca than pip install PyMca5.This module will probably evolve into a generic launcher.InstallationTo install, just run:pip install pymcaTo install locally, run:pip install pymca --userDependenciesPyMca5, fisx and numpy for command line use.Matplotlib and one of PyQt5, PySide2 or PySide6 to use the graphical interfaces.LicenseThis code is licensed under the MIT license.
Package: pymcabc
pymcabcAuthorAman DesaiDescriptionMonte Carlo Event Generator for the ABC theoryInstallationpipinstallpymcabcPhysicsThe physics of ABC model (theory) is described in Grifiths and Aitchison.Simple script to start using the package:Import pymcabc:importpymcabcDefine the process, for example:pymcabc.DefineProcess('A A > B B',mA=4,mB=10,mC=1,pi=30)Calculate the total cross section of the process (in barn):pymcabc.CrossSection().calc_xsection()Generate and Save events using a single command. Select whether to allow final state particle decays or not. Also select whether to apply detector effects on particle.pymcabc.SaveEvent(10000,boolDecay=True,boolDetector=True).to_root('name.root')Analyze the root file. Basic analysis is possible by calling thePlotDatamodulepymcabc.PlotData.file('name.root')ReferencesFor physics involved in the calculation, see for example, Introduction to Elementary Particles, David Griffiths.
Package: pymc-bart
Bayesian Additive Regression Trees for Probabilistic programming with PyMCPyMC-BART extendsPyMCprobabilistic programming framework to be able to define and solve models including a BART random variable. PyMC-BART also includes a few helpers function to aid with the interpretation of those models and perform variable selection.InstallationPyMC-BART is available on Conda-Forge. To set up a suitable Conda environment, runcondacreate--name=pymc-bart--channel=conda-forgepymc-bart
condaactivatepymc-bartAlternatively, it can be installed withpipinstallpymc-bartIn case you want to upgrade to the bleeding edge version of the package you can install from GitHub:pipinstallgit+https://github.com/pymc-devs/pymc-bart.gitContributionsPyMC-BART is a community project and welcomes contributions.
Additional information can be found in theContributing ReadmeCode of ConductPyMC-BART wishes to maintain a positive community. Additional details
can be found in theCode of ConductCitationIf you use PyMC-BART and want to cite it please useHere is the citation in BibTeX format@misc{quiroga2022bart,
title={Bayesian additive regression trees for probabilistic programming},
author={Quiroga, Miriana and Garay, Pablo G and Alonso, Juan M. and Loyola, Juan Martin and Martin, Osvaldo A},
year={2022},
doi={10.48550/ARXIV.2206.03619},
archivePrefix={arXiv},
primaryClass={stat.CO}
}LicenseApache License, Version 2.0DonationsPyMC-BART , as other pymc-devs projects, is a non-profit project under the NumFOCUS umbrella. If you want to support PyMC-BART financially, you can donatehere.Sponsors
Package: pymcbdsc
pymcbdscPymcbdsc(Python Minecraft Bedrock Dedicated Server Container Manager (長い...)) は、Bedrock Dedicated Server(以下、 BDS)を手間をかけずに構築・運用する為のスクリプト及び Python モジュールです。Pymcbdsc には次の特徴があります。BDS のアップデートを自動的に行える。コンテナ技術を用いることで、環境を汚さずに BDS を構築できる。定期的なセーブデータのバックアップを行える。なお、 Pymcbdsc は非公式であり、 Minecraft 及び Mojang AB から何ら承認を得たものではありません。OverviewMinecraft Bedrock Edition は不定期に新バージョンがリリースされ、多くの場合は Minecraft (クライアント) が自動的にバージョンアップされます。
Minecraft Bedrock Edition の新バージョンリリースに伴い、 BDS の新バージョンもリリースされますが、残念なことにこちらを自動バージョンアップする手段は用意されていません。Pymcbdsc では、この不便を解消するために BDS を自動バージョンアップする手段を提供します。また、マインクラフト エンドユーザーライセンス規約では Mojang AB の著作物について再頒布が禁止されています。
このため、本モジュールでは本モジュールを利用する各環境で BDS をダウンロードし使用する方式を採用しています。Getting StartedPrerequisitesDocker (Windows の場合はDocker Desktop for Windows) がインストールされ、動作している必要があります。また、 BDS をダウンロード及び利用する為に、下記の利用規約にも同意する必要があります。マインクラフト エンドユーザーライセンス規約プライバシーポリシーInstallingPymcbdsc をインストールします。pip install pymcbdscディレクトリ(フォルダ)やファイルを配置します。python -m pymcbdsc installまたはmcbdsc installConfigurationTagBDS (というか、 Minecraft) のバージョニングはmajor.minor.patch.revisionとなっております。
本モジュールでは、作成した Docker Image に対してこの BDS のバージョンをもとに Tag の付与を行います。本モジュールが付与する Tag は次の3種類です。タグの種類意味例latest最新の BDS バージョンのイメージを指します。latestminormajor.minor毎に作成され、各 BDS マイナーバージョンの最新イメージを指します。1.16revisionmajor.minor.patch.revisionすべてを含み、各 BDS バージョンのイメージを指します。1.16.201.02AuthorsKodai TooiGitHub,QiitaLicenseThis project is licensed under the MIT License - see theLICENSEfile for details
Package: py-mcc-f1
MCC-F1 Python packageRecently, the MCC-F1 curve has been proposed as an alternative, better way of assessing the performance of score-based binary classifiers [1].This Python package implements a function to compute the MCC-F1 curve, namelymcc_f1_curve, similarly to theprecision_recall_curveandroc_curvefunctions ofscikit-learn.Installationpip install py-mcc-f1Usagefrommcc_f1importmcc_f1_curve,plot_mcc_f1_curveimportnumpyasnpimportmatplotlib.pyplotaspltfromsklearn.datasetsimportload_breast_cancerfromsklearn.linear_modelimportLogisticRegressionfromsklearn.model_selectionimporttrain_test_split# Load data and train modelX,y=load_breast_cancer(return_X_y=True)X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.33)clf=LogisticRegression().fit(X_train,y_train)# Calculate MCC-F1 metric# @TODO# Get predictions and MCC-F1 curve pointsy_score=clf.predict_proba(X_test)[:,1]mcc,f1,thresholds=mcc_f1_curve(y_test,y_score)# Plot MCC-F1 curveplot_mcc_f1_curve(clf,X_test,y_test)Please refer to the function's docstring for further comments and details.Future enhancementsFunction to plot the MCC-F1 curve, (e.g.,plot_mcc_f1_curve), similar tosklearn/metrics/_plot/precision_recall_curve.pyandsklearn/metrics/_plot/roc_curve.py;Function to compute the MCC-F1 metric, as defined in section 2.2 of the original paper.ContributingIf you would like to contribute to this package, please follow thecommon community guidelines.Please, also keep in mind that the main goal of this project is to be of similar implementation and quality as scikit-learn. Pull requests should pass the existing unit-tests, and add new ones when necessary.To run the tests:make testLicenseThis package is distributed under theMIT license.References[2006.11278] The MCC-F1 curve: a performance evaluation technique for binary classification
Package: pymccool
Installationpip install pymccoolUsageFor basic, no-nonsense console and file logging:frompymccool.loggingimportLoggerlogger=Logger(app_name="<your app name>")For more options, use LoggerKwargsfrompymccool.loggingimportLogger,LoggerKwargslogger=Logger(LoggerKwargs(app_name="test_logger_loki",default_level=Logger.VERBOSE,stream_level=Logger.VERBOSE,grafana_loki_endpoint="https://loki.end.point.com/loki/api/v1/push"))To use the Tracer:fromuuidimportuuid1frompymccool.tracingimportget_tracer,get_decoratorfrompymccool.loggingimportLogger,LoggerKwargslogger=Logger(LoggerKwargs(app_name="test_logger_loki",default_level=Logger.VERBOSE,stream_level=Logger.VERBOSE,grafana_loki_endpoint="https://loki.end.point.com/loki/api/v1/push"))tracer=get_tracer(service_name="test_tracer",endpoint="https://otel-rec.end.point.com/v1/traces",uuid=UUID)instrument_decorator=get_decorator(e2e_tracer)
Package: pymccorrelation
pymccorrelationA tool to calculate correlation coefficients for data, using bootstrapping and/or perturbation to estimate the uncertainties on the correlation coefficient.
This was initially a python implementation of theCurran (2014)method for calculating uncertainties on Spearman's Rank Correlation Coefficient, but has since been expanded.
Curran's original C implementation isMCSpearman(ASCL entry).Currently the following correlation coefficients can be calculated (with bootstrapping and/or perturbation):Pearson's rSpearman's rhoKendall's tauKendall's tau can also calculated when some of the data are left/right censored, following the method described byIsobe+1986.Requirementspython3scipynumpyInstallationpymccorrelationis available via PyPi and can be installed with:pip install pymccorrelationUsagepymccorrelationexports a single function to the user (also calledpymccorrelation).from pymccorrelation import pymccorrelation

[... load your data ...]The correlation coefficient can be one ofpearsonr,spearmanr, orkendallt.For example, to compute the Pearson's r for a sample, using 1000 bootstrapping iterations to estimate the uncertainties:res = pymccorrelation(data['x'], data['y'],
                      coeff='pearsonr',
                      Nboot=1000)The output,resis a tuple of length 2, and the two elements are:numpy array with the correlation coefficient (Pearson's r, in this case) percentiles (by default 16%, 50%, and 84%)numpy array with the p-value percentiles (by default 16%, 50%, and 84%)The percentile ranges can be adjusted using thepercentileskeyword argument.Additionally, if the full posterior distribution is desired, that can be obtained by setting thereturn_distkeyword argument toTrue.
In that case,resbecomes a tuple of length four:numpy array with the correlation coefficient (Pearson's r, in this case) percentiles (by default 16%, 50%, and 84%)numpy array with the p-value percentiles (by default 16%, 50%, and 84%)numpy array with full set of correlation coefficient values from the bootstrappingnumpy array with the full set of p-values computed from the bootstrappingPlease see the docstring for the full set of arguments and information including measurement uncertainties (necessary for point perturbation) and for marking censored data.CitingIf you use this script as part of your research, I encourage you to cite the following papers:Curran 2014: Describes the technique and application to Spearman's rank correlation coefficientPrivon+ 2020: First use of this software, aspymcspearman.Please also citescipyandnumpy.If your work uses Kendall's tau with censored data please also cite:Isobe+ 1986: Censoring of data when computing Kendall's rank correlation coefficient.
Package: pymccrgb
pymccrgbpymccrgbis a Python package for multiscale curvature classification of
point clouds with color attributes.It extends a popular classification method
(MCC lidar)[0]to point cloud datasets with multiple color channels, such as those
commonly produced in surveys using drone photography or other platforms. It can be used to distinguish points from the
ground surface and low vegetation in data produced by structure from motion photogrammetry,
stereo photogrammetry, or multi-spectral lidar scanning, or to filter colorized lidar point clouds.The intended users are scientists in geomorphology, ecology, or planetary science
who want to classify point clouds for topographic analysis, canopy height measurements, or other spectral classification.InstallationThis package is developed for Linux and Python 3.6+. It depends on common
Python packages like sklearn, numpy, the LibLAS C API, andMCC Python bindings.You can install it withconda:condaenvcreate-npymcc
condaactivatepymcc
condainstallpymccrgb-cconda-forgeRequirementsThe LibLAS C library is required for MCC andpymccrgb. The MCC wrapper also
requires Boost and the C++11 or later standard library. These are installed
with the conda package.Refer to thedocumentationand theLibLAS install guidefor
instructions for installing LibLAS from source.ExamplesExample notebooks are available in the docs or atdocs/source/examples.Topography under tree coverfrompymccrgbimportmcc,mcc_rgbfrompymccrgb.datasetsimportload_mammoth_lidarfrompymccrgb.plottingimportplot_results# Load sample data (Mammoth Mountain, CA)data=load_mammoth_lidar(npoints=1e6)# MCC algorithmground_mcc,labels_mcc=mcc(data)# MCC-RGB algorithmground_mccrgb,labels_mccrgb=mcc_rgb(data)plot_results(data,labels_mcc,labels_mccrgb)Results of MCC and MCC-RGB on a forested area near Mammoth Mountain, CA.DocumentationRead the documentation for example use cases, an API reference, and more atpymccrgb.readthedocs.io.ContributingBug reportsBug reports are much appreciated. Pleaseopen an issuewith thebuglabel,
and provide a minimal example illustrating the problem.SuggestionsFeel free tosuggest new featuresin an issue with thenew-featurelabel.Pull requestsIf you would like to add a feature or fix a bug, please fork the repository, create a feature branch, andsubmit a PRand reference any relevant issues. There are nice guides to contributing with GitHubhereandhere. Please include tests where appropriate and check that the test suite passes (a Travis build orpytest pymccrgb/tests) before submitting.Support and questionsPleaseopen an issuewith your question.References[0] Evans, J. S., & Hudak, A. T. 2007. A multiscale curvature algorithm for classifying discrete return LiDAR in forested environments. IEEE Transactions on Geoscience and Remote Sensing, 45(4), 1029-1038doiLicenseThis work is licensed under the MIT License (seeLICENSE). It also
incorporates a wrapper for themcc-lidarimplementation,
which is distributed under the Apache license (seeLICENSE.txt).
Package: pymcd
Project descriptionThis package (pymcd) computes Mel Cepstral Distortion (MCD) in python, which is used to assess the quality of the generated speech by comparing the discrepancy between generated and ground-truth speeches.OverviewMel Cepstral Distortion (MCD) is a measure of how different two sequences of mel cepstra are, which is widely used to evaluate the performance of speech synthesis models. The MCD metric compares k-th (default k=13) Mel Frequency Cepstral Coefficient (MFCC) vectors derived from the generated speech and ground truth, respectively.The pymcd package provides scripts to compute a variety of forms of MCD score:MCD (plain): the conventional MCD metric, which requires the lengths of two input speeches to be the same. Otherwise, it would simply extend the shorted speech to the length of longer one by padding zero for the time-domain waveform.MCD-DTW: an improved MCD metric that adopts the Dynamic Time Warping (DTW) algorithm to find the minimum MCD between two speeches.MCD-DTW-SL: MCD-DTW weighted by Speech Length (SL) evaluates both the length and the quality of alignment between two speeches. Based on the MCD-DTW metric, the MCD-DTW-SL incorporates an additional coefficient w.r.t. the difference between the lengths of two speeches.More details of the above three types of MCD can be found inV2C: Visual Voice Cloning.LicensePlease see the file License for details of the license and warranty for mcd.InstallationRequire Python 3, the package can be installed and updated using pip, i.e.,pip install -U pymcdExamplefrom pymcd.mcd import Calculate_MCD

# instance of MCD class
# three different modes "plain", "dtw" and "dtw_sl" for the above three MCD metrics
mcd_toolbox = Calculate_MCD(MCD_mode="plain")

# two inputs w.r.t. reference (ground-truth) and synthesized speeches, respectively
mcd_value = mcd_toolbox.calculate_mcd("001.wav", "002.wav")
Package: pymcdream
A prototype based on the algorithm inJ.A. Vrugt, C.J.F. ter Braak, C.G.H. Diks, D. Higdon, B.A. Robinson, and J.M. Hyman: Accelerating Markov chain Monte Carlo simulation by differential evolution with self-adaptive randomized subspace sampling.  International Journal of Nonlinear Sciences and Numerical Simulation, 2008, In Press.
Package: pymcef
Python Monte Carlo Efficient Frontier (PyMCEF) packagePurposePyMCEF is a python package that can generate efficient frontier based on Monte Carlo simulated returns.A Quickstart tutorialBenchmarkPyMCEF is based on axiomatic Second-order Stochastic dominance portfolio theory.Absolute SemiDeviation and Fixed-target expected under performance are used as the risk measure for
this stochastic programming problem.
These two risk measures don’t have the theoretical flaw in mean variance model.One example when mean variance model failsUser inputThe Monte Carlo simulated returns for all the assets in the investment universe is the input
and will be to used to train the efficient frontier.(Optional) The returns as a validation set to measure the performance of the efficient frontier.Computation resultsThe complete efficient frontier stored as a vector of efficient portfolios,
each of which containing the following:A python dictionary, storing the asset index and weight in the portfolioIn sample performance (Sharpe ratio etc.)The lower and upper bound for the risk tolerance producing this particular portfolioValidation performance, if validation Monte Carlo simulated returns are provided.AdvantageThis package implements the algorithm introduced by Prof. Robert J. Vanderbei in his Book:Linear Programming: Foundations and Extensionsand paperFrontiers of Stochastically Nondominated PortfoliosThis algorithm is very efficient, starting with risk tolerance (lagrangian multiplier) being infinite and the optimal
portfolio being 100% in the asset with the largest average return, only portfolios on the efficient
frontier will be visited. With the product of number of assets and number of simulated return less than
10 million, the time needed to construct the full efficient frontier is less than 1 minute.Speed comparison on efficient frontier construction with other LP solversThis algorithm is based on simulated returns so it is model agnosticThis introduce huge flexibility to the user as no assumption is made on the type of return distribution (e.g. Gaussian).
Package: pymcel
PymcelUtilidades de Mecánica CelesteEl paquetepymcelcontiene un conjunto de utilidades que pueden
usarse para la enseñanza de (o la investigación en) Mecánica Celeste o
Astrodinámica.Las utilidades que contienen el paquete fueron originalmente
desarrolladas como parte del libroMecánica Celeste: teoría,
algoritmos y problemasdel profesor Jorge I. Zuluaga de la
Universidad de Antioquia.Download and installpymcelesta disponible enPyPI,https://pypi.org/project/pymcel/.
Para instalar solo debe ejecutar.pip install -U pymcelSi usted prefiere puede descargar e instalar directamente desde lasfuentes.Es también interesante consultar elrepositorio enGitHubdel paquete, donde además de las fuentes,
encontrará, entre otras cosas utiles, cuadernos de ejemplos y tutoriales sobre el uso del paquete.
Muchos de estos cuadernos incorporan los códigos que vienen con el libro y pueden ser ejecutados
por comodidad enGoogle Colaboratory.Para empezarPara empezar a usar el paquete basta que lo importe:importpymcelaspc¿Qué hay de nuevo?Para una lista detallada de las características más nuevas
introducidas en el paquete con la última versión vea el archivoWhat's
new.Este paquete ha sido diseñado y escrito originalmente por Jorge I. Zuluaga (C) 2023