Saravanan666/pypi-org huggingface dataset:
Package: ensemble-integration
ensemble-integration: Integrating multi-modal data for predictive modelingensemble-integration(oreipy) leverages multi-modal data to build classifiers using a late fusion approach.
In eipy, base predictors are trained on each modality before being ensembled at the late stage.This implementation of eipy can utilizesklearn-likemodels only, therefore, for unstructured data,
e.g. images, it is recommended to perform feature selection prior to using eipy. We hope to allow for a wider range of base predictors,
i.e. deep learning methods, in future releases. A key feature ofeipyis its built-in nested cross-validation approach, allowing for a
fair comparison of a collection of user-defined ensemble methods.Documentation including tutorials are available athttps://eipy.readthedocs.io/en/latest/.InstallationAs usual it is recommended to set up a virtual environment prior to installation.
You can install ensemble-integration with pip:pip installensemble-integrationCitationIf you useensemble-integrationin a scientific publication please cite the following:Jamie J. R. Bennett, Yan Chak Li and Gaurav Pandey.An Open-Source Python Package for Multi-modal Data Integration using Heterogeneous Ensembles,https://doi.org/10.48550/arXiv.2401.09582.Yan Chak Li, Linhua Wang, Jeffrey N Law, T M Murali, Gaurav Pandey.Integrating multimodal data through interpretable heterogeneous ensembles, Bioinformatics Advances, Volume 2, Issue 1, 2022, vbac065,https://doi.org/10.1093/bioadv/vbac065.
Package: ensemblem
Dynamic Weighted Ensemble - Local FusionThis repository contains an implementation for the Dynamic Weighted Ensemble (DWE) - Local Fusion method. Find the paper in this ref onIEEE.Local Fusion is an ensemble techinque that could be used to improve predictions by weighing appropriately the single models contribution.InstallationPypipip install ensemblemDocs - ReadTheDocs(UnderReview)UsageFirst of all, you need to define the KWEnsembler class. Next, it's required to provide the search-space (it could be the validation set / neighbours-set) in which the ensembler will find the nearest elements to the generic test sample.from ensemblem.model import KWEnsembler
	ensemble = KWEnsembler(5)
	ensemble.fit(X_validation, y_validation)Finally, calling the prediction method the class will produce the forecasts.ensemble.predict(X_test,
                    features_space,
                    other_model_prediction_columns)The class returns predictions in the same order in which they are provided.
