Saravanan666/pypi-org huggingface dataset:
Package: modelgraph
modelgraphA tool for visualizing dependencies between different components of your model.MotivationAssume you have some model, represented as a system of ODEs with potentially several intermediation expression. For example in the classical Hodgkin Huxley model of the squid axon from 1952 we have the following expressionsdV_dt = -(-i_Stim + i_Na + i_K + i_L)/Cm
i_Na = g_Na*m**3*h*(V - E_Na)From this we can deduce thati_Nadepends on the parameterg_Na, and sincedV_dtdepends oni_Nait also depends (indirectly) on the parameterg_Na.Inmodelgraphwe can visualize this dependency using the following code snippetfrommodelgraphimportDependencyGraphimportgotran# Load ode using gotranode=gotran.load_ode("hodgkin_huxley_squid_axon_model_1952_original.ode")# Build dependency graphgraph=DependencyGraph(ode)# Get the components that depends on g_Na (we call this inverse dependents)G=graph.inv_dependency_graph("g_Na")# Visualize using matplotlib (python -m pip install matplotlib)importmatplotlib.pyplotaspltnx.draw(G,with_labels=True,font_size=10,node_size=2000)plt.savefig("g_Na_mpl.png")# Or using pydot (python -m pip install pydot)P=nx.nx_pydot.to_pydot(G)P.write_png("g_Na_pydot.png")It is also possible to go the other way around, i.e if you want to look at e.gdV_dtand see that it depends on# Visualize what dV_dt depdens onG_dV_dt=graph.dependency_graph("dV_dt")nx.draw(G_dV_dt,with_labels=True,font_size=10,node_size=2000)plt.savefig("dV_dt_mpl.png")P_dV_dt=nx.nx_pydot.to_pydot(G_dV_dt)P_dV_dt.write_png("dV_dt_pydot.png")Here we only display the graphpydotsince thematplotlibversion seems to be a bit messy if the graph becomes too largeInstallationInstall with pippython3 -m pip install modelgraphGUIThere is also a graphical user interface. To use this you need to installstreamlitpython -m pip install streamlitYou can run the the gui by passing in the.odefile as a command line argument e.gpython -m modelgraph demo/hodgkin_huxley_squid_axon_model_1952_original.odeThis will start astreamlitserver, and the GUI is now hosted onhttp://localhost:8501DocumentationDocumentation is hosted athttp://computationalphysiology.github.io/modelgraph.Automated testTests are provided in the foldertests. You can run the tests with pytestpython3 -m pytest tests -vvContributingSeethe contributing sectionAuthorsHenrik Finsberg (henriknf@simula.no)LicenseMIT
Package: model-harmonics
Python tools for obtaining and working with model synthetic spherical harmonic coefficients for comparing with data from the the NASA/DLR Gravity Recovery and Climate Experiment (GRACE) and the NASA/GFZ Gravity Recovery and Climate Experiment Follow-On (GRACE-FO) missionsThese are extension routines for the set ofgravity-toolkittoolsResourcesNASA GRACE mission siteNASA GRACE-FO mission siteJPL GRACE Tellus siteJPL GRACE-FO siteUTCSR GRACE siteGRACE at the NASA Physical Oceanography Distributed Active Archive Center (PO.DAAC)GRACE at the GFZ Information System and Data CenterDependenciesgeoid-toolkit: Python utilities for calculating geoid heights from static gravity field coefficientsgravity-toolkit: Python tools for working with GRACE/GRACE-FO datapygrib: Python interface for reading and writing GRIB datacdsapi: Python client libraries for the CDS Web APIfiona: Python wrapper for vector data access functions from the OGR librarypyproj: Python interface to PROJ libraryshapely: PostGIS-ish operations outside a database context for Pythonecmwf-api-client: Python client libraries for the ECMWF Web APIReferencesI. Velicogna, Y. Mohajerani, G. A, F. Landerer, J. Mouginot, B. No&euml;l,
E. Rignot, T. C. Sutterley, M. van den Broeke, J. M. van Wessem, and D. Wiese,
“Continuity of ice sheet mass loss in Greenland and Antarctica from the GRACE
and GRACE Follow‐On missions”,Geophysical Research Letters, 47,
(2020).doi: 10.1029/2020GL087291T. C. Sutterley, I. Velicogna, and C.-W. Hsu, “Self‐Consistent Ice Mass Balance
and Regional Sea Level From Time‐Variable Gravity”,Earth and Space Science, 7,
(2020).doi: 10.1029/2019EA000860DownloadThe program homepage is:https://github.com/tsutterley/model-harmonicsA zip archive of the latest version is available directly at:https://github.com/tsutterley/model-harmonics/archive/main.zipDisclaimerThis project contains work and contributions from thescientific community.
This program is not sponsored or maintained by the Universities Space Research Association (USRA),
the Center for Space Research at the University of Texas (UTCSR), the Jet Propulsion Laboratory (JPL),
the German Research Centre for Geosciences (GeoForschungsZentrum, GFZ) or NASA.
It is provided here for your convenience butwith no guarantees whatsoever.LicenseThe content of this project is licensed under theCreative Commons Attribution 4.0 Attribution licenseand the source code is licensed under theMIT license.
Package: modelhouse
modelhouseWhy?The purpose ofmodelhouseis to make it easy to distribute models to workers on cloud.Withmodelhouse, you can store and load your models from different storage backends (Google Cloud Storage, AWS S3, local).modelhousealso provides model caching, which can significantly reduce model loading time while keeping memory utilization low.Installationpip install modelhouseDocumentationFor documentation, please visithttps://modelhouse.readthedocs.io/en/latest/Getting startedTODO
Package: modelhub
# ModelhubA CLI tool to manage your models.## CommandsIt takes a TensorFlow SaveModel file, uploads it with version and meta info, and checkouts it to local.- info model_name[@version_number]- create model_name -m “comment”- submit model_name -m “comment” [–batching_config=batching_config.txt] model_path- checkout model_name[@version_number]- deploy model_name[@version_number] [CPU/GPU] [online/offline] [instance-number] [offline]## NTF modelsModelHub ogirinally supports uploading only TensorFlow-based models. From 0.0.8, it supports NTF models.To prepare NTF models, you need create a new folder containing two subfolders: variables and assetsvaribles: storing trained modelsassets: storing any other data files, for example, feature dictionaries.## Python API
pass
get model path by model name [and version]checkout model
Package: modelhub-ai
We are building a collection of deep learning models. Check it outhere.Crowdsourced through contributions by the scientific research community, Modelhub is a repository of deep learning models pretrained for a wide variety of applications. Modelhub highlights recent trends in deep learning applications, enables transfer learning approaches and promotes reproducible science.This repository is the index/registry of all models, and as such the point where all developments of theModelhub Projectcome together.Essential Information/Documentation:Quick StartTechnical OverviewContribute Your Own Model to ModelhubPlease refer tomodelhub.readthedocs.iofor the full documentation of the Modelhub project and infrastructure.About Us:We are theComputational Imaging and Bioinformatics Laboratoryat the Harvard Medical School, Brigham and Women’s Hospital and Dana-Farber Cancer Institute. We are a data science lab focused on the development and application of novel Artificial Intelligence (AI) approaches to various types of medical data.
Package: modelib
A minimalist framework for online deployment of sklearn-like modelsInstallationpipinstallmodelibUsageThe modelib package provides a simple interface to deploy and serve models online. The package is designed to be used with thefastapipackage, and supports serving models that are compatible with thesklearnpackage.First, you will need to create a model that is compatible with the sklearn package. For example, let's create a simple RandomForestClassifier model with a StandardScaler preprocessor:MODEL=Pipeline([("scaler",StandardScaler()),("clf",RandomForestClassifier(random_state=42)),]).set_output(transform="pandas")Let's assume that you have a dataset with the following columns:FEATURES=[{"name":"sepal length (cm)","dtype":"float64"},{"name":"sepal width (cm)","dtype":"float64"},{"name":"petal length (cm)","dtype":"float64"},{"name":"petal width (cm)","dtype":"float64"},]After the model is created and trained, you can create a modelib runner for this model as follows:importmodelibasmlsimple_runner=ml.SklearnRunner(name="my simple model",predictor=MODEL,method_name="predict",features=FEATURES,)Another option is to use theSklearnPipelineRunnerclass which allows you to get all the outputs of the pipeline:pipeline_runner=ml.SklearnPipelineRunner("Pipeline Model",predictor=MODEL,method_names=["transform","predict"],features=FEATURES,)Now you can extend a FastAPI app with the runners:importfastapiapp=fastapi.FastAPI()app=ml.init_app(app,[simple_runner,pipeline_runner])Theinit_appfunction will add the necessary routes to the FastAPI app to serve the models. You can now start the app with:uvicorn<replace-with-the-script-filename>:app--reloadAfter the app is running you can check the created routes in the Swagger UI at the/docsendpoint.The created routes expect a JSON payload with the features as keys and the values as the input to the model. For example, to make a prediction with the simple model runner you can send a POST request to the/my-simple-modelendpoint with the following payload:{"sepal length (cm)":5.1,"sepal width (cm)":3.5,"petal length (cm)":1.4,"petal width (cm)":0.2}The response will be a JSON with the prediction:{"result":0}ContributingIf you want to contribute to the project, please read theCONTRIBUTING.mdfile for more information.
Package: modelicapy
ModelicaPyA Python package containing a variety of scripts and functions for interaction with Modelica and TRANSFORM.ContactScott GreenwoodLicenseThis project is licensed under the UT-Battelle Open SourceLicense(Permissive)Copyright 2017, UT-Battelle, LLCInstallation and Usehttps://pypi.org/project/modelicapy/-pip version may be behind GitHubpip install modelicapy

