Saravanan666/pypi-org huggingface dataset:
Package: scikit-diveMove
scikit-diveMoveis a Python interface to R packagediveMovefor
scientific data analysis, with a focus on diving behaviour analysis.  It
has utilities to represent, visualize, filter, analyse, and summarize
time-depth recorder (TDR) data.  Miscellaneous functions for handling
position and 3D kinematics data are also provided.scikit-diveMovecommunicates with a singleRinstance for access to low-level tools of
packagediveMove.The table below shows which features ofdiveMoveare accessible fromscikit-diveMove:diveMovescikit-diveMoveNotesFunctionalityFunctions/MethodsMovementaustFilterrmsDistFiltergrpSpeedFilterdistSpeedreadLocsUnder consideration.Bout analysisboutfreqsboutinitbouts2.nlsFUNbouts2.nlsbouts3.nlsFUNbouts3.nlsbouts2.mleFUNbouts2.llbouts2.LLbouts.mlelabelBoutsplotBoutsplotBouts2.cdfbec2bec3BoutsNLSBoutsMLEFully implemented in Python.Dive analysisreadTDRcreateTDRTDR.__init__TDRSource.__init__Fully implemented.  SingleTDRclass for data with or
without speed measurements.calibrateDepthTDR.calibrateTDR.zocTDR.detect_wetTDR.detect_divesTDR.detect_dive_phasesFully implementedcalibrateSpeedrqPlotTDR.calibrate_speedNew implementation of the
algorithm entirely in Python.
The procedure generates the plot
concurrently.diveStatsstampDivetimeBudgetTDR.dive_statsTDR.time_budgetTDR.stamp_divesFully implementedplotTDRplotDiveModelplotZOCTDR.plotTDR.plot_zoc_filtersTDR.plot_phasesTDR.plot_dive_modelFully implemented.
Interactivity is the default, as
standardmatplotlib.getTDRgetDepthgetSpeedgetTimegetCCDatagetDtimegetFileNameTDR.tdrTDR.get_depthTDR.get_speedTDR.tdr.indexTDR.src_fileTDR.dtimeFully implemented.getCCDatadeemed redundant,
as the columns can be accessed
directly from theTDR.tdrattribute.getDActgetDPhaseLabgetDiveDerivgetDiveModelgetGActTDR.get_wet_activityTDR.get_dives_detailsTDR.get_dive_derivFully implementedextractDiveFully implementedscikit-diveMovealso provides useful tools for processing signals from
tri-axial Inertial Measurement Units (IMU), such as thermal calibration,
corrections for shifts in coordinate frames, as well as computation of
orientation using a variety of current methods.  Analyses are fully
tractable by encouraging the use ofxarraydata structures that can be
read from and written to NetCDF file format.  Using these data structures,
meta-data attributes can be easily appended at all layers as analyses
progress.InstallationType the following at a terminal command line:pipinstallscikit-diveMoveOr install from source tree by typing the following at the command line:pythonsetup.pyinstallThe documentation can also be installed as described inDocumentation.Once installed,skdiveMovecan be easily imported as:import skdiveMove as skdiveDependenciesskdiveMovedepends primarily onRpackagediveMove, which must be
installed and available to the user running Python.  If needed, installdiveMoveat theRprompt:install.packages("diveMove")DocumentationAvailable at:https://spluque.github.io/scikit-diveMoveAlternatively, installing the package as follows:pipinstall-e.["dev"]allows the documentation to be built locally (choosing the desired target
{“html”, “pdf”, etc.}):make-Cdocs/html
Package: scikit-duplo
scikit-duploVery simple reusable blocks for scikit-learn pipelines  (inspired by scikit-lego)InstallationInstallation from the source tree:python setup.py installOr via pip from PyPI:pip install scikit-duploContentsThe sci-kit duplo package contains multiple classes that you can use in a sci-kit
learn compatible pipeline. There are ensemble learning classes within themetasubdirectory.
These classes expect you to pass in multiple other Sci-kit learn compatible
machine learning classes. It will use these to build an ensemble of models to
predict the target variable.There are feature engineering classes inside thepreprocessingsubdirectory. These are
ColumnTransformer compatible classes that expect to receive a dataframe and set of column
names that it will transform for the downstream pipeline processes.
Package: scikit-elm
Scikit-ELMscikit-elmis ascikit-learncompatible Extreme Learning Machine (ELM) regressor/classifier.It features very high degree of model flexibility: dynamically added classes,partial_fitwithout performance penalties, wide data format compatibility,
optimization and parameter selection without full re-training.Big Data and out-of-core learning support throughdask-powered backend.
GPU acceleration support with NVidia hardware, and on macOS throughplaidml.Toolbox is in active development, initial release soon.
Package: scikit-embeddings
scikit-embeddingsUtilites for training, storing and using word and document embeddings in scikit-learn pipelines.FeaturesTrain Word and Paragraph embeddings in scikit-learn compatible pipelines.Fast and performant trainable tokenizer components fromtokenizers.Easy to integrate components and pipelines in your scikit-learn workflows and machine learning pipelines.Easy serialization and integration with HugginFace Hub for quickly publishing your embedding pipelines.What scikit-embeddings is not for:Training transformer models and deep neural language models (if you want to do this, do it withtransformers)Using pretrained sentence transformers (useembetter)InstallationYou can easily install scikit-embeddings from PyPI:pipinstallscikit-embeddingsIf you want to use GloVe embedding models, install alogn with glovpy:pipinstallscikit-embeddings[glove]Example PipelinesYou can use scikit-embeddings with many many different pipeline architectures, I will list a few here:Word EmbeddingsYou can train classic vanilla word embeddings by building a pipeline that contains aWordLeveltokenizer and an embedding model:fromskembedding.tokenizersimportWordLevelTokenizerfromskembedding.modelsimportWord2VecEmbeddingfromskembeddings.pipelineimportEmbeddingPipelineembedding_pipe=EmbeddingPipeline(WordLevelTokenizer(),Word2VecEmbedding(n_components=100,algorithm="cbow"))embedding_pipe.fit(texts)Fasttext-likeYou can train an embedding pipeline that uses subword information by using a tokenizer that does that.
You may want to useUnigram,BPEorWordPiecefor these purposes.
Fasttext also uses skip-gram by default so let's change to that.fromskembedding.tokenizersimportUnigramTokenizerfromskembedding.modelsimportWord2VecEmbeddingfromskembeddings.pipelineimportEmbeddingPipelineembedding_pipe=EmbeddingPipeline(UnigramTokenizer(),Word2VecEmbedding(n_components=250,algorithm="sg"))embedding_pipe.fit(texts)Paragraph EmbeddingsYou can train Doc2Vec paragpraph embeddings with the chosen choice of tokenization.fromskembedding.tokenizersimportWordPieceTokenizerfromskembedding.modelsimportParagraphEmbeddingfromskembeddings.pipelineimportEmbeddingPipeline,PretrainedPipelineembedding_pipe=EmbeddingPipeline(WordPieceTokenizer(),ParagraphEmbedding(n_components=250,algorithm="dm"))embedding_pipe.fit(texts)SerializationPipelines can be safely serialized to disk:embedding_pipe.to_disk("output_folder/")pretrained=PretrainedPipeline("output_folder/")Or published to HugginFace Hub:fromhuggingface_hubimportloginlogin()embedding_pipe.to_hub("username/name_of_pipeline")pretrained=PretrainedPipeline("username/name_of_pipeline")Text ClassificationYou can include an embedding model in your classification pipelines by adding some classification head.fromsklearn.linear_modelimportLogisticRegressionfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportclassification_reportX_train,X_test,y_train,y_test=train_test_split(X,y)cls_pipe=make_pipeline(pretrained,LogisticRegression())cls_pipe.fit(X_train,y_train)y_pred=cls_pipe.predict(X_test)print(classification_report(y_test,y_pred))
Package: scikit-event-correlation
scikit-event-correlationEvent Correlation and Changing Detection AlgorithmTheoryCorrelating events in complex and dynamic IoT environments is a challenging task not only because of the amount of available data that needs to be processed but also due to the call for time efficient data processing. We propose the adoption of a univariate change detection algorithm for real-time event detection and we implement a stepwise event correlation scheme based on a first-order Markov model.RequirementsPython 3.6 to 3.10 supported.scikit-learn 1.0.0 to 1.02 supported.InstallationInstall with pip:python -m pip install scikit-event-correlationExample ProjectSee the example project in theexample/directory of the GitHub repository.
Package: scikit-fda
scikit-fda: Functional Data Analysis in PythonFunctional Data Analysis, or FDA, is the field of Statistics that analyses
data that depend on a continuous parameter.This package offers classes, methods and functions to give support to FDA
in Python. Includes a wide range of utils to work with functional data, and its
representation, exploratory analysis, or preprocessing, among other tasks
such as inference, classification, regression or clustering of functional data.
See documentation for further information on the features included in the
package.DocumentationThe documentation is available atfda.readthedocs.io/en/stable/, which
includes detailed information of the different modules, classes and methods of
the package, along with several examples showing different functionalities.The documentation of the latest version, corresponding with the develop
version of the package, can be found atfda.readthedocs.io/en/latest/.InstallationCurrently,scikit-fdais available in Python versions above 3.8, regardless of the
platform.
The stable version can be installed viaPyPI:pip install scikit-fdaIt is also available from conda-forge:
.. code:conda install -c conda-forge scikit-fdaInstallation from sourceIt is possible to install the latest version of the package, available in the
develop branch,  by cloning this repository and doing a manual installation.gitclonehttps://github.com/GAA-UAM/scikit-fda.gitpipinstall./scikit-fdaMake sure that your default Python version is currently supported, or change
the python and pip commands by specifying a version, such aspython3.8:gitclonehttps://github.com/GAA-UAM/scikit-fda.gitpython3.8-mpipinstall./scikit-fdaRequirementsscikit-fdadepends on the following packages:fdasrsf- SRSF frameworkfindiff- Finite differencesmatplotlib- Plotting with Pythonmultimethod- Multiple dispatchnumpy- The fundamental package for scientific computing with Pythonpandas- Powerful Python data analysis toolkitrdata- Reader of R datasets in .rda format in Pythonscikit-datasets- Scikit-learn compatible datasetsscikit-learn- Machine learning in Pythonscipy- Scientific computation in Pythonsetuptools- Python PackagingThe dependencies are automatically installed.ContributionsAll contributions are welcome. You can help this project grow in multiple ways,
from creating an issue, reporting an improvement or a bug, to doing a
repository fork and creating a pull request to the development branch.The people involved at some point in the development of the package can be
found in thecontributors
file.LicenseThe package is licensed under the BSD 3-Clause License. A copy of thelicensecan be found along with the code.
Package: scikit-fda-sim
Functional Data Analysis, or FDA, is the field of Statistics that analyses
data that depend on a continuous parameter.This package offers classes, methods and functions to give support to FDA
in Python. Includes a wide range of utils to work with functional data, and its
representation, exploratory analysis, or preprocessing, among other tasks
such as inference, classification, regression or clustering of functional data.
See documentation or visit thegithub pageof the project for
further information on the features included in the package.The documentation is available atfda.readthedocs.io/en/stable/, which
includes detailed information of the different modules, classes and methods of
the package, along with several examples showing different funcionalities.
Package: scikit-fibers
scikit-FIBERSFeature Inclusion Bin Evolver for Risk Stratification (FIBERS)is an evolutionary algorithm for automatically binning features to stratify risk in right-censored survival data. In particular it was designed for features that correspond to mismatches between donor and recipients for transplantation. This repository focuses on a scikit-learn compatible implementation of the original(FIBERS)algorithm. Further development of the FIBERS algorithm will take place via this repository.It utilizes an evolutionary algorithm approach to optimizing bins of features based on their stratification of event risk through the following steps:Random bin initialization or expert knowledge input; the bin value at an instance is the sum of the instance's values for the features included in the binRepeated evolutionary cycles consisting of:Candidate bin evaluation with log-rank test to evaluate for significant difference in survival curves of the low risk group (instances for which bin value = 0) and high risk group (instances for which bin value > 0).Genetic operations (elitism, parent selection, crossover, and mutation) for new bin discovery and generation of the next generation of candidate binsFinal bin evaluation and summary of risk stratification provided by top binsInstallationWe can easily install scikit-FIBERS using the following command:pip install scikit-fibersRead More About scikit-FIBERSThe first publication detailing scikit-FIBERS (release 0.9.3) and applying it to simulated right-censored survival data with amino acid mismatch features is currently in press:Bandhey, H., Fogarty, N., Hsieh, Y., Kamoun, M., Urbanowicz, R. Scikit-FIBERS: An 'OR'-Rule Discovery Evolutionary Algorithm for Risk Stratification in Right-Censored Survival Analysis. In Proceedings of the 25th annual conference on Genetic and evolutionary computation. 2023. (In Press)How to Use:AnExample Notebookis given with sample code that shows what functions are available
in scikit-FIBERS and how to use them.Documentation:Extensive code documentation about the scikit-FIBERS API
can be foundherein the guide.ContactPlease emailRyan.Urbanowicz@cshs.organdHarsh.Bandhey@cshs.orgfor any
inquiries related to scikit-FIBERS.
Package: scikit-fingerprints
scikit-fingerprintsA Python library for efficient computation of molecular fingerprintsTable of ContentsDescriptionGeneral Project VisionLibrary DescriptionInstallationUsageTechnologies UsedContributingLicenseDescriptionMolecular fingerprints are crucial in various scientific fields, including drug discovery, materials science, and chemical analysis. However, existing Python libraries for computing molecular fingerprints often lack performance, user-friendliness, and support for modern programming standards. This project aims to address these shortcomings by creating an efficient and accessible Python library for molecular fingerprint computation.InstallationYou can install the library using pip:pipinstallscikit-fingerprintsGeneral Project VisionThe primary goal of this project was to develop a Python library that simplifies the computation of widely-used molecular fingerprints, such as Morgan's fingerprint, MACCS fingerprint, and others. This library has the following key features:User-Friendly Interface:The library was designed to provide an intuitive interface, making it easy to integrate into machine learning workflows.Performance Optimization:We implemented molecular fingerprint computation algorithms using concurrent programming techniques to maximize performance. Large datasets of molecules are processed in parallel for improved efficiency.Compatibility:The library's interface was inspired by popular data science libraries like Scikit-Learn, ensuring compatibility and familiarity for users familiar with these tools.Extensibility:Users should be able to customize and extend the library to suit their specific needs.Library DescriptionThe library offers various functions that accept molecule descriptors (e.g., SMILES) and fingerprint parameters, returning the specified fingerprints.It's open-source and available for installation via pip.The library has been designed for ease of use, minimizing the need for extensive training.Compatibility with the standard Python ML stack, based on Scikit-Learn interfaces, has been a top priority.ContributingPlease readCONTRIBUTING.mdandCODE_OF_CONDUCT.mdfor details on our code of conduct, and the process for submitting pull requests to us.LicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for details.
Package: scikit-garden-forked
# Scikit-GardenForked fromhttps://github.com/scikit-garden/scikit-gardenScikit-Garden or skgarden (pronounced as skarden) is a garden for Scikit-Learn compatible decision trees and forests.## InstallationScikit-Garden depends on NumPy, SciPy, Scikit-Learn and Cython. So make sure these dependencies are installed using pip:``
pip3 install setuptools numpy scipy scikit-learn cython
# or
pip3 install -r requirements.txt
``After that my Scikit-Garden fork can be installed using pip.``
pip install git+https://git@github.com/Demangio/scikit-garden.git
``## Available models### RegressorsExtraTreesRegressor (withreturn_stdsupport)ExtraTreesQuantileRegressorRandomForestRegressor (withreturn_stdsupport)RandomForestQuantileRegressor## UsageThe estimators in Scikit-Garden are Scikit-Learn compatible and can serve as a drop-in replacement for Scikit-Learn’s trees and forests.``
from sklearn.datasets import load_boston
X, y = load_boston()### Use QuantileForests for quantile estimation
from skgarden import RandomForestQuantileRegressor
rfqr = RandomForestQuantileRegressor(random_state=0)
rfqr.fit(X, y)
y_mean = rfqr.predict(X)
y_median = rfqr.predict(X, 50)
``## What changes in this releaseChange default predict method to the same as QuantReg package. This version is faster and include parametric estimation.
Adaptation of code to higher versions of dependencies.## Important links
-  API Reference:https://scikit-garden.github.io/api/-  Examples:https://scikit-garden.github.io/examples/-  Modifications source:https://stackoverflow.com/questions/51483951/quantile-random-forests-from-scikit-garden-very-slow-at-making-predictions
Package: scikit-gbm
scikit-gbmscikit-learn compatible tools to work with GBM modelsInstallationpip install scikit-gbm

