Saravanan666/pypi-org huggingface dataset:
Package: scikit-mlm
scikit-mlmscikit-mlmis a Python module implementing theMinimal Learning Machine(MLM) machine learning technique using thescikit-learnAPI.instalationthescikit-mlmpackage is available inPyPI. to install, simply type the following command:pip install scikit-mlmbasic usageexample of classification with thenearest neighbor MLMclassifier:fromskmlmimportNN_MLMfromsklearn.preprocessingimportMinMaxScalerfromsklearn.model_selectionimportcross_val_scorefromsklearn.pipelineimportmake_pipelinefromsklearn.datasetsimportload_iris# load datasetdataset=load_iris()clf=make_pipeline(MinMaxScaler(),NN_MLM(rp_number=20))scores=cross_val_score(clf,dataset.data,dataset.target,cv=10,scoring='accuracy')print('AVG =%.3f, STD =%.3f'%(scores.mean(),scores.std()))how to cite scikit-mlmif you usescikit-mlmin your paper, please cite it in your publication.@misc{scikit-mlm,
    author       = "Madson Luiz Dantas Dias",
    year         = "2019",
    title        = "scikit-mlm: An implementation of {MLM} for scikit-learn framework",
    url          = "https://github.com/omadson/scikit-mlm",
    doi          = "10.5281/zenodo.2875802",
    institution  = "Federal University of Cear\'{a}, Department of Computer Science" 
}contributingthis project is open for contributions. here are some of the ways for you to contribute:bug reports/fixfeatures requestsuse-case demonstrationsto make a contribution, just fork this repository, push the changes in your fork, open up an issue, and make a pull request!list of implemented technicsoriginal regression (MLMR)original classification (MLMC)nearest neighbor MLM (NN_MLM)opposite neighborhood MLM (ON_MLM)fuzzy C-means MLM (FCM_MLM)optimally selected MLM (OS_MLM)ℓ1/2-norm regularization MLM (L12_MLM)weighted MLM (w_MLM)ranking MLM (R-MLM)(WIP)future improvementslist of methods that will be implemented in the next releases:cubic equation MLM (C-MLM)expected squared distance MLM (ESD-MLM)voting based MLM (V-MLM)weighted voting based MLM (WV-MLM)random sampling voting based MLM (RSV-MLM)random sampling weighted voting based MLM (RSWV-MLM)reject option MLM (renjo-MLM)reject option weighted MLM (renjo-wMLM)contributorsMadson Diasacknowledgementthanks for@JamesRitchie, the initial idea of this project is inspired on thescikit-rvmrepo
Package: scikit-mol
scikit-molScikit-Learn classes for molecular vectorization using RDKitThe intended usage is to be able to add molecular vectorization directly into scikit-learn pipelines, so that the final model directly predict on RDKit molecules or SMILES stringsAs example with the needed scikit-learn and -mol imports and RDKit mol objects in the mol_list_train and _test lists:pipe = Pipeline([('mol_transformer', MorganTransformer()), ('Regressor', Ridge())])
pipe.fit(mol_list_train, y_train)
pipe.score(mol_list_test, y_test)
pipe.predict([Chem.MolFromSmiles('c1ccccc1C(=O)C')])

>>> array([4.93858815])The scikit-learn compatibility should also make it easier to include the fingerprinting step in hyperparameter tuning with scikit-learns utilitiesThe first draft for the project was created at theRDKIT UGM 2022 hackathon2022-October-14ImplementeddescriptorsMolecularDescriptorTransformer* fingerprints
    * MorganFingerprintTransformer
    * MACCSKeysFingerprintTransformer
    * RDKitFingerprintTransformer
    * AtomPairFingerprintTransformer
    * TopologicalTorsionFingerprintTransformer
    * MHFingerprintTransformer
    * SECFingerprintTransformer
    * AvalonFingerprintTransformer* conversions
    * SmilesToMol* standardizer
    * Standardizer* utilities
    * CheckSmilesSanitazionInstallationUsers can install latest tagged release from pippip install scikit-molBleeding edgepip install git+https://github.com:EBjerrum/scikit-mol.gitDevelopersgit clone git@github.com:EBjerrum/scikit-mol.git