from modelicapy import cleanData as clnFor updating your pip install to the latest GitHub version:pip install git+git://ADDRESS@masterorpip install --upgrade git+git://ADDRESS@masterBrief Description of FilesGraphViz folder - Generation of dependency graphs of a Modelica library.parametric.py - Generate parametric sweeps for simulations.read_dslog.py - Create a summary of the dslog file (e.g., pass/fail, simulation time, etc.).gen_dsin.py - Generate new dsin.txt file from dsin.txt or dsfinal.txt with modified simulation and/or variable parameters.regressiontest.py - Modified regressiontest.py file from BuildingsPy for regression testing on WindowscleanData.py - Returns data using a 'r=Reader' from buildingspy that has been cleaned of repeated values (i.e., due to events) and interpolates between values.getValues - Functions to return single values from components. Helpful for getting initial values. Includes Modelica formatted output. For use with TRANSFORM.createUnitScripts.py - autogenerate .mos files for use with buildingspy regression test.raven folder - contains an example of running FMU (via pyFMI) withRAVENwordclouds folder - example playing with the Modelica conference proceedings and wordcloudTo Contribute...You may report any issues with using the Issues button.Contributions in the form of Pull Requests are always welcome.
Package: modelify
ModelifyModelify takes over all devops jobs from data scientists and machine learning practitioners and brings their models to production.Installpip install modelifyUsageDeploying LightGBM Modelimportpandasaspdfromsklearn.datasetsimportload_irisfromlightgbmimportLGBMClassifier,Dataset,trainastrain_lgbmimportmodelifyfrommodelifyimportModelInferencefrommodelify.helpersimportcreate_schema# import datairis=load_iris()df=pd.DataFrame(data=np.c_[iris['data'],iris['target']],columns=iris['feature_names']+['target'])# train test splittrain,test=train_test_split(df,test_size=0.2)y_train=df["target"]X_train=df.drop(columns=["target"])# build your modelclr=LGBMClassifier()clr.fit(X_train,y_train)# deploymentinference=ModelInference(model=model,framework="LIGHTGBM",inputs=create_schema(X_train))modelify.connect("YOUR_API_KEY")modelify.deploy(inference,app_uid="YOUR_APP_UID")
Package: model-import-export
model-import-exportImports and Exports django model to excel and csvRequirementpython >= 3
Django 1.11.5, >= 2.11Installationpip install model-import-exportUsageCreating resourcesIn yourexample_app/resources.pyfrommodel_import_export.resourcesimportModelResource,ForeignKeyResource,ManyToManyResourcefromdashboard.modelsimport*classUserResource(ModelResource):classMeta:model=Userfields='__all__'Exporting modelfrom.resourcesimportUserResourcequeryset=User.objects.all()resource=UserResource(queryset)resource.to_excel('users.xlsx')Importing modelresource=UserResource()resource.from_excel('users.xlsx')Model Import/Export Example
Package: model-index
model-index: maintain a source of truth for ML modelsmodel-indexhas two goals:Make it easy to maintain a source-of-truth index of Machine Learning model metadataEnable the community browse this model metadata onPapers with CodeThe main design principle ofmodel-indexisflexibility. You can store your model metadata however is the
most convenient for you - as JSONs, YAMLs or as annotations inside markdown.model-indexprovides a convenient
way to collect all this metadata into a single file that's browsable, searchable and comparable.You can use this library locally or choose to upload the metadata toPapers with Codeto have your library featured on the website.How it worksThere is a root file for the model index:model-index.ymlthat links to (or contains) metadata.Models:-Name:Inception v3Metadata:FLOPs:5731284192Parameters:23834568Training Data:ImageNetTraining Resources:8x V100 GPUsResults:-Task:Image ClassificationDataset:ImageNetMetrics:Top 1 Accuracy:74.67%Top 5 Accuracy:92.1%Paper:https://arxiv.org/abs/1512.00567v3Code:https://github.com/rwightman/pytorch-image-models/blob/timm/models/inception_v3.py#L442Weights:https://download.pytorch.org/models/inception_v3_google-1a9a5a14.pthREADME:docs/inception-v3-readme.mdAll fields except forNameareoptional. You can add any fields you like, but the ones above have a
standard meaning across different models and libraries.We recommend putting themodel-index.ymlfile in the root of your repository (so that relative links such asdocs/inception-v3-readme.mdare easier to write), but you can also put it anywhere else in the repository (e.g.
in yourdocs/ormodels/folder).Storing metadata in markdown filesMetadata can also be directly stored in a model's README file. For example in thisdocs/rexnet.mdfile:<!--
Type: model-index
Name: RexNet
Metadata: 
  Epochs: 400
  Batch Size: 512
