Saravanan666/pypi-org huggingface dataset:
Package: modeldeploy-proxy-labextension
modeldeploy-proxy-labextensionA proxy for model deployment.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstallmodeldeploy-proxy-labextensionUninstallTo remove the extension, execute:pipuninstallmodeldeploy-proxy-labextensionContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the modeldeploy-proxy-labextension directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstallpipuninstallmodeldeploy-proxy-labextensionIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedmodeldeploy-proxy-labextensionwithin that folder.Testing the extensionFrontend testsThis extension is usingJestfor JavaScript code testing.To execute them, execute:jlpm
jlpmtestIntegration testsThis extension usesPlaywrightfor the integration tests (aka user level tests).
More precisely, the JupyterLab helperGalatais used to handle testing the extension in JupyterLab.More information are provided within theui-testsREADME.Packaging the extensionSeeRELEASE
Package: model-diagnostics
model-diagnosticsCI/CDDocsPackageMetaTools for diagnostics and assessment of (machine learning) modelsHighlights:All common point predictions covered: mean, median, quantiles, expectiles.Assess model calibration withidentification functions(generalized residuals) andcompute_bias.Assess calibration and bias graphicallyreliability diagramsfor auto-calibrationbias plotsfor conditional calibrationAssess the predictive performance of modelsstrictly consistent, homogeneousscoring functionsscore decompositioninto miscalibration, discrimination and uncertainty:rocket: To our knowledge, this is the first python package to offer reliability diagrams for quantiles and expectiles and a score decomposition, both made available by an internal implementation of isotonic quantile/expectile regression. :rocket:Read more in thedocumentation.This package relies on the giant shoulders of, among others,polars,matplotlib,scipyandscikit-learn.Installationpip install model-diagnosticsContributionsContributions are warmly welcome!
When contributing, you agree that your contributions will be subject to theMIT License.
Package: modeldocs
modeldocs is a documentation generator for your model subclasses.By parsing source code files, this generates documentation for your data models with
a documentation format similar to apidocs (https://github.com/apidoc/apidoc)InstallationFrom pypi:$ pip install modeldocsOr from the project root directory:$ python setup.py installUsageFirst, create a configuration file in json, like (optional “include”):{
    "name": "My Documentation",
    "version": "1.0.0",
    "title": "My Documentation Title",
    "description": "This documents my data models",
    "include": [
        "mymodule",
        "tests/myfile.py"
    ]
}Save it as modeldocs.json in the current directory.Then simply run it, and it’ll search for all modeldocs recursively from the current directory:$ modeldocsOr, specify via the command line where to look and what files:$ modeldocs --include mymodule myfile.pyOr pass a path to your custom config, which may specify an “include” configuration variable:$ modeldocs --config my_model_docs.jsonAlso, you can specify a custom output directory (default “docs”):$ modeldocs --output mydocsUse –help/-h to view info on the arguments:$ modeldocs --helpThe format is pretty simple. It follows a very similar format to apidocs (check github link above), example:class Motorcycle(MongoCollection):
    '''
    @modelGroup Vehicles
    @modelTitle Motorcycle
    @modelDescription This represents a motorcycle and all its data.

    @modelField {String} name the motorcycle name
    @modelField {Number} year the year it was made
    @modelField {Datetime} purchased_at the datetime it was purchased
    @modelField {String="red","green","blue"} color the color of the motorcycle, with specified possible values.
    @modelField {String} [owner] the owner of the vehicle (optional due to brackets)
    @modelField {Number} [wheels=2] the number of wheels (default 2 as specified)

    @modelExample {json} Motorcycle Example
        {
            "name": "yamaha v-star 650",
            "year": 2002,
            ...
        }
    '''
    passThat’s all it takes. Just add doc strings like the above to all your classes and it will recursively discover them