# or 

pip install git+https://github.com/krzjoa/scikit-gbm.gitUsageFo the moment, you can find the following tools in the library:GBMFeaturizerGBMDiscretizertrees_to_dataframeAXILTake a look at thedocumentationto learn more.
A simple example, how to useGBMFeaturizerin a classification task.# Classificationfromsklearn.datasetsimportmake_classificationfromsklearn.model_selectionimporttrain_test_splitfromsklearn.pipelineimportPipelinefromsklearn.linear_modelimportLogisticRegressionfromskgbm.preprocessingimportGBMFeaturizerfromxgboostimportXGBClassifierX,y=make_classification()X_train,X_test,y_train,y_test=train_test_split(X,y)pipeline=\Pipeline([('gbm_featurizer',GBMFeaturizer(XGBClassifier())),('logistic_regression',LogisticRegression())])# Try also:# ('gbm_featurizer', GBMFeaturizer(GradientBoostingClassifier())),# ('gbm_featurizer', GBMFeaturizer(LGBMClassifier())),# ('gbm_featurizer', GBMFeaturizer(CatBoostClassifier())),# Predictions for the test setpipeline_pred=pipeline.predict(X_test)
Package: scikit-genome
scikit-genomescikit-genomeis a Python package for genomics.Essential, efficient algorithms for genomicsInteroperable with Python’s scientific ecosystemFree and open-sourceFrequently asked questions (FAQ)How do I pronounce “scikit-genome?”sī kit ˈjēˌnōmis the preferred pronunciation.What’s a “scikit?”scikit-genome is a SciPy toolkit. It’s compatible with both SciPy toolkits like scikit-learn and NumPy-compatible packages like PyTorch and TensorFlow.What’s the inclusion criteria for new algorithms?Maintainers consider only well-established algorithms for inclusion. A minimum of three years since publication, more than 200 citations, and far-reaching usefulness is expected. Methods that provide clear-cut improvements on widely-used algorithms will also be considered.Methods provided by one of the following maintained, general-purpose packageswon’tbe considered for inclusion:matplotlibNumPyPandasPyTorchscikit-imagescikit-learnSciPystatsmodelsTensorFlowDo you support PyPy?Yes
Package: scikit-gpuppy
https://github.com/snphbaum/scikit-gpuppyThis package provides means for modeling functions and simulations using Gaussian processes (aka Kriging, Gaussian random fields, Gaussian random functions).
Additionally, uncertainty can be propagated through the Gaussian processes.NoteThe Gaussian process regression and uncertainty propagation are based on Girard’s thesis[1].An extension to speed up GP regression is based on Snelson’s thesis[2].WarningThe extension based on Snelson’s work is already usable but not as fast as it should be.
Additionally, the uncertainty propagation does not yet work with this extension.An additional extension for Inverse Uncertainty Propagation is based on my paper (and upcoming PhD thesis)[3].A simulation is seen as a function\(f(x)+\epsilon\)(\(x \in \mathbb{R}^n\)) with additional random error\(\epsilon \sim \mathcal{N}(0,v)\).
This optional error is due to the stochastic nature of most simulations.TheGaussianProcessmodule uses regression to model the simulation as a Gaussian process.TheUncertaintyPropagationmodule allows for propagating uncertainty\(x \sim \mathcal{N}(\mu,\Sigma)\)through the Gaussian process to estimate the output uncertainty of the simulation.TheFFNIandTaylorPropagationmodules provide classes for propagating uncertainty through deterministic functions.TheInverseUncertaintyPropagationmodule allows for propagating the desired
output uncertainty of the simulation backwards through the Gaussian Process.
This assumes that the components of the input\(x\)are estimated from samples using maximum likelihood estimators.
Then, the inverse uncertainty propagation calculates the optimal sample sizes for estimating\(x\)that lead to the desired output uncertainty of the simulation.[1]Girard, A. Approximate Methods for Propagation of Uncertainty with Gaussian Process Models, University of Glasgow, 2004[2]Snelson, E. L. Flexible and efficient Gaussian process models for machine learning, Gatsby Computational Neuroscience Unit, University College London, 2007[3]Baumgaertel, P.; Endler, G.; Wahl, A. M. & Lenz, R. Inverse Uncertainty Propagation for Demand Driven Data Acquisition, Proceedings of the 2014 Winter Simulation Conference, IEEE Press, 2014, 710-721