It supports one or multiple samples to forecasts. In this library, we refers to the neighbours-set as the space in which the ensembler will find the nearest elements to the generic test sample.Example of using the KWEnsembler classYou can find a detailed tutorial in the readthedocs webpage.Load dataSplit data into train, neighbours-set and test setsTrain multiple expert models on the train dataGenerate predictions for the test dataTrain the ensembler on neighbours-setGenerate predictions for the test dataset using ensemblerCompare the predictions from the ensembler with the predictions from the expert modelsResults & BenchmarksModelMAPEMAERMSERMSLE0Ensemble0.3041290.4993810.00161180.2119991Tree 10.3709190.5936060.007559260.2493732Tree 20.3196380.5112490.002240470.2250123RidgeCV0.315370.5311770.01312160.238018CreditsAlgorithm ApplicationsA dynamic weighting ensemble approach for wind energy production predictionIEEEAn ensemble approach to sensor fault detection and signal reconstruction for nuclear system controlElsevierPossible Improvements[Docs] General improvements over documentations[Code] Clean-code[Engineering] When dealing with features coming with magnitude and different meaning, it's relevant to normalize values appropriately.[Engineering] Additional measures to the simple euclidean-spaceLicenceThe code is provided with a MIT licence.
Package: ensemble-md
Ensemble Molecular Dynamicsensemble_mdis a Python package that provides methods for setting up, running, and analyzing molecular dynamics ensembles in GROMACS. The current implementation is mainly for synchronous ensemble of expanded ensemble (EXEE), but we will develop methods like asynchronous EEXE, or ensemble of alchemical metadynamics in the future. For installation instructions, theory overview, tutorials, and API references, please visit thedocumentation.CopyrightCopyright (c) 2022, Wei-Tse HsuAcknowledgementsProject based on theComputational Molecular Science Python Cookiecutterversion 1.6.
Package: ensemble-outlier-sample-detection
ensemble_outlier_sample_detectionA method for removing outlier samples.How to use.You can see more details in theexample.fromensemble_outlier_sample_detectionimportEnsembleOutlierSampleDetectorelo=EnsembleOutlierSampleDetector(random_state=334,n_jobs=-1)elo.fit(X,y)elo.outlier_support_# boolean(np.ndarray)ReferencePaperhttps://www.sciencedirect.com/science/article/abs/pii/S0169743917305919?via%3DihubSiteshttps://github.com/hkaneko1985/ensemble_outlier_sample_detectionhttps://datachemeng.com/outlier_samples_detectionc_python/LICENSECopyright © 2021 yu9824Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: ensembleperturbation
Ensemble PerturbationPython library for perturbing coupled model inputs into ensemble runs. Provides
perturbation and results comparison.pipinstallensembleperturbationDocumentation can be found athttps://ensembleperturbation.readthedocs.ioCommand-line interfaceensembleperturbationexposes the following CLI commands:make_storm_ensembleperturb_trackscombine_resultsplot_results
Package: ensemble-regressor
Softwareentwicklung 2 - ProjektarbeitPACKAGE-BeschreibungDateienKlasse: RegressorKlasse: Ensemble RegressorTesten: Unittesting2-Do'sVorgaben in Python-Package umsetzenPython Klassen erstelltPython-Paket erstellenautomatisierenUnittesting (mind. 5) um Funktionalität der Klasse zu testenREST-Webservice entwickeln, der das erstellte Paket nutzt und passende Endpoints anbietetDocker-Image erstellen für den erstellten Web-Servicegitlab-Pipeline entwickeln um Tests und alle anderen automatisierten Schritte auszuführen
Package: ensemble-tabpfn
Ensemble TabPFNTabPFN is a transformer architecture prosposed byHollman et alfor classification on small tabular datasets. It is a Prior-Data Fitted Network that has been trained once and does not require fine tuning for new datasets. It works by approximating the distribution of new data to the prior synthetic data it has seen during training. In a machine learning pipeline, this network can be "fit" on a training dataset in under a second and can generate predictions for the test set in a single forward pass in the network. However there are limitations in the current architecture, namely, the training dataset can contain only upto 1000 inputs with upto 100 numerical features. In addition, the network can predict only upto 10 classes in a multi-class classification problem. With EnsembleTabPFN, we address two of these issues where we have extended the original model to work with datasets containing more than 1000 samples and 100 features.
EnsembleTabPFN is fully compatible with Scikit-learn API and can be used in a modelling pipeline.InstallationFrom sourcegitclonehttps://github.com/ersilia-os/ensemble-tabpfn.gitcdensemble-tabpfn
pipinstall.From PyPIpipinstallensemble-tabpfnUsing Poetrygitclonehttps://github.com/ersilia-os/ensemble-tabpfn.gitcdensemble-tabpfnpoetryinstall--withoutdev,test,docsUsagefromensemble_tabpfnimportEnsembleTabPFNfromsklearn.metricsimportaccuracy_scoreclf=EnsembleTabPFN()clf.fit(X_train,y_train)y_hat=clf.predict(y_test)acc=accuracy_score(y_test,y_hat)
Package: ensemblizer
Ensemblizerensemblizeris a small package for various ensemble methodsModelCollectionis a simple way to aggregate models so that they can be trained together.CatEnsembletakes aModelCollectionobject (or the same input as one) with an additional ensemble model.  The ensemble model will train on the predicted probabilities (or just predictions) of theModelCollectionand make a separate prediction.  This ensemble method allows for different weighting schemes of the outputs of each model as well as stacking the original data with the predictions when training the ensemble model.  Additionally, this ensemble class allows you to pretrain theModelCollectionobject prior to training the ensemble model or training theModelCollectionobjectwiththe ensemble model.  This allows for more efficient hyperparameter tuning (albeit much longer training and tuning times).Hyperparameters can be trained like any other scikit-learn-esque model.  When setting parameters for the ensemble model, parameters that begin withname__will set the hyperparameter of thenamemodel in the collection or ensemble model (default name for ensemble model is "ensemble").  Parameters that start with__namewill update the weight of thenamemodel in the collection.  This allows the weighting scheme of the ensemble to be tuned with all other parameters using any scikit-learn tuning package.Current Version is v0.04This package is currently in the beginning stages but future work is planned.Installationpip install ensemblizerUsageimport numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import MultinomialNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
from ensemblizer import ModelCollection, CatEnsemble

np.random.seed(0)
x_train = np.random.randint(0, 10, (80, 3))
x_test = np.random.randint(0, 10, (20, 3))
y_train = np.random.randint(0, 2, 80)
y_test = np.random.randint(0, 2, 20)

models = ModelCollection([('log', LogisticRegression(random_state=0)),('nb', MultinomialNB())])
test.fit(x_train, y_train)

