Saravanan666/pypi-org huggingface dataset:
Package: mlpro
MLPro - The Integrative Middleware Framework for Standardized Machine Learning in PythonMLPro provides complete, standardized, and reusable functionalities to support your scientific research, educational tasks or industrial projects in machine learning.Key Featuresa) Open, modular and extensible architectureOverarching software infrastructure (mathematics, data management and plotting, UI framework, logging, ...)Fundamental ML classes for adaptive models and their training and hyperparameter tuningb) MLPro-RL: Sub-Package for Reinforcement LearningPowerful Environment templates for simulation, training and real operationTemplates for single-agents, model-based agents (MBRL) with action planning to multi-agents (MARL)Advanced training/tuning funktionalities with separate evaluation and progress detectionGrowing pool of reuseable environments of automation and roboticsc) MLPro-GT: Sub-Package for Native Game Theory and Dynamic GamesTemplates for native game theory regardless number of players and type of gamesTemplates for multi-players in dynamic games, including game boards, players, and many moreReuse of advanced training/tuning classes and multi-agent environments of sub-package MLPro-RLd) Numerous executable self study examplese) Integration of established 3rd party packagesMLPro provides wrapper classes for:Environments of OpenAI Gym and PettingZooPolicy Algorithms of Stable Baselines 3Hyperparameter tuning with HyperoptDocumentationThe Documentation is available here:https://mlpro.readthedocs.io/DevelopmentConsequent object-oriented design and programming (OOD/OOP)Quality assurance by test-driven developmentHosted and managed on GitHubAgile CI/CD approach with automated test and deploymentClean code paradigmaProject and TeamProject MLPro was started in 2021 by theGroup for Automation Technology and Learning Systems at the South Westphalia University of Applied Sciences, Germany.MLPro is designed and developed byDetlef Arend,Steve Yuwono,M Rizky Diprasetya, and furthercontributors.How to contributeIf you want to contribute, please readCONTRIBUTING.md
Package: mlprodict
mlprodictmlprodictwas initially started to help implementing converters
toONNX. The main features is a python runtime forONNX(classOnnxInference),
visualization tools
(seeVisualization),
and anumpy API for ONNX).
The package also provides tools to compare
predictions, to benchmark models converted withsklearn-onnx.import numpy
from sklearn.linear_model import LinearRegression
from sklearn.datasets import load_iris
from mlprodict.onnxrt import OnnxInference
from mlprodict.onnxrt.validate.validate_difference import measure_relative_difference
from mlprodict import __max_supported_opset__, get_ir_version

iris = load_iris()
X = iris.data[:, :2]
y = iris.target
lr = LinearRegression()
lr.fit(X, y)

# Predictions with scikit-learn.
expected = lr.predict(X[:5])
print(expected)

# Conversion into ONNX.
from mlprodict.onnx_conv import to_onnx
model_onnx = to_onnx(lr, X.astype(numpy.float32),
                     black_op={'LinearRegressor'},
                     target_opset=__max_supported_opset__)
print("ONNX:", str(model_onnx)[:200] + "\n...")

# Predictions with onnxruntime
model_onnx.ir_version = get_ir_version(__max_supported_opset__)
oinf = OnnxInference(model_onnx, runtime='onnxruntime1')
ypred = oinf.run({'X': X[:5].astype(numpy.float32)})
print("ONNX output:", ypred)

# Measuring the maximum difference.
print("max abs diff:", measure_relative_difference(expected, ypred['variable']))

# And the python runtime
oinf = OnnxInference(model_onnx, runtime='python')
ypred = oinf.run({'X': X[:5].astype(numpy.float32)},
                 verbose=1, fLOG=print)
