Saravanan666/pypi-org huggingface dataset:
Package: mlm8s
mlm8smiscellaneous for machine-learning in TensorFlowpip install keras_tuner
pip install mlm8sImports:from mlm8s import ListedPaths, paths2labels, strings2onehot, paths2label_dicts, map_via_dict
from mlm8s import GeneratorDataset, HyperModel, connect
from mlm8s import standardize, normalize, stretch, rotate_deg, flatten, correlate
from mlm8s import create_meshgrid, span_polar_basis
from mlm8s import group_unique
from mlm8s import print_plot_play
from mlm8s import get_sampling_matrix, soft_threshold, deadzone_l1_loss, lasso_l1, norm_l0, huber_loss
from mlm8s import lipschitz_grad_lasso, nesterov_momentum, ista_prox_lasso, fistaLabels from Paths:from mlm8s import ListedPaths, paths2label_dicts, map_via_dict

### read PATH2DATA and (onehot-)encode by file-containing folder:

paths = ListedPaths(PATH2DATA)*'ogg'
label_dict = paths2label_dicts(paths(), seperators=['/', '.'], indices=[-2, 0])
labels = map_via_dict(paths2labels(paths()), label_dict)Class - GeneratorDataset:Enables alternating results of tf.random* -calls, from within
the generator of tf.data.Dataset.from_generator*.kwargs = dict()
kwargs['paths'] = paths
kwargs['label_dict'] = label_dict
kwargs['seperators'] = ['/', '.']
kwargs['indices'] = [-2, 0]

### Feature-Engineering with generator, that can use random variables!!
def engineer_features(paths):
    # use data in path to engineer features
    features = tf.random.uniform(shape=[32, 256, 256, 4])
    return features

kwargs['engineer_features'] = engineer_features

### Creating Features & Labels:
def generate_from_paths(batch_size=1024, **kwargs):
    paths = kwargs['paths']
    seperators = kwargs['seperators']
    indices = kwargs['indices']
    engineer_features = kwargs['engineer_features']
    label_dict = kwargs['label_dict']
    rdm_paths = paths.get_rdm(batch_size)
    features = engineer_features(rdm_paths)
    labels = paths2labels(rdm_paths, seperators, indices)
    labels = map_via_dict(labels, label_dict)
    return features, labels

### Creating tf.data.Dataset, that can generate an infinite number of random batches
###                           from 'generate_from_paths'.
ds = GeneratorDataset(generate_from_paths, batch_size=128, epochs=16, **kwargs)()

for batch in ds.take(1):
    x, y = batch
    print(x.shape, y.shape)