and generate the documentation into the “docs” directory.Release Notes0.1.3:Fix issue with labeltype description wrapping multiple lines0.1.2:Add note to readme0.1.1:Better method of parsing, without loading any python modules. Just give it an include directory.0.1.0:Generates docs!0.0.1:Project created
Package: model-driven-inference-its
ITS-analysis-for-model-driven-inferenceRepository with the interrupted time series code based on prophet and Poisson regression.This OSS project is aimed to provide codebase that allows a user to use two different Interrupted Time Series models sequentially. The codebase provides a generic source code that allows model driven inference for any generic model.This projects allows a user to use their data in a specified format to perform interrupted time series, get summaries of their data via plots & metrics.User GuideDemo notebookDocumentation WebsiteFull DocumentationCode Documentation
Package: model-engine
ModelEngineThe ModelEngine repo is used to integrate new Tensorflow models into the OsmosisAI platform, though it is not strictly related to that platform. The main feature of this codebase is its simplified API for training and inferencing with common models. Currently support is only available for YOLOv3 models, with support for more models being planned.InstallationTo use ModelEngine, install using pip:pip install model-engineUsagefrommodel_engine.modelsimportget_modelyolo_model=get_model('yolov3:object_detection')# Note that as of this version, utilities for creating records in the right format# are not ported to this project but are coming soon.record_provider=yolo_model.Meta.record_provider('train.tfrecord','val.tfrecord','label_map.txt')model_instance=yolo_model()model_instance.train(record_provider)This API is in flux at the moment and derives some design principles from other projects such as Django. The current design is mainly influenced by decisions we've made in the past for our core OsmosisAI platform. Changing some things here requires making sure our platform is also ready for the change to be made, but we are open to making changes as necessary to support the wide usage of ModelEngine.ModelsCurrently we support the following models:YOLOv3Support for more models is being planned and will be updated here later.GoalsThe API of this project is still in flux due to limited model availability, but we plan to try and keep it as simple and flexible as possible. One of our main goals is to reduce the amount of complexity around using model code inside other codebases. We will import other projects where possible to reduce the amount of code needing management, but many Tensorflow 2 codebases rely heavily on the usage of Abseil for configuration which does not play nicely when integrating with other code.We also strive to keep outside dependencies to a minimum and currently aim to only require the necessary packages for Tensorflow 2.2.0.ContributingContributions are welcome from anyone. Contributions here will also make the open-source OsmosisAI platform better by adding support for training and inferencing with new models.If bugs or other issues are found please submit an issue using GitHub or if preferred our corporate email:contact@osmosisai.com.To see a list of sources we've used take a look at theacknowledgements.
Package: modelestimator-v2
modelestimator --- Infer sequence evolution rate matrices from a MSAExample usagemodelestimator-t0.001file1.fafile2.fafile3.faInfer a rate matrix (written to stdout) from three alignment files in Fasta format.
The output is PAML format by default, and therefore applicable in a number of
available phylogenetic softwares.modelestimator-b200file.faTry the experimental bootstrapping feature (200 replicates) on a Fasta multialignment.Syntaxmodelestimator <options> infiles<format>should be either FASTA, STOCKHOLM or PHYLIP format.Output is a rate matrix and residue distribution vector.Options-h, --help            show this help message and exit
  --version             show program's version number and exit
  -a {iqtree,matlab,mrbayes,octave,paml,phyml}, --application {iqtree,matlab,mrbayes,octave,paml,phyml}
                        Choose output format to suit the application you want
                        to use for inference. The 'iqtree', 'paml' and 'phyml'
                        options are identical. The 'matlab' and 'octave'
                        optins are for import into MatLab-compatible programs
                        and are presenting the actual Q matrix rather than the
                        R matrix used by PAML/PhyML, etc. Default: paml
  -f {fasta,clustal,nexus,phylip,stockholm}, --format {fasta,clustal,nexus,phylip,stockholm}
                        Specify sequence format of input files. Default: fasta
  -t T, --threshold T   Stop when consecutive iterations do not change by more
                        than T. Default: 0.001
  -b N, --bootstrap N   Estimate the rate matrix using bootstrapping by
                        computing N resampled replicates of the input
                        multialignment. For each replicate, a rate matrix is
                        computed. The mean matrix the elementwise standard
                        deviation is returned. Only one infile should be given
                        in this mode.
  -B N, --bootstrapped_quality N
                        Estimate the quality of the rate matrix estimate using
                        a bootstrap procedure. The multialignment is resampled
                        N times and a Q matrix is computed for each replicate.
                        Then the difference (matrix norm) between rate matrix
                        estimated without resampling and each bootstrapped Q
                        is computed and the mean difference is returned. Only
                        one infile should be given in this mode. Returns
                        bootstrap norm.