print("ONNX output:", ypred)InstallationInstallation frompipshould work unless you need the latest
development features.pip install mlprodictThe package includes a runtime forONNX. That’s why there
is a limited number of dependencies. However, some features
relies onsklearn-onnx,onnxruntime,scikit-learn.
They can be installed with the following instructions:pip install mlprodict[all]The code is available atGitHub/mlprodictand hasonline documentation.
Package: mlpro-int-gymnasium
MLPro-Int-Gymnasium - Integration between Gymnasium and MLProWelcome to MLPro-Int-Gymnasium, an extension to MLPro to integrate the Gymnasium package. MLPro is a middleware framework for standardized machine learning in Python. It is developed by the South Westphalia University of Applied Sciences, Germany, and provides standards, templates, and processes for hybrid machine learning applications. Gymnasium, in turn, provides a diverse suite of reinforcement learning environments.MLPro-Int-Gymnasium offers wrapper classes that allow the reuse of environments from Gymnasium in MLPro, or the other way around.Learn moreMLPro - Machine Learning ProfessionalMLPro-Int-Gymnasium - Integration of Gymnasium into MLProGymnasium - An API standard for reinforcement learning with a diverse collection of reference environments
Package: mlpro-int-hyperopt
MLPro-Int-Hyperopt - Integration of Hyperopt into MLProWelcome to MLPro-Int-Hyperopt, an extension to MLPro to integrate the Hyperopt package. MLPro is a middleware framework for standardized machine learning in Python. It is developed by the South Westphalia University of Applied Sciences, Germany, and provides standards, templates, and processes for hybrid machine learning applications. Hyperopt, in turn, provides state-of-the-art algorithms for hyperparameter search and optimization.MLPro-Int-Hyperopt provides wrapper classes that enable the use of selected Hyperopt functionalities in your MLPro applications. The use of these wrappers is illustrated in numerous example programs.Learn moreMLPro - Machine Learning ProfessionalMLPro-Int-Hyperopt - Integration of Hyperopt into MLProHyperopt: Distributed Asynchronous Hyper-parameter Optimization
Package: mlpro-int-openml
MLPro-Int-OpenML - Integration of OpenML into MLProWelcome to MLPro-Int-OpenML, an extension to MLPro to integrate the OpenML package.
MLPro is a middleware framework for standardized machine learning in Python. It is
developed by the South Westphalia University of Applied Sciences, Germany, and provides
standards, templates, and processes for hybrid machine learning applications. OpenML, in turn,
provides a vast amount of sample datasets, combined with a benchmark systematics to
enable a standardized assessment of ML algorithms.MLPro-Int-OpenML provides wrapper classes that enable the use of OpenML datasets in your
MLPro applications. The use of these wrappers is illustrated in example programs.Learn moreMLPro - Machine Learning ProfessionalMLPro-Int-OpenML - Integration of OpenML into MLProOpenML - A worldwide machine learning lab
Package: mlpro-int-optuna
MLPro-Int-Optuna - Integration of Optuna into MLProWelcome to MLPro-Int-Optuna, an extension to MLPro to integrate the Hyperopt package. MLPro is a middleware framework for standardized machine learning in Python. It is developed by the South Westphalia University of Applied Sciences, Germany, and provides standards, templates, and processes for hybrid machine learning applications. Optuna, in turn, provides state-of-the-art algorithms for hyperparameter search and optimization.MLPro-Int-Optuna provides wrapper classes that enable the use of selected Optuna functionalities in your MLPro applications. The use of these wrappers is illustrated in numerous example programs.Learn moreMLPro - Machine Learning ProfessionalMLPro-Int-Optuna - Integration of Optuna into MLProOptuna: Open Source Hyperparameter optimizmation framework
Package: mlpro-int-pettingzoo
MLPro-Int-PettingZoo - Integration between PettingZoo and MLProWelcome to MLPro-Int-PettingZoo, an extension to MLPro to integrate the PettingZoo package. MLPro is a middleware framework for standardized machine learning in Python. It is developed by the South Westphalia University of Applied Sciences, Germany, and provides standards, templates, and processes for hybrid machine learning applications. PettingZoo, in turn, provides a diverse suite of environments for multi-agent reinforcement learning.MLPro-Int-PettingZoo offers wrapper classes that allow the reuse of environments from PettingZoo in MLPro, or the other way around.Learn moreMLPro - Machine Learning ProfessionalMLPro-Int-PettingZoo - Integration of PettingZoo into MLProPettingZoo - An API standard for multi-agent reinforcement learning
Package: mlpro-int-river
MLPro-Int-River - Integration of River into MLProWelcome to MLPro-Int-River, an extension to MLPro to integrate the River package. MLPro is a middleware framework for standardized machine learning in Python. It is developed by the South Westphalia University of Applied Sciences, Germany, and provides standards, templates, and processes for hybrid machine learning applications. River, in turn, provides numerous state-of-the-art algorithms for several topics of online machine learning.MLPro-Int-River provides wrapper classes that enable the use of selected River functionalities in your MLPro applications. The use of these wrappers is illustrated in numerous example programs.Learn moreMLPro - Machine Learning ProfessionalMLPro-Int-River - Integration of River into MLProRiver - Online machine learning in Python
Package: mlpro-int-scikit-learn
MLPro-Int-scikit-learn - Integration of scikit-learn into MLProWelcome to MLPro-Int-scikit-learn, an extension to MLPro to integrate the scikit-learn package. MLPro is a middleware framework for standardized machine learning in Python. It is developed by the South Westphalia University of Applied Sciences, Germany, and provides standards, templates, and processes for hybrid machine learning applications. Scikit-learn, in turn, provides numerous state-of-the-art algorithms for a vast amount of machine learning topics.MLPro-Int-scikit-learn provides wrapper classes that enable the use of scikit-learn algorithms and data streams in your MLPro applications. The use of these wrappers is illustrated in various example programs.Learn moreMLPro - Machine Learning ProfessionalMLPro-Int-scikit-learn - Integration of scikit-learn into MLProscikit-learn - Machine Learning in Python
Package: mlproj-manager
# ML Project ManagerThe intent of this project is to provide a quick and easy to use framework to run machine learning experiments in a
systematic way, while keeping track of all the important details that are necessary for reproducibility.## Installation
This project is uploaded to the Python Package Index, so you can simply run the following command:python3 -m pip install mlproj_manager## Usage
Here is a quick list of steps to create and run a new experiment:1. Write a python script with a class that is a child of theExperimentabstract class in./mlproj_manager/experiments/abstract_experiment.py. See./examples/non_stationary_cifar_examplefor an example.
2. Register the experiment using the commandpython -m mlproj_manager.experiments.register_experimentwith the arguments–experiment-namefollowed by a named of your choosing,–experiment-pathfollowed by the path to the script
created in step 1, and–experiment-class-namefollowed by the name of the class defined in the script created in
step 1.
3. Create aconfig.jsonfile for your experiment that contains all the relevant details for running the experiment.
See./examples/non_stationary_cifar_example/config_files/backprop.jsonfor an example.
4. Finally, run the experiment using the commandpython -m mlproj_manager.mainwith the arguments–experiment-namefollowed by the experiment name used in step 2,–experiment-config-pathfollowed by the path to the config file
created in step 3,–use-slurm(optional) to indicate whether to schedule the experiment using slurm, and–slurm-config-path(required only if using slurm) followed by the path to a similar file as the one created for step
3 but with parameters relevant to the slurm scheduler.
Package: mlprovlab
MLProvLabMLProvLab: Provenance Management for Data Science NotebooksMLProvLab is a JupyterLab extension to track, manage, compare, and visualize the provenance of machine learning notebooks.
It can track, at runtime, the datasets, variables, libraries, and functions used in the notebook and their dependencies between cells.
It provides users the facility to compare different runs of computational experiments, thereby ensuring a way to help them make their decisions.
The tool helps researchers and data scientists to collect more information on their experimentation and interact with them.This extension is composed of a Python package namedmlprovlabfor the server extension and a NPM package namedmlprovlabfor the frontend extension.RequirementsJupyterLab >= 3.0InstallpipinstallmlprovlabTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment 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 mlprovlab directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Rebuild extension Typescript source after making changesjlpmrunbuildYou 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 neededjlpmrunwatch# 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 run 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=FalseUninstallpipuninstallmlprovlab
Package: mlp-tracking
REQUIREMENTSpip install mlp_trackingUSAGE EXAMPLEfrommlp_trackingimportMlpTracker,PipeType,IssueModuleimportos# initializetracker=MlpTracker(pipe_type=PipeType.FAQ_PREDIC_PIPE.value,issue_module=IssueModule.ML.value,# you may get kafka_servers from environmentskafka_servers=os.environ.get('KAFKA_SERVERS',''),kafka_username=os.environ.get('KAFKA_USERNAME',''),kafka_password=os.environ.get('KAFKA_PASSWORD',''),)# send eventtracker.send(message='predict error',reason='model not found',)
Package: ml-py
ML py is python package that have many classes and function usefull for machine learnining projects. I’ve developed this project while I was working on diffrent machine learining projects.Getting Startedml_py.image.ImagePreprocessorInstallingLicenseMIT LicenseCopyright (c) 2018 Mitiku YohannesPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: mlpylint
mlpylintA static code analyzer tool for identifying ml-specific code smells.DescriptionMLpylint is a static code analyzer designed specifically for Python applications. Drawing from extensive research in the
field of ML-specific code smells, MLpylint focuses on identifying ML-specific issues in your code. This assists in
enhancing the readability, maintainability, and efficiency of your ML codebase, ensuring it adheres to best practices in
the field of artificial intelligence and machine learning software development.Getting startedThe project structure is organized into three main components:Code Smell Checkers: These are the core of our tool, designed to identify specific code smells in your Python scripts.Test Scripts: Each code smell checker comes with an associated test script. These are used to validate the functionality of each checker, ensuring it correctly identifies its corresponding code smell.Code Smell Test Files: These are Python scripts that contain examples of code smells. They serve as practical test cases for the code smell checkers, helping to ensure that the checkers are accurately identifying the intended code smells.This organization allows for easy identification of different aspects of the tool, facilitating testing, extension, and maintenance.Installationcd mlpylint
py -m venv venv
source venv/Scripts/activate
pip install -e .[dev]Update PyPI Package=== Token required from PyPI ===
Create .pypirc file in C:\Users\<user_name> with pypi token parameters