ensemble = CatEnsemble(test, KNeighborsClassifier())
ensemble.fit(x_train, y_train)
test_preds = ensemble.predict(x_test)
print(f"Accuracy on test set is {accuracy_score(y_test, test_preds)}"

#change the C param of the 'log' model to 15, the alpha param of the 'nb' model to 1,
#the n_neighbors param of the ensemble model to 10, and the weight of the 'log' model to 3  
ens.set_params('log__C': 15, 'nb__alpha': 1, 'ensemble__n_neighbors': 10, '__log': 3})
ens.fit(x_train, y_train)
test_preds = ensemble.predict(x_test)
print(f"Accuracy on test set is {accuracy_score(y_test, test_preds)}"Future PlansThe next step is to create an ensemble regressor model.LicenseLol
Package: ensemblrestpy
INSTALLATIONpipinstallensemblrestpyquick startPython client for Ensembl REST APIimportpprintfromensemblimportEnsemblensembl=Ensembl()pprint.pprint(ensembl.variant_recoder("rs137853120",fields="id",var_synonyms=1))pprint.pprint(ensembl.variation("rs137853120",pops=1))pprint.pprint(ensembl.vep_id("rs137853120",dbNSFP="gnomAD_genomes_EAS_AF,gnomAD_genomes_EAS_AC,gnomAD_genomes_EAS_AN"))
Package: ensembl-variant-lookup
Ensembl Variant LookupEnsembl Variant Lookupprovides a web-based graphical interface, allowing users to retrieve information about genetic variants based on their Reference SNP ID (RSID). This application integrates with the Ensembl Variant API to provide detailed variant information.OverviewEnsembl Variant Lookupis a Python tool built with Flask that allows users to query and retrieve information about genetic variants from the Ensembl database. It provides a user-friendly interface for searching individual variants, batch queries, and exploring gene regions. The tool is designed to streamline the retrieval of essential genetic variant data, making it a valuable resource for genomics research and exploration.FeaturesSingle Variant Lookup:Retrieve detailed information about a specific genetic variant using its RSID.Batch Variant Lookup:Perform batch searches by entering a list of RSIDs and obtaining information for multiple variants simultaneously.Gene Lookup:Fetch information about a specific gene, including details on associated variants.Simplified illustration at high-level of API exposed in thie application, it includes all the API endpoints in the diagram:graph TD
  A[User's Browser] -->|GET /| B[Flask Application]
  B -->|GET /| C[Render index.html]
  C -->|Form Submission| D[Flask Application]
  D -->|POST /batch| E[Render batch_results.html]
  C -->|Form Submission| F[Flask Application]
  F -->|POST /visualize| G[Render visualization.html]
  C -->|Form Submission| H[Flask Application]
  H -->|POST /variant| I[Render variant_results.html]
  C -->|GET /gene_region| J[Flask Application]
  J -->|GET /gene_region| K[Render gene_region_results.html]This flowchart now includes the following API endpoints:/batch(POST): Batch search for variants by rsid list./variant(POST): Search for variants by rsid./gene_region(GET): Search for variants in a gene region./visualize(POST): Visualize variants for a specific gene.InstallationUsepipto install the Ensembl Variant Lookup package.pipinstallensembl-variant-lookupUsageRun the Application:ensembl-variant-lookupThis command starts the Flask development server, and you can access the application athttp://localhost:5000in your web browser.Access the Web Interface:Open your web browser and navigate tohttp://localhost:5000to use the Ensembl Variant Lookup tool.Single Variant Lookup:Enter a specific RSID in the provided form.Click the "Fetch Variant" button to retrieve detailed information for the specified genetic variant.Batch Variant Lookup:Enter a list of RSIDs (comma-separated) in the batch search form.Click the "Batch Search" button to obtain information for multiple variants simultaneously.Gene Lookup:Enter the gene name in the gene lookup form.Click the "Fetch Gene Info" button to retrieve details about the specified gene.ScreenshotsCaption 1:Screenshot of the Home Page.Caption 2:Screenshot of the Single Variant Lookup interface.Caption 3:Screenshot of the Batch Variant Lookup interface.Caption 4:Screenshot of the Gene Lookup interface.ContributingIf you would like to contribute to this project, please contact or leave here an issueissue
Package: ensenso-nxlib
Announcement:With Ensenso SDK version 3.3 we stop the maintenance of ourGitHub repository, since
our SDK now includes a corresponding Python interface package. The Ensenso SDK
can be downloadedhere.We will continue to provide the package on PyPI, however, with a few changes:The package is from now on namednxlibFor each new SDK release there will be a corresponding package with the same
version number as the SDKWe will also publish the package under the old nameensenso_nxlib(for those who do not
want to or cannot change their dependency list)Check ourmanualfor installation
guidelines and a detailed description including some examples to get you
started.
Package: enshroud
enShroudA steganography tool to hide secret texts in white space.Usage:To encode:enShroud-e-pPATH_TO_TEXT_FILE-oPATH_TO_OUTPUT-s"SECRET_MESSAGE_IN_QUOTES"To decode:enShroud-d-pPATH_TO_TEXT_FILENOTE: Add the path where enShroud is installed to your PATH variable.Alternate Method:Download the .whl file frompypi downloadssection.In the directory where the .whl file is downloaded, run:pipinstallfile_name.whl
Package: ensight-reader
ensight-readerThis library provides a pure Python reader (with some writing capability) for the EnSight Gold data format,
a common format for results of computational fluid dynamics (CFD) simulations.
It also comes with a few CLI tools, notablyensight_transformwhich
allows you to perform in-place scaling/translation/etc. of the geometry in your case.The library designed for efficient, selective, memory-mapped access to data from EnSight Gold case –
something that would be useful when importing the data into other systems. If you're looking for a more "batteries included" solution, look atvtkEnSightGoldBinaryReaderfrom the VTK library (see docs for comparison).RequirementsPython 3.9+NumPy 1.21+Installationpipinstallensight-readerExample – Python APIimportensightreaderimportnumpyasnpcase=ensightreader.read_case("example.case")geofile=case.get_geometry_model()part_names=geofile.get_part_names()# ["internalMesh", ...]part=geofile.get_part_by_name(part_names[0])N=part.number_of_nodeswithgeofile.open()asfp_geo:node_coordinates=part.read_coordinates(fp_geo)# np.ndarray((N, 3), dtype=np.float32)variable=case.get_variable("UMean")withvariable.mmap_writable()asmm_var:data=variable.read_node_data(mm_var,part.part_id)data[:]=np.sqrt(data)# transform variable data in-placeExample – CLI# increment X coordinateensight_transform--translate100sphere.case# scale by 1000 (eg. m -> mm conversion)ensight_transform--scale1e31e31e3sphere.case# rotation matrixensight_transform--matrix\0-100\1000\0010\0001\sphere.case# transform only "internalMesh" partensight_transform--translate100--only-partsinternalMeshmotorbike.caseTo learn more, pleasesee the documentation.
Package: ens-label-inspector
NameHash Label InspectorThe Label Inspector is a critical component of the NameHash software stack that is used to protect users from malicious domain names.ENS-tailored domain name label inspectionCharacter and grapheme information, scripts, codepoints, ...Confusable grapheme detectionRendering checks for different fontsENSIP-15 verification with detailed explanations and auto-suggestionsPunycode and DNS hostname compatibility checksSupports many use casesStandalone Python library (PyPI)ASGI web serverAmazon AWS LambdahandlerGetting StartedInstalling the libraryThe Label Inspector is available as a Python library onPyPI. You can install it withpip:pipinstallens-label-inspectorStarting the web serverA FastAPI application is included in thelabel_inspector.web_apimodule. The default installation from PyPI does not include an ASGI server, so you will need to install one separately. For example, to installuvicorn:pipinstall'uvicorn[standard]'You can start the web server with:uvicornlabel_inspector.web_api:appMake an example request:curl-d'{"label":"nick"}'-H"Content-Type: application/json"-XPOSThttp://localhos
t:8000# {"label":"nick","status":"normalized", ...Using the AWS Lambda handlerThe Label Inspector includes a handler forAmazon AWS Lambda. It is available in thelabel_inspector.lambdamodule. You can use it to create a Lambda function that will respond to HTTP requests. It uses themangumlibrary.See the includedDockerfilefor an example of how to build a Lambda deployment package.
Package: enslyon.opdsshowroom
Introduction============This product is a simple implementation of how quick you can integrateREST data in a plone view with requests and lxml.The showroom is a dexterity type that take a link to an OPDS libraryand the url of a REST API returning an HTML page. This page shouldcontain the library presentation and content.It was done for the Ecole Normale Superieure de Lyon - Institut Francais de l'Education for the projectmetnav (Metadata Navigation).enslyon.opdsshowroom Installation---------------------------------To install enslyon.opdsshowroom using zc.buildout and the plone.recipe.zope2instancerecipe to manage your project, you can do this:* Add ``enslyon.opdsshowroom`` to the list of eggs to install, e.g.:[buildout]...eggs =...enslyon.opdsshowroom* Re-run buildout, e.g. with:$ ./bin/buildoutChangelog=========1.0.3 (2015-10-28)-------------------- Add 'Exclude Navigation' Behavior[encolpe]1.0.2 (2015-10-26)-------------------- Add the i18n script[encolpe]- Add the first translation: English and French[encolpe]- Fix duplicate description and add a class name to our base tag[encolpe]1.0.1 (2015-10-23)-------------------- Add the missing MANIFEST.in file[encolpe]1.0 (2015-10-23)-------------------- Initial release[encolpe]
Package: ensmallen
Ensmallen is the Rust/Python high-performance graph processing submodule of the🍇 GRAPElibrary.How to install EnsmallenTo install the complete GraPE library, do run:pipinstallgrapeInstead, to exclusively install the Ensmallen package, you can run:pipinstallensmallenCompiling the wheelsSeethis pageto compile the bindings yourself.ContributingPlease refer to theCONTRIBUTING.mdfile.Cite GraPEPlease cite the following paper if it was useful for your research:@misc{cappelletti2021grape,title={GraPE: fast and scalable Graph Processing and Embedding},author={Luca Cappelletti and Tommaso Fontana and Elena Casiraghi and Vida Ravanmehr and Tiffany J. Callahan and Marcin P. Joachimiak and Christopher J. Mungall and Peter N. Robinson and Justin Reese and Giorgio Valentini},year={2021},eprint={2110.06196},archivePrefix={arXiv},primaryClass={cs.LG}}
Package: ensmallen-graph
Python BindingsHow to install thisThis project is currently work in progress, and is to be considered for all
intents and porposes analphaversion.To install thelatest (alpha) release, run the following:pipinstallensmallen_graphCompile the bindingsThe project uses PyO3 and maturin.
You need nightly rust in order to compile PyO3.
This could be done by running:curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh --default-toolchain nightly --profile default -yThen we need to install maturin with:cargo install maturinAnd finally we can create the Wheels with:maturin build --releaseThe wheels will be located in./target/wheels/.Compile the bindings for multiple Python versionsBy default maturin will build for the installed python version.To install other Python versions just run:wgethttps://www.python.org/ftp/python/${PYTHON_VERSION}/Python-${PYTHON_VERSION}.tar.xz
tar-xfPython-${PYTHON_VERSION}.tar.xz(cdPython-${PYTHON_VERSION};./configure--enable-optimizations;make-j$(nproc);make-j$(nproc)install)Where${PYTHON_VERSION}is the choosen version, such as3.8.3or3.6.10.Solving the GLIBC__2.29__ not found errorThis means that the linux package were built on a system with a really new Libc version.
This can be solved by compiling your own bindings.
In order to be compatible with as many systems as possible, we suggest to build them on the official Manylinux1 docker.Exploiting AvxThe library vec_rand which is used in the crate can take advantage in using Avx instructions/To compile the bindings with Avx Instructions you can run :RUSTFLAGS=" -C target-cpu=native"maturinbuild--release--no-sdistCompiling the bindings for Linux to push them to PipyIn order to make the wheels usable by any linux system we must follow themanylinux2010standard. We used to supportmanylinux1but rust no longer support Glibc 2.5 so we had to bump it to the next standard.This can be done by building the bindings inside a centos5 docker with:gitclonehttps://github.com/LucaCappelletti95/ensmallen_graphcdensmallen_graph
makebuild_manylinux2010python_manylinux2010The result wheels will be in./ensmallen_graph/bindings/python/target/wheels/.A wheel will be created for each version of python, this is configurable in the Dockerfile./ensmallen_graph/setup/DockerFileManylinux2010in a ENV var.A tutorial on how the internals of Python's Cffi can be foundhere
Package: ens-namehash
# ENS NamehashThis package is an implementation of thenamehashalgorithm from
[EIP137](https://github.com/ethereum/EIPs/issues/137).### QuickstartInstall the package:`bash $ pip installens-namehash`Hash some names!`python >>> from namehash import namehash >>>namehash('')...b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'>>>namehash('eth')...b'\x93\xcd\xebp\x8buE\xdcf\x8e\xb9(\x01v\x16\x9d\x1c3\xcf\xd8\xedo\x04i\n\x0b\xcc\x88\xa9?\xc4\xae'>>>namehash('foo.eth')...b'\xde\x9b\t\xfd|_\x90\x1e#\xa3\xf1\x9f\xec\xc5H(\xe9\xc8HS\x98\x01\xe8e\x91\xbd\x98\x01\xb0\x19\xf8O'`