Paper: https://arxiv.org/abs/2007.00992v1
--># SummaryRank Expansion Networks (ReXNets) follow a set of new design 
principles for designing bottlenecks in image classification models.## Usageimport timm
m = timm.create_model('rexnet_100', pretrained=True)
m.eval()In this case, you just need to include this markdown file into the globalmodel-index.ymlfile:Models:-docs/rexnet.mdGet startedCheck out ourofficial documentationon how to get started.Uploading to Papers with CodeTo feature your library on Papers with Code, get in touch withhello@paperswithcode.comand the model index
of your library will be automatically included into Papers with Code.
Package: modelingtools
ModelTools - Work in progress, but what's here should work.A collection of utility model training and statistical tools. These tools intend to solve problems such as:Integrating components of different ML libraries so they can be used togetherAddressing specific shortcomings of specific ML library functionsSimplify common tasks, such as plots for classifier evaluationBayesian AB TestingA convenience wrapper for common Bayesian A/B Testing tasks.Bayesian AB Testing is base on the use of conjugate prior distributions. A description of common conjugate prior relationships can be foundhere.The most common use case is when the metric of interest is a measure of K successes in N trials, such as a click-through-rate. Another common use case is a Poisson proccess (k events per interval) such as signups or api traffic per day.Sample usage:frommodelingtools.testingtoolsimportBayesianABTestingdata={"a_trials":1000,"a_successes":100,"b_trials":2000,"b_successes":201,}ab_test_ctr=BayesianABTesting(likelihood_function="binomial",data=data)result=ab_test_ctr.execute_test(metric="CTR")You can call some static methods to get info:BayesianABTesting.get_likelihood_options()BayesianABTesting.get_required_data_fields()
Package: model-insight
Model-InsightDescriptionModel-insight is a Python third-party library that loads commonly used mathematical modeling data sets and performs modeling processing (such as evaluation problems, simulation problems, etc.).
At the same time, we can also learn the related knowledge of mathematical modeling.InstallingUsepip>>>pip install model-insight==0.4.2Load Datasets>>>from model_insight.load_datasets import load_#Several datasets are availiable:EvaluationBatteryRoller coasterAircraftOptimizationoilswimportfolioChangePopulation of U.S.Shanghai COVID casesPredictionRestaurant salesMead lakeTitanicExplainationAdult salaryMulti-criteria Decision MakingModel-Insight provides some functions to preprocess data, give weights, and do comprehensive evaluation.
For example,>>>from model_insight.mcdm_functions import ahp
>>>judgement_matrix = np.array([[1,2,3],[1/2,1,4],[1/3,1/4,1]])
>>>ahp_weights = ahp(judgement_matrix)
>>>ahp_weights
>>>The Max Eigenvalue is  (3.1078473338549757+0j)
array([0.51713362+0.j, 0.35856042+0.j, 0.12430596+0.j])Welcome to cooperationIf you are interested in this project, you can contact me vialearningmm@163.com.
Package: modelisation
PrésentationCette bibliothèque permet de faire dela modélisation de points expérimentauxtrès simplement en ajoutant seulement deux lignes de code dans votre programme Python.Avec cette bibliothèque, vous pourrez :Afficher la courbe modélisée sur le graphique ainsi que sonéquation.Sélectionner avec le “lasso”, les points expérimentaux à utiliser pour la modélisation.Afficher/masquer unréticuleen appuyant sur la touche “r” du clavier.Afficher/masquer la légende en appuyant sur la touche “m” du clavier.Copier-collerle graphique avec les touches Ctrl+C et Ctrl V.Description plus détailléeInstallationUtilisez le gestionnaire de packagespippour installer.pipinstallmodelisationDépendancesLes bibliothèques suivantes doivent être installées :matplotlibnumpyscypyaddcopyfighandlerUtilisationimportmatplotlib.pyplotaspltimportmodelisationx=[0,1e-3,2e-3,3e-3,4e-3,5e-3,6e-3,7e-3]#  saisir les valeurs expérimentales de la grandeur en abscissey=[0,0.221,0.440,0.665,1.250,1.105,1.327,1.550]#  saisir les valeurs de la grandeur en ordonnéeplt.plot(x,y,color='red',marker='+',linestyle='none')# Afficher les pointsmodelisation.modele("lineaire",x,y)# modèles disponibles : "lineaire", "affine", "parabole", "exp_croissante", "exp_decroissante", "double_affine"plt.show()Auteur© Stéphane LAURENT - 2024Lycée Valin - La Rochelle (17) - France
Package: model-json
Model JsonFeaturesTODORequirementsTODOInstallationYou can installModel JsonviapipfromPyPI:$pipinstallmodel-jsonUsagePlease see theCommand-line Referencefor details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Model Jsonis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: modelkit
modelkitPython framework for production ML systems.modelkitis a minimalist yet powerful MLOps library for Python, built for people who want to deploy ML models to production.It packs several features which make your go-to-production journey a breeze, and ensures that the same exact code will run in production, on your machine, or on data processing pipelines.Quickstartmodelkitprovides a straightforward and consistent way to wrap your prediction  code in aModelclass:frommodelkitimportModelclassMyModel(Model):def_predict(self,item):# This is where your prediction logic goes...returnresultBe sure to check out our tutorials in thedocumentation.FeaturesWrapping your prediction code inmodelkitinstantly gives acces to all features:fastModel predictions can be batched for speed (you define the batching logic) with minimal overhead.composableModels can depend on other models, and evaluate them however you need toextensibleModels can rely on arbitrary supporting configurations files calledassetshosted on local or cloud object storestype-safeModels' inputs and outputs can be validated bypydantic, you get type annotations for your predictions and can catch errors with static type analysis tools during development.asyncModels support async and sync prediction functions.modelkitsupports calling async code from sync code so you don't have to suffer from partially async code.testableModels carry their own unit test cases, and unit testing fixtures are available forpytestfast to deployModels can be served in a single CLI call usingfastapiIn addition, you will find thatmodelkitis:simpleUse pip to installmodelkit, it is just a Python library.robustFollow software development best practices: version and test all your configurations and artifacts.customizableGo beyond off-the-shelf models: custom processing, heuristics, business logic, different frameworks, etc.framework agnosticBring your own framework to the table, and use whatever code or library you want.modelkitis not opinionated about how you build or train your models.organizedVersion and share you ML library and artifacts with others, as a Python package or as a service. Let others use and evaluate your models!fast to codeJust write the prediction logic and that's it. No cumbersome pre or postprocessing logic, branching options, etc... The boilerplate code is minimal and sensible.InstallationInstall the latest stable release withpip:pip install modelkitOptional dependencies are available for remote storage providers (see documentation)modelkit >= 0.1is now be shipped withpydantic 2, bringing significant performance improvements 🎉 ⚡You can refer to themodelkit migration noteto ease the migration process!CommunityJoin ourcommunityon Discord to get support and leave feedbackLocal installContributors, if you want to install and test locally:# install
make setup