=== In project root dir ===
py -m pip install --upgrade pip
py -m pip install --upgrade build
py -m build
py -m pip install --upgrade twine
py -m twine upload dist/*Usage$ mlpylint --help                          # View tool options
$ mlpylint <path>                          # Check for code smells (CS)
$ mlpylint -a,  --advice <path>            # Check for code smells (CS) and include advisory results (CSA)
$ mlpylint -ls, --list-smells              # List all available code smells
$ mlpylint -ds, --describe-smell <id>      # Get code smell description by id
$ mlpylint -c,  --color <path>             # Enable colorized analysis outputAnalysis assumptions:Imports and ImportFrom are done at the top of the .py file. It is considered a best practice to put all import
statements at the top of a Python file. This makes it easier to read and understand the dependencies of the file, and
can help prevent issues with circular imports.AuthorPeter Hamfelt - [peter.hamfelt@gmail.com,pehd16@student.bth.se]AcknowledgementsThis work is inspired by and built upon the research conducted by the following individuals:Haiyin Zhang from AI for Fintech Research, ING, Amsterdam, Netherlands.Luís Cruz from Delft University of Technology, Delft, Netherlands.Arie van Deursen from Delft University of Technology, Delft, Netherlands.Their contribution towards identifying and categorizing "Code Smells for Machine Learning Applications" has played a
crucial role in the development of this tool. I would like to express my deepest gratitude for their pioneering work
in this field.Research link:https://arxiv.org/abs/2203.13746LicenseMIT License
Package: ml-python
MLThis module provides for the easiest way to implement Machine Learning algorithms. It also has in-built support for graphing and optimizers based in C.Learn the module here:YouTubeBlog PostExamplesThis module uses a tensorflow backend.Implemented Algorithms2D CNNml.cnnBasic MLPml.nnK-Meansml.k_meansLinear Regressionml.linear_regressionoptimized with CLogistic Regressionml.logistic_regressionGraph Modulesml.graphGraph any function with or without data points -from ml.graph import graph_function, graph_function_and_dataNonlinear Regressionml.regressionOptimizers -ml.optimizeroptimized with CGradientDescentOptimizer -from ml.optimizer import GradientDescentOptimizerAdamOptimizer -from ml.optimizer import AdamOptimizerUNSTABLE- Character generating RNN -ml.rnnYou can find examples for all of these in/examplesPip installationpipinstallml-pythonPython installationgitclonehttps://github.com/vivek3141/mlcdml
pythonsetup.pyinstallBash Installationgitclonehttps://github.com/vivek3141/mlcdml
sudomakeinstallExamplesExamples for all implemented structures can be found in/examples.In this example, linear regression is used.First, import the required modules.importnumpyasnpfromml.linear_regressionimportLinearRegressionThen make the required objectl=LinearRegression()This code below randomly generates 50 data points from 0 to 10 for us to run linear regression on.# Randomly generating the data and converting the list to intx=np.array(list(map(int,10*np.random.random(50))))y=np.array(list(map(int,10*np.random.random(50))))Lastly, train it. Setgraph=Trueto visualize the dataset and the model.l.fit(data=x,labels=y,graph=True)The full code can be found in/examples/linear_regression.pyMakefileA Makefile is included for easy installation.To install using make runsudomakeNote: Superuser privileges are only required if python is installed at/usr/local/libLicenseAll code is available under theMIT LicenseContributingPull requests are always welcome, so feel free to create one. Please follow the pull request template, so
your intention and additions are clear.ContactFeel free to contact me by:Email:vivnps.verma@gmail.comGitHub Issue:create issue
Package: ml-pyxis
ml-pyxisTool for reading and writing datasets of tensors (numpy.ndarray) with
MessagePack and Lightning Memory-Mapped Database (LMDB).Exampleimportnumpyasnpimportpyxisaspx# Create datanb_samples=10X=np.ones((nb_samples,2,2),dtype=np.float32)y=np.arange(nb_samples,dtype=np.uint8)# Writedb=px.Writer(dirpath='data',map_size_limit=1)db.put_samples('input',X,'target',y)db.close()# Readdb=px.Reader(dirpath='data')sample=db[0]db.close()print(sample){'input':array([[1.,1.],[1.,1.]],dtype=float32),'target':array(0,dtype=uint8)}More examples can be found in theexamples/directory.InstallationThe installation instructions are generic and should work on most operating
systems that support the prerequisites.ml-pyxisrequires Python version 2.7, 3.4, 3.5, or 3.6. We recommend
installingml-pyxis, as well as all prerequisites, in a virtual environment
viavirtualenv.PrerequisitesThe following Python packages are required to useml-pyxis:lmdb- Universal Python binding for theLMDB ‘Lightning’ Databasemsgpack-MessagePackimplementation for Python (binary serialisation)NumPy- N-dimensional array object and tools for operating on themsix- A Python 2 and 3 compatibility libraryPlease refer to the individual packages for more information about additional
dependencies and how to install them for your operating system.Bleeding-edge installationTo install the latest version ofml-pyxis, use the following command:pipinstall--upgradehttps://github.com/vicolab/ml-pyxis/archive/master.zipAdd the--usertag if you want to install the package in your home
directory.NoticeThe previous LMDB-only API has been deprecated in favour of a combination
between LMDB and msgpack. The old version can be installed by using the
following commit hash with pip:pipinstall--upgradegit+git://github.com/vicolab/ml-pyxis.git@787c3484e3121f2767b254fc41be091d0a3e0cf0Development installationml-pyxiscan be installed from source in such a way that any changes to
your local copy will take effect without having to reinstall the package.
Start by making a copy of the repository:gitclonehttps://github.com/vicolab/ml-pyxis.gitNext, enter the directory and installml-pyxisin development mode by
issuing the following command:cdml-pyxispythonsetup.pydevelop