Package: model-evaluation-777
Speech Enhancement Model EvaluationThis is a python package to evaluate your speech enhancement model performance.Installationpip install model-evaluation-777 -i https://pypi.org/simplePESQ and STOI Evaluationdefevaluate(ref_dir="/media/youwei/Chauncey's/VERSO_Dataset/test/clean/",deg_dir="/media/youwei/Chauncey's/VERSO_Dataset/test/noisy/",fs=16000):'''Args:ref_dir: reference signal directorydeg_dir: degration signal directoryfs: sample rateReturns:pesq_score_average, stoi_score_average'''frommodel_evaluationimportstoi_pesqpesq_score,stoi_score=stoi_pesq.evaluate(ref_dir=ref_dir,deg_dir=deg_dir,fs=16000)Plot SNR vs PESQdefplot_snr_pesq(out_dir,enh_dir,ref_dir="/media/youwei/Chauncey's/VERSO_Dataset/test/clean/",deg_dir="/media/youwei/Chauncey's/VERSO_Dataset/test/noisy/",fs=16000):'''Args:out_dir: directory to save figureenh_dir: enhanced signal directoryref_dir: reference signal directorydeg_dir: degration signal directoryfs: sample rateReturns:snr vs pesq score data'''The SNR vs PESQ figure will save to out_dir automatically.frommodel_evaluationimportstoi_pesqdata=stoi_pesq.plot_snr_pesq(out_dir=out_dir,enh_dir=enh_dir)Plot SNR vs STOIdefplot_snr_stoi(out_dir,enh_dir,ref_dir="/media/youwei/Chauncey's/VERSO_Dataset/test/clean/",deg_dir="/media/youwei/Chauncey's/VERSO_Dataset/test/noisy/",fs=16000):'''Args:out_dir: directory to save figureenh_dir: enhanced signal directoryref_dir: reference signal directorydeg_dir: degration signal directoryfs: sample rateReturns:snr vs stoi score data'''The SNR vs STOI figure will save to out_dir automatically.frommodel_evaluationimportstoi_pesqdata=stoi_pesq.plot_snr_stoi(out_dir=out_dir,enh_dir=enh_dir)
Package: model-evaluator
Model EvaluatorDescriptionA package for training and evaluating PyTorch models.Now it supports only visualization of training of models, but in future will support training
and evaluation of many models which can be very useful for students.If you have any bugs/improvement ideas, create an issue thread.GitHub repositoryPyPiInstallationFor installation you need to execute following command:pip install model-evaluatorThen you can import library and use it in your code:import model_evaluatorExample usagefrom model_evaluator import Trainer, PlottingOptions, Accuracy, F1Score

train_data_loader = ...
test_data_loader = ...
model = ...
optimizer = ...
criterion = ... # those are yours

trainer = Trainer(model, optimizer, criterion, [Accuracy(), F1Score()],
                  plotting_options=PlottingOptions.PLOT_BOTH, plot_interval=8)