# lint & test
make tests
Package: modelldcatnotordf
modelldcatnotordfA small Python library for mapping a modell catalog to rdfThe library contains helper classes for the following modelldcat-ap-no classes:InformationModelThe library will map tothe Norwegian Application Profile.UsageInstall% pip install modelldcatnotordfGetting startedfrom datacatalogtordf import Catalog
from modelldcatnotordf import InformationModel

# Create catalog object
catalog = Catalog()
catalog.identifier = "http://example.com/catalogs/1"
catalog.title = {"en": "A model catalog"}
catalog.publisher = "https://example.com/publishers/1"

# Create a model:
model = InformationModel()
model.identifier = "http://example.com/models/1"
model.description = {"nb": "En adressemodell"}
# ... and further attributes ...
#
# Add model to catalog:
catalog.model.append(model)

# get rdf representation in turtle (default)
rdf = catalog.to_rdf()
print(rdf.decode())DevelopmentRequirementspython3pyenv[pipx] (https://github.com/pipxproject/pipx)poetrynox% pipx install poetry==1.0.5
% pipx install nox==2020.8.22
% pipx inject nox nox-poetryInstall% git clone https://github.com/Informasjonsforvaltning/modelldcatnotordf.git
% cd modelldcatnotordf
% pyenv install 3.8.6
% pyenv install 3.7.9
% pyenv local 3.8.6 3.7.9
% poetry installRun all sessions% noxRun all tests with coverage reporting% nox -rs testsDebuggingYou can enter intoPdbby passing--pdbto pytest:nox -rs tests -- --pdbYou can set breakpoints directly in code by using the functionbreakpoint().