Saravanan666/pypi-org huggingface dataset:
Package: scikit_rest
scikit-restAutomatically deploy your ML model as a REST APIOften times, deploying your favorite Scikit-learn / XGBoost / Pytorch / Tensorflow model as a REST API might take a lot of time. There are a lot of boilerplate codes to be written.scikit-restis a package designed to alleviate most of the pain points within this process.PrerequisitesThis package officially supports Python 3Installingpip install scikit_restUsageThe main function offered in this package isserve, with the following syntax:serve(
        col_list: List[str],
        col_types: Dict[str, Union[List, type]],
        transform_fn: Callable,
        predict_fn: Union[Callable, sklearn.base.BaseEstimator],
        port: int,
        is_nullable: bool ,
        name: str,
    )col_listList of Column names, where the order of the values will dictate the order within the pandas DataFramecol_list = ['class', 'sex', 'age', 'embarked', 'date', 'is_englishman']col_typesDictionary of Column Names and the type of the variable, used for input Validation. If the values
of the dictionary is instead a list, We assume that any input for the variable can only be any of
the ones listed within the listcol_types = {
    'class' : int,
    'sex' : str,
    'age' : float,
    'embarked': ['C', 'S', 'Q'],
    'date': datetime.datetime,
    'is_englishman': bool
}transform_fnFunction which convert the input dataframe into test dataframe, we can call model.predict upon to get the final resultdef transform_fn(input_df):
    df = input_df.copy()
    df['sex'] = df['sex'].apply(lambda x : transform_sex(x))
    df['embarked'] = df['embarked'].apply(lambda x : transform_embarked(x))
    df['date'] = df['date'].dt.year
    df = df.fillna(0.)
    return dfpredict_fnFunction which convert the test dataframe into result. If a ML model instance is passed in, we will instead try to call model.predict_proba / model.predict to get the resultdef predict_fn(input_df):
    df = input_df.copy()
    return model.predict(df).item()portPort Number where the REST API should be served uponis_nullableWhether input API can be nullablenameName of the programExampleExample of Usage can be found atexamplefolderContributingPlease readCONTRIBUTING.mdfor details on our code of conduct,