Package: mlmc
MLMCMLMC provides tools for the multilevel Monte Carlo method.mlmc package includes:samples schedulingestimation of generalized moment functionsprobability density function approximationadvanced post-processing with Quantity structureIt is meant as part of theGeoMopproject in particular Analysis component.InstallationPackage can be installed via pip.pip install mlmcDocumentationYou can find the documentation including tutorials underhttps://mlmc.readthedocs.io/DevelopmentProvided that you want to contribute, create a pull request and make sure you runtoxbefore. Tox
installs necessary requirements as well as the developed package itself into clear virtual environment
and call pytest to search in thetestfolder for tests to execute.RequirementsNumPySciPyh5pyattrsruamel.yamlgstoolsmemoizationsklearnLicenceFree software: GPL 3.0  License
Package: ml-metadata
ML MetadataML Metadata (MLMD)is a library for recording and retrieving metadata
associated with ML developer and data scientist workflows.NOTE: ML Metadata may be backwards incompatible before version 1.0.Getting StartedFor more background on MLMD and instructions on using it, see thegetting started guideInstalling from PyPIThe recommended way to install ML Metadata is to use thePyPI package:pipinstallml-metadataThen import the relevant packages:fromml_metadataimportmetadata_storefromml_metadata.protoimportmetadata_store_pb2Nightly PackagesML Metadata (MLMD) also hosts nightly packages athttps://pypi-nightly.tensorflow.orgon Google Cloud. To install the latest
nightly package, please use the following command:pipinstall--extra-index-urlhttps://pypi-nightly.tensorflow.org/simpleml-metadataInstalling with DockerThis is the recommended way to build ML Metadata under Linux, and is
continuously tested at Google.Please first installdockeranddocker-composeby following the directions:docker;docker-compose.Then, run the following at the project root:DOCKER_SERVICE=manylinux-python${PY_VERSION}sudodocker-composebuild${DOCKER_SERVICE}sudodocker-composerun${DOCKER_SERVICE}wherePY_VERSIONis one of{38, 39}.A wheel will be produced underdist/, and installed as follows:pipinstalldist/*.whlInstalling from source1. PrerequisitesTo compile and use ML Metadata, you need to set up some prerequisites.Install BazelIf Bazel is not installed on your system, install it now by followingthese
directions.Install cmakeIf cmake is not installed on your system, install it now by followingthese
directions.2. Clone ML Metadata repositorygitclonehttps://github.com/google/ml-metadatacdml-metadataNote that these instructions will install the latest master branch of ML
Metadata. If you want to install a specific branch (such as a release branch),
pass-b <branchname>to thegit clonecommand.3. Build the pip packageML Metadata uses Bazel to build the pip package from source:pythonsetup.pybdist_wheelYou can find the generated.whlfile in thedistsubdirectory.4. Install the pip packagepipinstalldist/*.whl5.(Optional) Build the grpc serverML Metadata uses Bazel to build the c++ binary from source:bazelbuild-copt--definegrpc_no_ares=true//ml_metadata/metadata_store:metadata_store_serverSupported platformsMLMD is built and tested on the following 64-bit operating systems:macOS 10.14.6 (Mojave) or later.Ubuntu 16.04 or later.Windows 7 or later.
Package: mlmicrophysics
mlmicrophysicsMachine learning emulators for microphysical processes in CESM.RequirementsThe library has been tested with Python 3.6.
The mlmicrophysics library requires the following Python libraries:numpyscipymatplotlibscikit-learntensorflowkeraspandasxarraypyyamlnetcdf4You can install the dependencies using conda or pip depending on your local
Python installation. In order to compile the fortran code within the library,
you will need gfortran on your system.InstallationTo install and compile the library, run the following command:gitclonehttps://github.com/NCAR/mlmicrophysics.gitcdmlmicrophysics
pipinstall.RunningTo train a new microphysics neural network emulator, you will first need to process
the CESM CAM output files using thescripts/process_cesm_output.pyscript. The
process script converts the CAM netCDF files to a set of csv files and filters
out non-cloud grid cells. The script requires a yaml config file. Seeconfig/cesm_tau_run5_full_process.ymlfor
an example. To run the processing script:cd~/mlmicrophysics/scripts
python-uprocess_cesm_output.py../config/cesm_tau_run5_full_process.yml-p5>&tau_run5_process.logOnce the data are processed, you can train a set of neural network emulators withscripts/train_mp_neural_nets.py.
This script pre-processes the training and validation data, trains a set of neural networks
and saves them and their verification statistics to an output directory.ContactIf you have issues with the library, please create an issue on the github page.
General questions can be sent to David John Gagne atdgagne@ucar.edu.
Package: ml-mixins
ML MixinsInstallationthis package can be installed viapip:pip install ml-mixinsThenfrom mixins import SeedableMixin
...DescriptionUseful Python Mixins for ML. These are python mixin classes that can be used to add useful bits of discrete
functionality to python objects for use in ML / data science. They currently include:SeedableMixinwhich adds nice seeding capabilities, including functions to seed various stages of
computation in a manner that is both random but also reproducible from a global seed, as well as to store
seeds used at various times so that a subsection of the computation can be reproduced exactly during
debugging outside of the rest of the computation flow.TimeableMixinadds functionality for timing sections of code.SaveableMixinadds customizable save/load functionality (using pickle)SwapcacheableMixin. This one is a bit more niche. It adds a "swapcache" to the class, which allows
one to store various iterations of parameters keyed by an arbitrary python object with an equality
operator, with a notion of a "current" setting whose values are then exposed as main class attributes.
The intended use-case is for data processing classes, where it may be desirable to try different
preprocesisng settings, have the object retain derived data for those settings, but present a
front-facing interface that looks like it is only computing a single setting. For example, if running
tfidf under different stopwords and ngram settings, one can run the system via the swapcache under
settings A, and the class can present an interface of[obj].stop_words,obj.ngram_range,obj.tfidf_vectorized_data, but then this can be transparently updated to a different setting without
discarding that data via the swapcache interface.TQDMableMixin. This one adds a_tqdmmethod to a class which automatically progressbar-ifies ranges
for iteration, unless the range is sufficiently short or the class hasself.tqdmset toNoneNone of these are guaranteed to work or be useful at this point.
Package: mlmmapi
interaction-graderPython package to help grade test questions (interactions) using trained machine learning models.The Answer class can be used to check if an answer is basically identical to the desired answer except
for misspellings.Initial version hard codes a model already trained to recognize actor names from a list of 322.# Example usagefrommlmmapiimportcheck_answercorrect_answer='Joaquim Phoenix'answer='Joakim Pheonix'correct,prediction,score=check_answer(answer,correct_answer)ifcorrect:print('Correct Answer')else:print('Prediction:{}- score:{}'.format(prediction,score))Package Dependencies:fuzzywuzzypython-LevenshteinnumpypandassklearnxgboostjoblibBuild Package:Setup a virtual environmentInsure you have python3.x instaledpython3 -m venv envsource env/bin/activateInstall all packages listed in the dependenciespip3 install <...>pip3 install .Test the code above in the example in python3Check pypi.org for the lastest version of the mlmmapi packageupdate the setup.py to have the next version number to push to pypiCommit the latest setup.py to the repoBuild the packagepython3 setup.py sdistUpload the packageInstall the twine packagepip3 install twineUpload the packagetwine upload dist/*
Package: mlmmj_archiver
mlmmj-archiver==============mlmmj-archiver is a wrapper around hypermail to manage the HTML archive generation of mlmmj-based mailing lists. It uses a YAML configuration file to describe the lists and their options.This script was inspired by Martin Leopold's update-archive.sh script. You can his version on his [webpage](http://www.leopold.dk/~martin/mlmmj-scripts.html).You can get support or request new features at the following [site](https://admin.modernbiztonsag.org/redmine/projects/mlmmj-archiver).Installation------------### Package ###easy_install mlmmj_archiver### Source ###Get it from [github](https://github.com/ScOut3R/mlmmj-archiver).Configuration syntax--------------------list-name:archive: /path/to/archive/dirlist: /path/to/list/diroptions:ordering: threadthreadlevels: 100index: monthlyoutput:- showrepliesAll the options are optional. The supported output options are shown above, further options will be added soon.Usage-----mlmmj_archiver.py [-h] [-c CONFIG] [-x] [-p]optional arguments:-h, --help            show this help message and exit-c CONFIG, --config CONFIGuse alternate config file (default: /etc/mlmmj-archiver/config.yml)-x, --overwrite       overwrite archives-p, --progress        show progress
Package: mlmnemonist
ML-Mnemonist is an open-source lightweight framework for simple ML operations and it pairs up easily with free online cloud services that do not support session backup and recovery because the framework implements these in the hardware level. To that end, some of the tutorials here are purposefully created to work with Google Colab.
<p align=”center”>
<img src=”/figures/logo.png”/>
</p>Check out more information on the GitHub <a href=”https://github.com/HamidrezaKmK/ML-Mnemonist”>repository</a>.Change Log0.1.0 (20.11.2022)Tutorial 2 is finalizedCode for hyper experiment runners is refactoredNow we are able to adjoint single experiments with hyper experiment runnersEach experiment will create outputs under the hyper experiment directoryThe hyper experiment directory will output all the experiment output scores
in a json.0.0.15 (19.7.2022)Internal functionalities of Experiment Runner changedCreating new experiments with the same name overwrites the previous
experiment with the same name rather than creating new onesThe caching scheme for meta parameters had a bug which is fixedThe Tutorial is finalized0.0.14 (19.7.2022)Add exception handler to hyper experiments for conflicting configs0.0.13 (01.7.2022)Bug removal in configurations of the factoryBug removal in readme0.0.12 (01.7.2022)Biggest update yet!Introduce HyperExperiments!When retrieving using factory, the pipelines will also be handledCaching system updated, META_DATA cache added0.0.11 (01.7.2022)Grid search can now continue on the runner’s last interrupt0.0.10 (01.7.2022)With preprocess added to gridsearchmerge_cfg added to ExperimentRunner0.0.9 (01.7.2022)Grid search bug removalImplement two types of grid search: one using a palette config and another using a directory
containing all the config filesRetrieve added to ExperimentRunnerFactoryUpdated naming scheme for experiments such that each experiment has a description file and
their name contains the date of today0.0.8 (01.7.2022)Bug removal in validation tools0.0.7 (01.7.2022)Add expand_cfg for hyperparameter tuningAdd gridsearch for hyperparameter tuningChange cache token scheme0.0.6 (29.6.2022)Bug removal in CACHE.RESET() where directories are included in the logsRunner pipeline cloning option addedpreprocess does keep the pipeline by default0.0.5 (24.6.2022)Add reload_cfg before each call of runner.runAdd reload_cfg before each call of runner.preprocessAdd runner.export_logs() method to get a zip file from all
logfiles in the experiment directory0.0.4 (23.6.2022)Add more logs for verbose runnersAdd CACHE.LOGS_DIR to save logs such as tensorboardAdd maximum cache limit that can be manipulated using mlm.MAX_CACHE_SIZE0.0.3 (23.6.2022)README updatedfull support without configurationssecret_root added to factory and reveal_true_path0.0.2 (23.6.2022)Bug removal of some initial problems with the setup0.0.1 (23.6.2022)First release
Package: ml-model-quality-analysis
Quality Analysis for Machine Learning modelsThe three quality pillars are:Functionality:groups analyses that evaluate how ”well“ an AI module performs a
given task (i.e. assessing the suitability of an AI module for an application domain).Comprehensibility:groups analyses that try to open the blackbox and enable
stakeholders (model producers, users, or regulators) to interpret decisions and the
decision-making process.Robustness:groups analyses that assess how the ML component responds to small
changes in the input.The latest release performs functionality and robustness analyses for image classification
and regression models. The next versions will include comprehensibility analysis and accept text data.InstallationUsing the PyPi package:pip install ml-model-quality-analysisNotable DependenciesTensorFlow 2.3 is required:pip install tensorflow==2.3Getting StartedFor examples on performing quality analysis for ML models, see theQuality Report Notebook.
Package: ml-models
pypi url :: [https://pypi.org/project/ml-models/]
This repository is stacked with the multiple ml models looped over certain times,The User can install the ml_models and use the project as shown in driver package.The data needs to be concise and at last you'll have a table generated over different ml models with different evaluation technique. With this you can directly check the model to use for.from ml_models import *
from ml_models.build_model import build_table

random_forest_classifier= RandomForestClassifier(n_estimators= 10, criterion="entropy")  

# for decision Tree
# Create Decision Tree classifer object
decision_tree = DecisionTreeClassifier()


nn = MLPClassifier(solver='lbfgs', alpha=1e-5,
                     hidden_layer_sizes=(1), random_state=1)



if __name__ == '__main__':
       # reading the csv file
    df = pd.read_csv("data.csv")
    X = df.iloc[:, :-1] # Features
    y = df.iloc[:, -1] # Target variable

    li_df = []
    for i in range(0,10):
        li_df.append(build_table(X,y,[decision_tree,"Decision Tree",False],
                                [nn, "Artificial Neural Network",True]))

    averages = pd.concat([each.stack() for each in li_df],axis=1)\
                .apply(lambda x:x.mean(),axis=1)\
                .unstack()
    print(averages)
Package: mlmorph
This is python interface for theMalayalam morphology analyser - mlmorph.InstallationPython 3 is required. Using withvenvis recommended$pipinstallmlmorphUsageMorphological analysis examplefrommlmorphimportAnalyseranalyser=Analyser()analyser.analyse("കേരളത്തിന്റെ")Gives[('കേരളം<np><genitive>',179)]The second item in this result is the weight. Sometimes a single word can have multiple analysis. The analysis with less weight is the preferred analysis.Morphological generator examplefrommlmorphimportGeneratorgenerator=Generator()generator.generate("കേരളം<np><genitive>")Gives(('കേരളത്തിന്റെ',0.0),)Command line interface$python-mmlmorph--helpusage: __main__.py [-h] [-i INFILE] [-a] [-g] [-v]

optional arguments:
  -h, --help            show this help message and exit
  -i INFILE, --input INFILE
                        source of analysis data
  -a, --analyse         Analyse the input file strings
  -g, --generate        Generate the input file strings
  -v, --verbose         print verbosely while processingAccepts strings from stdin too. For example:$python-mmlmorph-aനിറങ്ങൾ
നിറങ്ങൾ   നിറം<n><pl>
Package: mlmorph-spellchecker
This is a Spellchecker for Malayalam language based onMalayalam morphology analyser - mlmorph.InstallationPython 3 is required. Using withvenvis recommended$pipinstallmlmorph_spellcheckerUsagefrommlmorph_spellcheckerimportSpellCheckerspellchecker=SpellChecker()ifspellchecker.spellcheck(word)isTrue:print('%s✔️'%(word))else:print('%s❌ Suggestions:%s'%(word,spellchecker.candidates(word)))Command line interface$python-mmlmorph_spellchecker--helpusage: __main__.py [-h] word

positional arguments:
word        word to spellcheck

optional arguments:
-h, --help  show this help message and exit
Package: ml-mosaic
#MOSAIC Models for AI comparatorMosaic is a framework dedicated to the comparison of AI models. It is often very
difficult to choose the best AI model for a specific problematic and multiple o
ptions are available, including choices over the model hyper-parameters. It is t
empting to try different options and to compare them to get the best performance
/resource ratio. But this kind of test can be pretty time consuming from the dev
elopper point of vue. The Mosaic framework eases the automation of the program g
eneration and provides tools to help the study (Database, plot system…)Mosaic is a python framework based on Pytorch. From a simple configuration file,
a set of pipelines is generated including all the steps of the data treatment (
data loading, formatting, normalization, post-treatment…) and the model training
itself. The framework executes all these pipelines in a parallel way and store
all the results in a database and in differents files. Some facility are offered
to pause/resume and monitor the run. A plot module helps getting some compact a
nd graphical representations to ease the interpretation of this data.
Package: mlmprovisions
mlmprovisionsReusable Django app, that allows you to track provisions
for your affiliate partners. It has a flexible way of configuring how to
split the provision and is capable of runningmulti-level marketingScreenshotsInstalationpipinstallmlmprovisionsThen add required appssettings.pyINSTALLED_APPS=[...'treenode','mlmtools','floppyforms',...]Add to theurls.pypath('mlmtools/',include('mlmtools.urls'))And sync the dbpythonmanage.pymakemigrations
pythonmanage.pymigrateConfiguration and usageUsing the admin interface add marketer nodes and tracking codes for them.
We suggest adding 1 central node and several subnodesFields:Owner- the user this note is associated toSplit type- how to split the provisionfixed- this node takes a fixed percentage*tree split- MultiLevel split. This split is how much is sent up the treeSplit cut- the slider how much we keep and how much we pass to the child nodesCan have children- whether the subnodes can create subnodes (MLM needs this)track code usage- how many times can the code be used (limitless/only once for all/only once per user)To add attribution you have these methodsfrommlmtools.modelsimportTrackCode,CodeUsestr_code="CFHUMJ"#tells if this code can be usedCodeUse.test_use(str_code,client_user)#tells if this code can be used#lets have something like an order (the track code uses generic relation)dt=DummyTarget(name="my order target 2",amount=1000.0)dt.save()#and attach the codeCodeUse.use(str_code,client_user,target=dt,amount=dt.amount)And finaly you can check how it looks by visitinghttp://<yoursite>/mlmtools/list_codes/ENJOY!
Package: mlmpy
mlmThis is the repository for my Machine Learning Project Manager.
This application is divided into two parts. The C++ code, and the Python code. The C++ code is
the heart of the manager, it is self suficient and necessary for all the procceses required
for the project manager. On the other hand the Python package mlmpy inside the python_manager folder
is an API that facilitates the use of mlm through python, this way you don't have to leave your notebook or
python script. mlmpy does not work at all without the C++ package.PrerequisitesC++ >= 17
Boost >= 1.69
scikit-learn>=0.20.3
python>=3.7Who do I talk to?Pol Monroig