pip install -e .DocumentationThere are a collection of notebooks in the notebooks directory which demonstrates some different aspects and use casesBasic Usage and fingerprint transformersDescriptor transformerPipelining with Scikit-Learn classesMolecular standardizationSanitizing SMILES inputIntegrated hyperparameter tuning of Scikit-Learn estimator and Scikit-Mol transformerUsing parallel execution to speed up descriptor and fingerprint calculationsBUGSProbably still, please check issues at GitHub and report thereContributers:Esben Jannik Bjerrum@ebjerrum,esben@cheminformania.comCarmen Esposito@cesposSon Ha,sonha@uni-mainz.deOh-hyeon Choung,ohhyeon.choung@gmail.comAndreas Poehlmann,@ap--Ya Chen,@anya-chenRafał Bachorz@rafalbachorzAdrien Chaton@adrienchaton
Package: scikit-monaco
scikit-monaco is a library for Monte Carlo integration in python. The core is
written in Cython, with process-level parallelism to squeeze the last bits of
speed out of the python interpreter.A code snippet is worth a thousand words. Let’s look at integratingsqrt(x**2+y**2+z**2)in the unit square:>>>fromskmonacoimportmcquad>>>frommathimportsqrt>>>result,error=mcquad(...lambdaxs:sqrt(xs[0]**2+xs[1]**2+xs[2]**2),...npoints=1e6,xl=[0.,0.,0.],xu=[1.,1.,1.])>>>print"{}+/-{}".format(result,error)0.960695982212+/-0.000277843266684LinksHome page:https://pypi.python.org/pypi/scikit-monacoDocumentation:http://scikit-monaco.readthedocs.org/en/latest/Source code:https://github.com/scikit-monaco/scikit-monacoIssues:https://github.com/scikit-monaco/scikit-monaco/issuesInstallationFrom PypiThe easiest way to download and install scikit-monaco is from the Python
package index (pypi). Just run:$ python easy_install scikit-monacoOr, if you have pip:$ pip install scikit-monacoFrom sourceClone the repository using:$ git clone https://github.com/scikit-monaco/scikit-monaco.gitAnd run:$ python setup.py installin the project’s root directory.TestingAfter the installation, run$ python runtests.pyin the package’s root directory.Issue reporting and contributingReport issues using thegithub issue tracker.Read the CONTRIBUTING guide to learn how to contribute.
Package: scikit-mpe
scikit-mpescikit-mpeis a package for extracting a minimal path in N-dimensional Euclidean space (on regular Cartesian grids)
usingthe fast marching method.QuickstartInstallingpip install -U scikit-mpeUsageHere is a simple example that demonstrates how to extract the path passing through the retina vessels.frommatplotlibimportpyplotaspltfromskimage.dataimportretinafromskimage.colorimportrgb2grayfromskimage.transformimportrescalefromskimage.filtersimportsatofromskmpeimportmpeimage=rescale(rgb2gray(retina()),0.5)speed_image=sato(image)start_point=(76,388)end_point=(611,442)way_points=[(330,98),(554,203)]path_info=mpe(speed_image,start_point,end_point,way_points)px,py=path_info.path[:,1],path_info.path[:,0]plt.imshow(image,cmap='gray')plt.plot(px,py,'-r')plt.plot(*start_point[::-1],'oy')plt.plot(*end_point[::-1],'og')forpinway_points:plt.plot(*p[::-1],'ob')plt.show()DocumentationThe full documentation can be found atscikit-mpe.readthedocs.ioReferencesFast Marching Methods: A boundary value formulationLevel Set Methods and Fast Marching Methodsscikit-fmm- Python implementation of the fast marching methodITKMinimalPathExtraction- ITK based C++ implementation of MPELicenseMIT
Package: scikit-mps
scikit-mpsis a Python interface to MPSlib,https://github.com/ergosimulation/mpslib/,
which is a C++ library for geostatistical multiple point simulation, with implementations
of ‘SNESIM’, ‘ENESIM’, and ‘GENESIM’It contains three modules:mpslib: Interacts with MPSlibeas: read and write EAS/GSLIB formatted filestrainingimages: Access to a number of trainingimagesimport mpslib as mps
O=mps.mpslib(method='mps_snesim_tree')
O.run()
O.plot_reals()
O.plot_etype()PyPI<http://pypi.python.org/pypi/scikit-mps>RequirementsNumpy >= 1.0.2Matplotlib >= 1.0.2MPSlib needs to be downloaded, installed, and in the system path (https://github.com/ergosimulation/mpslib/)
[Any 11 C++11 compiler should work, such as gcc, MinGW, MSVC]InstallingVia pip:pip install scikit-mpsoptionally download and reinstall:import mpslib as mps
O=mps.mpslib
O.compile_mpslib()From source codecd ROOT_OF_MPSLIB/python
pip install .
cd ROOT_OF_MPSLIB
make clean
makeIf you wish to develop the scikit-mps package, then install it in editable developer mode usingpip install -e .
Package: scikit-MTR
🛠 scikit-mtr: Multi-Task Regression in Pythonscikit-mtrprovides a framework for multi-task regression using popular regression algorithms and introduces a
stacking method to combine different regressors for enhanced performance.🌟 Features📊 Support for multiple regressors: Decision Trees, Linear Regression, Random Forests, Extra Trees, MLP, and MOKP.🏆 Stacking method to combine predictions from various regressors.📦 Installationpipinstallscikit-mtr⚡ Quick StartGet up and running withscikit-mtrin a flash:fromsklearn.model_selectionimporttrain_test_splitfromscikit_mtr.multi_output_toolsimportmulti_output_regressor,load_data_by_sklearnparams={'regressor':'LR','dataset':41467,'random_seed':0}# Load and split dataX,y=load_data_by_sklearn(params['dataset'])X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=params['random_seed'])# Initialize regressormodel=multi_output_regressor(params['regressor'])model.fit(X_train,y_train)# 🎯 Make predictionsy_pred_test=model.predict(X_test)📚 Using Stackingscikit-mtrintroduces a powerful stacking method where base regressors' predictions serve as features for
meta-regressors:fromscikit_mtr.multi_output_stackingimportMultiTargetRegressorStackingbase_regressors=[LinearRegression()for_inrange(y_train.shape[1])]meta_regressors=[LinearRegression()for_inrange(y_train.shape[1])]stacker=MultiTargetRegressorStacking(base_regressors,meta_regressors)stacker.fit(X_train,y_train)stacked_predictions=stacker.predict(X_test)print(stacked_predictions)🧪 Supported RegressorsCurrently, the following regressors are in our arsenal:DT: 🌲 Decision TreeLR: 📈 Linear RegressionRF: 🌳 Random ForestET: 🍃 Extra TreesMLP: 🧠 Multi-layer PerceptronMOKP: 🔮 MOKP Regressor
Package: scikit-multiflow
scikit-multiflowis a machine learning package for streaming data in Python.Quick linksWebpageDocumentationCommunityFeaturesIncremental LearningStream learning models are created incrementally and are updated continuously. They are suitable
for big data applications where real-time response is vital.Adaptive learningChanges in data distribution harm learning. Adaptive methods are specifically designed to be
robust to concept drift changes in dynamic environments.Resource-wise efficientStreaming techniques efficiently handle resources such as memory and processing time given the
unbounded nature of data streams.Easy to usescikit-multiflow is designed for users with any experience level. Experiments are easy to design,
setup, and run. Existing methods are easy to modify and extend.Stream learning toolsIn its current state, scikit-multiflow contains data generators, multi-output/multi-target stream
learning methods, change detection methods, evaluation methods, and more.Open sourceDistributed under theBSD 3-Clause,scikit-multiflowis developed and maintained by an active, diverse and growingcommunity.Use casesThe following tasks are supported inscikit-multiflow:Supervised learningWhen working with labeled data. Depending on the target type can be either classification
(discrete values) or regression (continuous values)Single/multi outputSingle-output methods predict a single target-label (binary or multi-class) for classification or
a single target-value for regression. Multi-output methods simultaneously predict multiple
variables given an input.Concept drift detectionChanges in data distribution can harm learning. Drift detection methods are designed to rise an
alarm in the presence of drift and are used alongside learning methods to improve their robustness
against this phenomenon in evolving data streams.Unsupervised learningWhen working with unlabeled data. For example, anomaly detection where the goal is the
identification of rare events or samples which differ significantly from the majority of the data.Jupyter NotebooksIn order to display plots fromscikit-multiflowwithin aJupyter Notebookwe need to define
the proper mathplotlib backend to use. This is done by including the following magic command at the
beginning of the Notebook:%matplotlibnotebookJupyterLabis the next-generation user interface
for Jupyter, currently in beta, it can display interactive plots with some caveats. If you use
JupyterLab then the current solution is to use thejupyter-matplotlibextension:%matplotlibwidgetCitingscikit-multiflowIfscikit-multiflowhas been useful for your research and you would like to cite it in a academic
publication, please use the following Bibtex entry:@article{skmultiflow,author={Jacob Montiel and Jesse Read and Albert Bifet and Talel Abdessalem},title={Scikit-Multiflow: A Multi-output Streaming Framework },journal={Journal of Machine Learning Research},year={2018},volume={19},number={72},pages={1-5},url={http://jmlr.org/papers/v19/18-251.html}}
Package: scikit-nano
scikit-nanois a python toolkit for generating and analyzing
nanostructure data.scikit-nanocan generate structure data (i.e., atomic coordinates)
for the following classes of nanostructures:FullerenesGrapheneN-layer grapheneBilayer graphene with more fine control over relative layer
orientation, including relative rotation and stacking arrangements.NanotubesSingle-walled nanotubes (SWNTs)SWNTbundlesMulti-walled nanotubes (MWNTs)MWNTbundlesThe following structure data formats are supported:xyzLAMMPS data(limited support for full format spec.)LAMMPS dump(limited support for full format spec.)Extending input/output capabilities with more structure data formats
such aspdb,json,zmatrix, etc. is queued for developmentSecondary to its structure generating functions are itsstructure analysis toolsincluding:defect/vacancy structure analysisnearest-neighbor analysisPOAV analysisImportant linksDocumentation:http://scikit-nano.org/docSource code repo:https://github.com/androomerrill/scikit-nanoDownload releases:https://github.com/androomerrill/scikit-nano/releasesIssue tracker:https://github.com/androomerrill/scikit-nano/issuesPyPI page:https://pypi.python.org/pypi/scikit-nanoDependenciesPython 3.4+numpy 1.8+scipy 0.13+InstallationYou can install the latest stable release from thePython Package Indexusingpip:> pip install scikit-nanoAlternatively you can download a source code tarball fromhttp://pypi.python.org/pypi/scikit-nanoor clone the source code
from thegithub repousinggit:> git clone https://github.com/androomerrill/scikit-nano.gitcdinto the source code directory and run:> python setup.py installThese commands will probabily fail if you don’t haveadmin privileges.
In that case, try installing to the user base directory.
Usingpip:> pip install --user scikit-nanoOr from source:> python setup.py install --user
Package: scikit-net
The sknet project is a scikit-learn and NetworkX compatible framework for machine learning in complex networks. It provides learning algorithms for complex networks, as well as transforming methods to turn tabular data into complex networks.It started in 2021 as a project from volunteers to help to improve the development of research on the interface between complex networks and machine learning. It main focus
is to help researchers and students to develop solutions using machine learning on complex networks.:computer: InstallationThe sknet installation is available via PiPy:pip install scikit-net:high_brightness: QuickstartThe following code snippet shows how one can transform tabular data into a complex network and then use it to create a classifier:from sklearn.model_selection import train_test_split
from sklean.metrics import accuracy_score
from sklearn.datasets import load_iris
from sknet.network_construction import KNNConstructor
from sknet.supervised import EaseOfAccessClassifier

X, y = load_iris(return_X_y = True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)

# The constructor responsible for transforming the tabular data into a complex network
knn_c = KNNConstructor(k=5)

classifier = EaseOfAccessClassifier()
classifier.fit(X_train, y_train, constructor=knn_c)
y_pred = classifier.predict(X_test)
accuracy_score(y_test, y_pred):pencil: DocumentationWe provide an extensive API documentation as well with some user guides. The documentation is available onhttps://tnanukem.github.io/scikit-net/CitationIf you used the scikit-net on your research project, please cite us using the following publication:@article{Toledo2021,
doi = {10.21105/joss.03864},
url = {https://doi.org/10.21105/joss.03864},
year = {2021},
publisher = {The Open Journal},
volume = {6},
number = {68},
pages = {3864},
author = {Tiago Toledo},
title = {sknet: A Python framework for Machine Learning in Complex Networks},
journal = {Journal of Open Source Software}
}
Package: scikit-neuralnetwork
orphan:scikit-neuralnetworkDeep neural network implementation without the learning cliff!  This library implements multi-layer perceptrons as a wrapper for the powerfulLasagnelibrary that’s compatible withscikit-learnfor a more user-friendly and Pythonic interface.NOTE: This project is possible thanks to thenucl.ai ConferenceonJuly 18-20. Join us inVienna!FeaturesThanks to the underlyingLasagneimplementation, this library supports the following neural network features, which are exposed in an intuitive andwell documentedAPI:Activation Functions —Nonlinear:Sigmoid,Tanh,Rectifier.Linear:Linear,Gaussian,Softmax.Layer Types —Convolution(greyscale and color, 2D),Dense(standard, 1D).Learning Rules —sgd,momentum,nesterov,adadelta,adagrad,rmsprop.Regularization —L1,L2anddropout.Dataset Formats —numpy.ndarray,scipy.sparse, coming soon: iterators.If a feature you need is missing, consider opening aGitHub Issuewith a detailed explanation about the use case and we’ll see what we can do.InstallationTo download and setup the latest official release, you can do so from PYPI directly:> pip install scikit-neuralnetworkThis will install a copy ofLasagnetoo as a dependency. We recommend you use a virtual environment for Python.Then, you can run the tests usingnosetests-vsknn, and other samples or benchmarks are available in theexamples/folder.Getting StartedThe library supports both regressors (to estimate continuous outputs from inputs) and classifiers (to predict labels from features).  This is thesklearn-compatible API:fromsknn.mlpimportClassifier,Layernn=Classifier(layers=[Layer("Rectifier",units=100),Layer("Linear")],learning_rate=0.02,n_iter=10)nn.fit(X_train,y_train)y_valid=nn.predict(X_valid)score=nn.score(X_test,y_test)Thegenerated documentationas a standalone page where you can find more information about parameters, as well as examples in theUser Guide.
Package: scikit-neuromsi
scikit-neuromsiScikit-neuromsiis an open-source Python framework that simplifies the implementation of neurocomputational models of multisensory integration.MotivationResearch on the the neural process by which unisensory signals are combined to form a significantly different multisensory response has grown exponentially in the recent years. Nevertheless, there is as yet no unified theoretical approach to multisensory integration. We believe that building a framework for multisensory integration modelling would greatly contribute to originate a unifying theory that narrows the gap between neural and behavioural multisensory responses.ContactRenato Paredes (paredesrenato92@gmail.com)FeaturesScikit-neuromsicurrently has three classes which implement neurocomputational
models of multisensory integration.The available modules are:alais_burr2004: implements the near-optimal bimodal integration
employed by Alais and Burr (2004) to reproduce the Ventriloquist Effect.ernst_banks2002: implements the visual-haptic maximum-likelihood
integrator employed by Ernst and Banks (2002) to reproduce the visual-haptic task.kording2007: implements the Bayesian Causal Inference model for
Multisensory Perception employed by Kording et al. (2007) to reproduce
the Ventriloquist Effect.In addition, there is acoremodule with features to facilitate the implementation of new models of multisensory integration.RequirementsYou need Python 3.9+ to run scikit-neuromsi.InstallationRun the following command:$ pip install scikit-neuromsior clone this repo and then inside the local directory execute:$ pip install -e .
Package: scikit-ntk
Neural Tangent Kernel forscikit-learnGaussian Processesscikit-ntkis implementation of the neural tangent kernel (NTK) for thescikit-learnmachine learning library as part of "An Empirical Analysis of the Laplace and Neural Tangent Kernels" master's thesis (found athttp://hdl.handle.net/20.500.12680/d504rr81vandhttps://arxiv.org/abs/2208.03761).  This library is meant to directly integrate withsklearn.gaussian_processmodule.  This implementation of the NTK can be used in combination with other kernels to train and predict with Gaussian process regressors and classifiers.InstallationDependenciesscikit-ntk requires:Python (>=3.7)scikit-learn (>=1.0.1)User installationIn terminal usingpiprun:pipinstallscikit-ntkUsageUsage is described inexamples/usage.py; however, to get started simply import theNeuralTangentKernelclass:fromskntkimportNeuralTangentKernelasNTKkernel_ntk=NTK(D=3,bias=0.01,bias_bounds=(1e-6,1e6))Once declared, usage is the same as otherscikit-learnkernels.BuildingPython Poetry (>=1.2) is required if you wish to buildscikit-ntkfrom source.  In order to build follow these steps:Clone the repositorygitclonegit@github.com:392781/scikit-ntk.gitEnable a Poetry virtual environmentpoetryshellBuild and installpoetrybuild
poetryinstall--withdevCitationIf you use scikit-ntk in your scientific work, please use the following citation alongside the scikit-learn citations found athttps://scikit-learn.org/stable/about.html#citing-scikit-learn:@mastersthesis{lencevicius2022laplacentk,
  author  = "Ronaldas Paulius Lencevicius",
  title   = "An Empirical Analysis of the Laplace and Neural Tangent Kernels",
  school  = "California State Polytechnic University, Pomona",
  year    = "2022",
  month   = "August",
  note    = {\url{http://hdl.handle.net/20.500.12680/d504rr81v}}
}
Package: scikit-numerical
Tools for numerical math calculationsThis repository contains tools for math numerical computation such as numerical integration and interpolation. The current implementation contains:numerical integration using Gauss formulaimportnumpyasnpfromnumerical.integrationimportgaussdeff(x):returnnp.power(x[0],2)gauss.integrate(f,0.,1.)# 0.3333333spline functions and theirs derivativesimportnumpyasnpfromnumericalimportsplinesimportmatplotlib.pyplotaspltx=np.arange(0,4.,0.05)y=splines.schoenberg(x)yd1=splines.schoenberg.deriv(x,order=1)# first derivativeyd2=splines.schoenberg.deriv(x,order=2)# second derivative# visualize resultsplt.plot(x,y)plt.plot(x,yd1)plt.plot(x,yd2)plt.show()function interpolationimportnumpyasnpfromnumericalimportinterpolateimportmatplotlib.pyplotaspltdeffun(x):return1-np.power(x[0]-0.5,2)grid=np.array([np.arange(0,1.0001,0.25)])values=fun(grid)itp_fun=interpolate(values,grid)x=np.arange(0.,1.00001,0.001).reshape(1,-1)y_intp=itp_fun(x)y_true=fun(x)plt.plot(x[0],y_intp)plt.plot(x[0],y_true)plt.show()