and the process for submitting pull requests to us.Authors[Aditya Kelvianto Sidharta][https://adityasidharta.com]LicenseThis project is licensed under the MIT License - see theLICENSEfile for details
Package: scikit-rf
Descriptionscikit-rf(akaskrf) is an Open Source, BSD-licensed package for RF/Microwave engineering implemented
in the Python programming language. It provides a modern, object-oriented library which is both
flexible and scalable.Home PageDocumentationInstallIf you haveinstalled Python, you can install scikit-rf frompipviapython-mpipinstallscikit-rfIf you haveinstalled conda, then you can also get scikit-rf fromcondainstall-cconda-forgescikit-rfscikit-rfincludes standalone gui applications which can be installed and used like this# Install the additional dependencies for the gui applicationspython-mpipinstallscikit-rf[plot,qtapps,visa]# Run the appsdata-grabber# Run the data-grabber applicationmultiline-trl# Run the multiline-trl applicationQuestions or comments? Ask the CommunityMailing list: You can suscribe to our mailing list to ask (and answer) questions and to receive scikit-rf announcements.Chat: scikit-rf have channels on bothSlackandMatrixSuggestion box: if you would like to suggest a feature/topic for consideration (optionally anonymous).Contributing to the scikit-rf projectThere is multiple ways to contribute to an open-source project like scikit-rf!Sponsoring the projectContributing to the codeContributing to the DocumentationGetting some merchandise to express your loveLicensescikit-rf is permissively licensed under a3-clause BSD license.
Package: scikit-robot
scikit-robot: A Flexible Framework for Robot Control in PythonDocumentation|Installation|Quick Start|Python API|ContributeScikit-Robot is a lightweight pure-Python library for robotic kinematics,
motion planning, visualization and control.InstallationYou may need to install some dependencies by apt-get install:sudoapt-getupdate
sudoapt-getinstalllibspatialindex-devfreeglut3-devlibsuitesparse-devlibblas-devliblapack-devThen,pipinstallscikit-robotIf you would like to usePybullet Interfaceandopen3dfor mesh simplification,pipinstallscikit-robot[all]FeaturesLoading robot model from URDF (examples/robot_models.py)Forward and inverse kinematics (examples/trimesh_scene_viewer.py)Collision detectionInteractive viewer (examples/trimesh_scene_viewer.py)Pybullet and ROS command interface (examples/pybullet_robot_interface.py)Forward and inverse dynamicsPath planning (examples/collision_free_trajectory.py)
Package: scikit-rt
Scikit-rtScikit-rt provides tools for loading, plotting, and analysing
radiotherapy data inDICOMandNIfTIformats.  It includes
image registration viaelastixandNiftyReg,
single- and multi-atlas segmentation, and region-of-interest (ROI)
comparisons.Scikit-rt documentation is at:https://scikit-rt.github.io/scikit-rt/If you encounter problems with scikit-rt, please submit a help request
or bug report via the project issues tracker:https://github.com/scikit-rt/scikit-rt/issuesThis work was supported by Cancer Research UK RadNet Cambridge [C17918/A28870].
Package: scikits.ann
The ANN module provides a numpy-compatible python wrapper around theApproximate Nearest Neighbor library (http://www.cs.umd.edu/~mount/ANN/).* Installation *Download and build the Approximate Nearest Neighbor library. Modify the ANN section ofsite.cfg so that ANN_ROOT is the path to the root of the Approximate Nearest Neighborlibrary include/lib tree.If /usr/local/include contains the ANN/ include directory and /usr/local/lib containslibANN.a, thenANN_ROOT = /usr/localRun ::python setup.py build_ext --inplace build testsudo python setup.py installfrom within the source directory.* Usage *scikits.ann exposes a single class, kdtree that wraps the Approximate Nearest Neighborlibrary's kd-tree implementation. kdtree has a single (non-constructor) method, knn thatfinds the indecies (of the points used to construct the kdtree) of the k-nearest neighborsand the squared distances to those points. A little example will probably be muchmore enlightening::>>> import scikits.ann as ann>>> import numpy as np>>> k=ann.kdtree(np.array([[0.,0],[1,0],[1.5,2]]))>>> k.knn([0,.2],1)(array([[0]]), array([[ 0.04]]))>>> k.knn([0,.2],2)(array([[0, 1]]), array([[ 0.04,  1.04]]))>>> k.knn([[0,.2],[.1,2],[3,1],[0,0]],2)(array([[0, 1],[2, 0],[2, 1],[1, 2]]), array([[ 0.04,  1.04],[ 1.96,  4.01],[ 3.25,  5.  ],[ 1.  ,  6.25]]))>>> k.knn([[0,.2],[.1,2],[3,1],[0,0]],3)(array([[ 0,  1,  2],[ 2,  0,  1],[ 2,  1,  0],[ 1,  2, -1]]), array([[  4.00000000e-002,   1.04000000e+000,   5.49000000e+000],[  1.96000000e+000,   4.01000000e+000,   4.81000000e+000],[  3.25000000e+000,   5.00000000e+000,   1.00000000e+001],[  1.00000000e+000,   6.25000000e+000,   1.79769313e+308]]))
Package: scikits.audiolab
Audiolab is a python package for audio file IO using numpy arrays. It supports
many different audio formats, including wav, aiff, au, flac, ogg, htk. It also
supports output to audio device (Mac OS X and Linux only).For simplicity, a matlab-like API is provided for simple import/export; a more
complete API is also available.Audiolab is essentially a wrapper around Erik de Castro Lopo’s excellent
libsndfile:http://www.mega-nerd.com/libsndfile/LICENSE: audiolab is licensed under the LGPL, as is libsndfile itself. See
COPYING.txt for details.2006-2008, David Cournapeau
Package: scikits.bvp_solver
bvp_solver is a Python package for solving two-point boundary value problems that wrapsa slightly modified BVP_SOLVER (seehttp://cs.stmarys.ca/~muir/BVP_SOLVER_Webpage.shtml).
Installation indstructions, a tutorial, examples and documentation can be found athttp://packages.python.org/scikits.bvp_solver/. If you have questions or suggestions
send an e-mail to the mailing list or me.To join the mailing list send an e-mail toscikits-bvp_solver+subscribe@googlegroups.com
Package: scikit-sdr
scikit-sdrscikit-sdris a Python 3 library that provides algorithms for building digital communication systems and for experimenting with DSP and SDR.
The structure of the library is as follows:sksdr: source code for algorithmstests: units tests using the pytest frameworkdemo: demonstrations using Jupyter notebooksgnuradio: GNU Radio wrappers contained in an OOT module (gnuradio/gr-grsksdr) and some demonstration flowgraphs (gnuradio/demo)docs: Sphinx documentationSome of this work as been inspired and/or based of other libraries such askommandscikit-dsp-comm. Other sources include the books:"Digital Communications: A Discrete-time Approach" by Michael Rice"Understanding Digital Signal Processing" by Richard G. Lyons"Digital Signal Processing: Principles, Algorithms and Applications" by John G. Proakis and Dimitris G. Manolakis
Package: scikit-sequitur
SciKit Sequituris an Apache2 licensed Python module for inferring
compositional hierarchies from sequences.Sequitur detects repetition and factors it out by forming rules in a
grammar. The rules can be composed of non-terminals, giving rise to a
hierarchy. It is useful for recognizing lexical structure in strings, and
excels at very long sequences. The Sequitur algorithm was originally developed
by Craig Nevill-Manning and Ian Witten.>>>fromsksequiturimportparse>>>grammar=parse('hello hello')>>>print(grammar)0->1_11->hellohelloSciKit Sequiturworks on strings, lines, or any sequence of Python objects.FeaturesPure-PythonDeveloped on Python 3.10Tested on CPython 3.6, 3.7, 3.8, 3.9, 3.10Tested using GitHub Actions on Linux, Mac, and WindowsQuickstartInstallingscikit-sequituris simple withpip:$ pip install scikit-sequiturYou can access documentation in the interpreter with Python’s built-in help
function:>>>importsksequitur>>>help(sksequitur)# doctest: +SKIPTutorialThescikit-sequiturmodule provides utilities for parsing sequences and
understanding grammars.>>>fromsksequiturimportparse>>>print(parse('abcabc'))0->111->abcabcTheparsefunction is a shortcut forParserandGrammarobjects.>>>fromsksequiturimportParser>>>parser=Parser()Feed works incrementally.>>>parser.feed('ab')>>>parser.feed('cab')>>>parser.feed('c')Parsers can be converted to Grammars.>>>fromsksequiturimportGrammar>>>grammar=Grammar(parser.tree)>>>print(grammar)0->111->abcabcGrammars are keyed by Productions.>>>fromsksequiturimportProduction>>>grammar[Production(0)][Production(1),Production(1)]Mark symbols can be used to store metadata about a sequence. The mark symbol is
printed as a pipe character “|”.>>>fromsksequiturimportMark>>>mark=Mark()>>>markMark()>>>print(mark)|Attributes can be added to mark symbols using keyword arguments.>>>mark=Mark(kind='start',name='foo.py')>>>markMark(kind='start',name='foo.py')>>>mark.kind'start'Mark symbols can not be made part of a rule.>>>parser=Parser()>>>parser.feed('ab')>>>parser.feed([Mark()])>>>parser.feed('cab')>>>parser.feed([Mark()])>>>parser.feed('c')>>>grammar=Grammar(parser.tree)>>>print(grammar)0->1|c1|c1->ababReferencescikit-sequitur Documentationscikit-sequitur at PyPIscikit-sequitur at GitHubscikit-sequitur Issue TrackerLicenseCopyright 2021 Grant JenksLicensed 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: scikits.learn
Warning: this package has been renamed!scikit-learnAboutscikits.learn is a python module for machine learning built on top of
scipy.The project was started in 2007 by David Cournapeau as a Google Summer
of Code project, and since then many volunteers have contributed. See
the AUTHORS.rst file for a complete list of contributors.It is currently maintained by a team of volunteers.Important linksOfficial source code repo:https://github.com/scikit-learn/scikit-learnHTML documentation (stable release):http://scikit-learn.sourceforge.net/HTML documentation (development version):http://scikit-learn.sourceforge.net/dev/Download releases:http://sourceforge.net/projects/scikit-learn/files/Issue tracker:https://github.com/scikit-learn/scikit-learn/issuesMailing list:https://lists.sourceforge.net/lists/listinfo/scikit-learn-generalIRC channel:#scikit-learnatirc.freenode.netDependenciesThe required dependencies to build the software are python >= 2.5,
setuptools, NumPy >= 1.2, SciPy >= 0.7 and a working C++ compiler.To run the tests you will also need nose >= 0.10.InstallThis packages uses distutils, which is the default way of installing
python modules. To install in your home directory, use:python setup.py install --homeTo install for all users on Unix/Linux:python setup.py build
sudo python setup.py installDevelopmentCodeGITYou can check the latest sources with the command:git clone git://github.com/scikit-learn/scikit-learn.gitor if you have write privileges:git clone git@github.com:scikit-learn/scikit-learn.gitTestingAfter installation, you can launch the test suite from outside the
source directory (you will need to have nosetest installed):python -c "import scikits.learn as skl; skl.test()"See web pagehttp://scikit-learn.sourceforge.net/install.html#testingfor more information.
Package: scikit-sos
scikit-sos is a Python module for Stochastic Outlier Selection (SOS). It
is compatible with scikit-learn. SOS is an unsupervised outlier selection
algorithm. It uses the concept of affinity to compute an outlier probability
for each data point.For more information about SOS, see the technical report: J.H.M.
Janssens, F. Huszar, E.O. Postma, and H.J. van den Herik.Stochastic
Outlier
Selection.
Technical Report TiCC TR 2012-001, Tilburg University, Tilburg, the
Netherlands, 2012.Installpipinstallscikit-sosUsage>>>importpandasaspd>>>fromsksosimportSOS>>>iris=pd.read_csv("http://bit.ly/iris-csv")>>>X=iris.drop("Name",axis=1).values>>>iris["score"]=detector.predict(X)>>>iris.sort_values("score",ascending=False).head(10)SepalLengthSepalWidthPetalLengthPetalWidthNamescore414.52.31.30.3Iris-setosa0.9818981064.92.54.51.7Iris-virginica0.964381224.63.61.00.2Iris-setosa0.9579451346.12.65.61.4Iris-virginica0.897970244.83.41.90.2Iris-setosa0.8717331145.82.85.12.4Iris-virginica0.831610626.02.24.01.0Iris-versicolor0.8211411086.72.55.81.8Iris-virginica0.819842445.13.81.90.4Iris-setosa0.7733011006.33.36.02.5Iris-virginica0.765657Selecting outliers from the command lineThis module also includes a command-line tool calledsos.
To illustrate, we apply SOS with a perplexity of 10 to the Iris dataset:$curl-sLhttp://bit.ly/iris-csv|>tail-n+2|cut-d,-f1-4|>sos-p10|>sort-nr|head0.981898400.964381320.957944920.897970430.871732990.831610450.821140720.819842090.773301480.76565738Adding a threshold causes SOS to output 0s and 1s instead of outlier
probabilities. If we set the threshold to 0.8 then we see that out of
the 150 data points, 8 are selected as outliers:$curl-sLhttp://bit.ly/iris-csv|>tail-n+2|cut-d,-f1-4|>sos-p10-t0.8|>paste-sd+|bc8LicenseAll software in this repository is distributed under the terms of the
BSD Simplified License. The full license is in the LICENSE file.
Package: scikit-sound
scikit-soundcontains functions for working with soundDependenciesnumpy, scipyHomepagehttp://work.thaslwanter.at/sksound/html/Author:Thomas HaslwanterDate:26-02-2024Ver:0.2.14Licence:BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)Copyright:© 2024, Thomas Haslwanter, all rights reserved.InstallationYou can install scikit-sound withpip install scikit-soundand upgrade to a new version withpip install scikit-sound -USound Processing Utilitiessounds.Sound … class, with methodsgenerate_soundget_infoplayread_soundsummarywrite_wavMisc Other Utilitiesmisc … GUI routines for standard file- and directory-handlingaskquestionget_dirget_fileprogressbarsave_file
Package: scikit-spark
Spark acceleration for Scikit-LearnThis project is a major re-write of thespark-sklearnproject, which
seems to no longer be under development. It focuses specifically on the
acceleration of Scikit-Learn's cross validation functionality using PySpark.Improvements over spark-sklearnscikit-sparksupportsscikit-learnversions past 0.19,spark-sklearnhave stated that they are probably not
going to support newer versions.The functionality inscikit-sparkis based onsklearn.model_selectionmodule rather than the
deprecated and soon to be removedsklearn.grid_search. The newmodel_selectionversions
contain several nicer features andscikit-sparkmaintains full compatibility.InstallationThe package can be installed through pip:pipinstallscikit-sparkIt has so far only been tested with Spark 2.2.0 and up, but may work with
older versions.Supported scikit-learn versions0.18 untested, likely doesn't work0.19 supported0.20 supported0.21 supported (Python 3 only)0.22 supported (Python 3 only)UsageThe functionality here is meant to as closely resemble using Scikit-Learn as
possible. By default (withspark=True) theSparkSessionis obtained
internally by callingSparkSession.builder.getOrCreate(), so the instantiation
and calling of the functions is the same (You will preferably have already
created aSparkSession).This example is adapted from the Scikit-Learn documentation. It instantiates
a localSparkSession, and distributes the cross validation folds and
iterations using this. In actual use, to get the benefit of this package it
should be used distributed across several machines with Spark as running it
locally is slower than theScikit-Learnparallelisation implementation.fromsklearnimportsvm,datasetsfrompyspark.sqlimportSparkSessioniris=datasets.load_iris()parameters={'kernel':('linear','rbf'),'C':[0.01,0.1,1,10,100]}svc=svm.SVC()spark=SparkSession.builder\.master("local[*]")\.appName("skspark-grid-search-doctests")\.getOrCreate()# How to run grid searchfromskspark.model_selectionimportGridSearchCVgs=GridSearchCV(svc,parameters)gs.fit(iris.data,iris.target)# How to run random searchfromskspark.model_selectionimportRandomizedSearchCVrs=RandomizedSearchCV(spark,svc,parameters)rs.fit(iris.data,iris.target)Current and upcoming functionalityCurrentmodel_selection.RandomizedSearchCVmodel_selection.GridSearchCVUpcomingmodel_selection.cross_val_predictmodel_selection.cross_val_scoreThe docstrings are modifications of the Scikit-Learn ones and are still being
converted to specifically refer to this project.Performance optimisationsReducing RAM usageComing soon
Package: scikit-splearn
Thescikit-splearnpackage is a  Python scikit toolbox for spectral learning algorithms.These algorithms aim at learning Weighted Automata (WA) using what is named a Hankel matrix. The toolbox thus provides also a class for WA (with a bunch of useful methods), another one for Hankel matrix, and a class for loading data. As WA are a generalization of classical Probabilistic Automaton (and thus HMM), everything works for these simpler models.The core of the learning algorithms is to compute a singular values decomposition of the Hankel matrix and then to construct the weighted automata from the elements of the decomposition. This is done in the class Learning.In its classic version, the rows of the Hankel matrix are prefixes while its columns are suffixes. Each cell contains then the probability of the sequence starting with the corresponding prefix and ending with the corresponding suffix. In the case of learning, the cells contain observed frequencies.scikit-splearnprovides other versions, where each cell contains the probability that the corresponding sequence is prefix, a suffix, or a factor.Formally, the Hankel matrix is bi-infinite. Hence, in case of learning, one has to concentrate on a finite portion. The parameters lrows and lcolumn allows to specified which subsequences are taken into account as rows and columns of the finite matrix. If, instead of a list, an integer is provided, the finite matrix will have all rows and columns that correspond to subsequences up to these given lengths.The learning method requires also the information about the rank of the matrix. This rank corresponds to the number of states of a minimal WA computing the matrix (in case of learning, this is the estimated number of states of the target automaton). There is no easy way to evaluate the rank, a cross-validation approach is usually used to find the best possible value.Finally,scikit-splearnprovides 2 ways to store the Hankel matrix: a classical one as an array, and a sparse version usingscipy.sparse.The original scikit-splearn Toolbox is developed in Python atLabEx Archimède, as aLISproject.This package, as well as thescikit-splearntoolbox, is Free software, released under BSD License.The latest version ofscikit-splearncan be downloaded from the followingPyPI page.The documentation is availablehere.There is also agitlab repository, which provides the git repository managing the source code and where issues can be reported.History1.0.0 (2016-06-30)First version1.0.1 (2016-10-07)Bug setup correction1.1.0 (2018-15-02)Adding IO functionsRebaseDot display method1.2.0 (2018-22-02)Adding dot export for AutomataAdding yalm and json import and export for Automata and HankelAdding random SVD as an option for dense Hankel matrix calculation.Rebase : removing Learning class + some new functionnalitiesUpdate doc.AuthorsFrançois DenisRémi EyraudDenis ArrivaultDominique Benielli
Package: scikits.samplerate
Samplerate is a small python package to do high quality audio resampling for
data in numpy arrays; IOW, it is a matlab resample replacement.Samplerate is a wrapper around the Secret Rabbit Code from Erik de Castro Lopo
(http://www.mega-nerd.com/SRC/), which has high quality converters based on the
work of J.O Smith from CCRMA (seehttp://ccrma.stanford.edu/~jos/resample/optfir.pdf)
Package: scikits.talkbox
Talkbox, to make your numpy environment speech aware !Talkbox is set of python modules for speech/signal processing. The goal of thistoolbox is to be a sandbox for features which may end up in scipy at somepoint. The following features are planned before a 1.0 release:* Spectrum estimation related functions: both parametic (lpc, highresolution methods like music and co), and non-parametric (Welch,periodogram)* Fourier-like transforms (DCT, DST, MDCT, etc...)* Basic signal processing tasks such as resampling* Speech related functionalities: mfcc, mel spectrum, etc..* More as it comesI want talkbox to be useful for both research and educational purpose. As such,a requirement is to have a pure python implementation for everything - foreducational purpose and reproducibility - and optional C for speed.
Package: scikit-stan
scikit-stanScikit-Stan is a package ofStanmodels wrapped in aScikit-Learnstyle interface.This package is currently under active development and should be treated as beta software.Documentation is available athttps://brianward.dev/scikit-stan/or onReadTheDocs(older versions and PDFs available).InstallationPre-compiled wheels for the package are available for MacOS, Windows, and Linux systems viapip install scikit_stan.Source installation requires a working installation ofCmdStan.Basic usagefromscikit_stanimportGLMm=GLM(family='gamma')# Gamma family distribution with canonical inverse linkm.fit(X,y)# runs HMC-NUTSpredictions=m.predict(X)# generates new predictions from fitted modelscore=m.score(X,y)# computes the R2 score of the fitted model on the data X and observations yAttributionThis package is licensed under the BSD 3-clause license.It is inspired by existing packages in the Stan ecosystem likerstanarm.This package was initially developed at the Simons Foundation by Alexey Izmailov during
a summer 2022 internship under the mentorship of Brian Ward.