trainer.train(NUM_EPOCHS, train_data_loader, test_data_loader, device)AuthorsArtsiom Halian -GitHubVersions1.0.13 - Added cpu loss for weighted losses1.0.12 - Fixes1.0.11 - Fixes1.0.10 - Fixes1.0.9 - Fixes1.0.8 - Fixes1.0.7 - Added HuggingFace support1.0.6 - Explicit conversion to tensor1.0.5 - Fixed plotting1.0.4 - Fixed binary recognition1.0.3 - Fixed multiclass backward error1.0.2 - Fixed history error1.0.1 - Updated readme1.0.0 - Initial version
Package: modelforge
ModelforgeModelforge is a foundation for sharing trained machine learning models. It is a set of command line
tools and a Python library. Modelforge maintains model files in a third-party remote storage service
("cloud") using the backend mechanism. Model metadata (download links, names, descriptions, versions,
etc.) resides in a Git repository called the "Index", and documentation is automatically generated
there. Modelforge does no assumptions about the models: they can be of any origin, such as TensorFlow,
scikit-learn, or your custom. The underlying model storage format -Advanced Scientific Data Format- can wrap any data
easily and efficiently, but it's the developer's responsibility to convert.Learn more about:Why?- what problem Modelforge tries to solve.Modelforge model- what is a model in Modelforge context.Model storage format- low-level serialization details.Backends- extension system to upload and download models from clouds.Git Index- how documentation about the models is generated from the structured metadata.Command line tools- how to perform typical operations.API- Modelforge API for developers.Who uses Modelforge?source{d}, insrc-d/mlandsrc-d/lookout-sdk-ml; the public index issrc-d/models.InstallYou can run Modelforge through Docker:docker run -it --rm srcd/modelforge --helpor install it using thePython package manager:pip3 install modelforgeUsageThe project exposes two interfaces:command lineandAPI.ContributionsContributions are pretty much welcome! Please follow thecontributions guideand thecode of conduct.If you wish to make your MLonCode model available insrc-d/models,
please  fork that repository and runmodelforge publishto upload your model on your fork. Then
create a pull request. You should provide read access to the model file for everybody. If you
consider using our Google Cloud Storage bucket, feel free to contact us through GitHub issues.LicenseApache 2.0.
Package: modelfox
ModelFox for PythonWatch the VideoRead the DocsThe ModelFox Python library makes it easy to make predictions with your ModelFox machine learning model from Python.Usage$ pip install modelfoximportmodelfoxmodel=modelfox.Model.from_path('./heart_disease.modelfox')input={'age':63,'gender':'male',# ...}output=model.predict(input)For more information,read the docs.Platform SupportModelFox for Python is currently supported on Linux, macOS, and Windows with ARM64 and AMD64 CPUs. Are you interested in another platform?Open an issueor send us an email athelp@modelfox.dev.ExamplesThe source for this package contains a number of examples in theexamplesdirectory. Each example has aREADME.mdexplaining how to run it.NotesModelFox for Python requires pip 20.3 or later, which includes support forPEP 600. This is necessary to correctly install modelfox's native extension. If you are using an earlier python version, you may see the error "Could not find a version that satisfies the requirement modelfox" when you attempt topip install modelfox. To resolve this, you should upgrade pip to version 20.3 or later.
Package: modelframe
Compute fixed and random effects model matrices in PythonAboutmodelframebuilds model matrices and response vectors from a given
dataset usinglme4-style formulas in Python.InstallationYou can installmodelframeeither from PyPI using:pipinstallmodelframeor using the latest GitHub [release](https://github.com/dirmeier/modelframe/releases/):python-mpipinstallgit+https://github.com/dirmeier/modelframe.git@v0.1.0AuthorSimon Dirmeiersimon.dirmeier at web.de.
Package: model-framework
⚠Work in progress!This project is in an early prototyping phase.What is ‘model-framework’?Model-framework is a framework to build simple to use Python interfaces for complex models. For instance, a structural analysis tool (likeFramAT) requires a number of user inputs parameters, for instance, for general settings, material or loads. It can be cumbersome to develop a consistent user interface for such a tool which has a large number of settings. Model-framework helps to build good Python user API’s for complex models. In particular it aims to improve the following aspects of the developer and user experiences.Providing a simple to understand Python API to build and interact with complex modelsEnforcing API consistencyUser input validationFull API documentation through automatic documentation generationFlexible model extensibilityClear separation between user input and solution routinesPlease refer do thedocumentationfor more information.InstallationModel-Frameworkis available onPyPIand may simply be installed withpip install model-frameworkLicenseLicense:Apache-2.0
Package: modelfree-protein15n
# modelfree-protein15n
Model-Free analysis framework for protein backbone amide 15N NMR spin relaxation rates.This tool fits the relaxation data to a multi-Lorentzian spectral density function.
One can choose the number of Lorentzians (dynamic modes) for the fit.
Typically, one can perform 1, 2, and 3 dynamic mode MF analysis and see which model is most relevant for the data.
IMPACT analysis is also possible by fixing the correlation times and fitting the amplitudes.## Relevant litteratureLipari & Szabo, Journal of the American Chemical Society (1982);
Halle, The Journal of chemical physics (2009);
Khan et al., Biophysical journal (2015)# installation$ pip install modelfree-protein15n# usageThe program is able to generate random relaxation data with the command ‘modfree generate’.
The program is able to fit relaxation data to a model with the command ‘modfree fit’.
The program is able to plot the results with the command ‘modfree plot’.## Data generationTo generate relaxation data, type the following command:$ modfree generateThe following flags are available:
-o (str): Output directory containing the generated data.
-modes (int): number of dynamic modes used to generate the data
-n (int): number of residues in the data
-noise (float): between 0 and 1, indicates the proportion of noise to put in the data. (0.03 by default)
-fields (list, int or float): Magnetic fields used for the rate generation in MHz.
-rates: relaxation rates to generate. by default R1, R2, NOE, etaXY.For example, you can type:$ modfree generate -o Generated -modes 2 -n 70 -noise 0.05 -fields 600 700 850 950 1200 -rates R1 R2 NOE etaXY etaZ## Data fittingTo fit relaxation data, you will need your data in a specific format akin to the generated data. Generate some data to see how it’s done. You will also need a directory file and a parameter file. type the following command to fit the data generated in the previous section:$ modfree fit -o Generated_fit -d Generated/directories.toml -p Generated/parameters.tomlYou can also fit only part of the data with the flag -r:$ modfree fit -o Generated_fit -d Generated/directories.toml -p Generated/parameters.toml -r 10 11 12 13 14 15 16 17Or$ modfree fit -o Generated_fit -d Generated/directories.toml -p Generated/parameters.toml -r 15## Data plottingTo plot the fitted data, just type:$ modfree plot -o Generated_fit -p allThe following flags are available:
-o (str): Output directory containing the data.
-p: What to plot (all, relaxation, parameters, statistics, correlation)
-format: Format of the plot files (pdf, png, jpg, svg…)
-dpi (600 by default)
Package: modelfun
Please go toMODELFUNto try examplesEliminate the bottleneck of handmade marks and release AI potential.Modelfun Python SDKThis package provides functionality developed to simplify interfacing with the [MODELFUN API] in Python 3.InstallationThe package can be installed withpip:pipinstall--upgrademodelfunInstall from source:pythonsetup.pyinstallRequirementsPython 3.6+Quick StartTo use this library, you must have an API key and specify it as a string when creating themodelfun.Clientobject. API keys can be created through theplatform. This is a basic example of the creating the client and using thegenerateendpoint.Generateimportmodelfun# initialize the Modelfun Client with an API Keymo=modelfun.Client('YOUR_API_KEY')prompt='''摘要：本文总结了十个可穿戴产品的设计原则，而这些原则，同样也是笔者认为是这个行业最吸引人的地方：1.为人们解决重复性问题；2.从人开始，而不是从机器开始；3.要引起注意，但不要刻意；4.提升用户能力，而不是取代人答案：'''# generate a prediction for a promptprediction=mo.generate(model_name='modelfun',prompt=prompt)# print the predicted textprint('prediction:{}'.format(prediction.generations[0].text))Classifyimportmodelfunfrommodelfun.classifyimportExample# initialize the Modelfun Client with an API Keymo=modelfun.Client('YOUR_API_KEY')response=mo.classify(model_name='modelfun',task_name='情感分析',inputs=["世界充满了欺骗","世界和平"],examples=[Example("基本都是欺骗","消极"),Example("基本都是惊喜","积极")],labels=["消极","积极"])print('prediction:{}'.format(response.classifications))VersioningTo use the SDK with a specific API version, you can specify it when creating the Modelfun Client:importmodelfunmo=modelfun.Client('YOUR_API_KEY','2022-08-08')EndpointsModelfun EndpointFunction/generatemo.generate()/classifymo.classify()ModelsWhen you call Modelfun's APIs we decide on a good default model for your use-case behind the scenes. The default model is great to get you started, but in production environments we recommend that you specify the model size yourself via themodelparameter.ResponsesAll of the endpoint functions will return a Modelfun object corresponding to the endpoint (e.g. for generation, it would beGeneration). The responses can be found as instance variables of the object (e.g. generation would beGeneration.text). Printing the Modelfun response object itself will display an organized view of the instance variables.