Saravanan666/pypi-org huggingface dataset:
Package: mlpack
mlpack is a fast, flexible machine learning library, written in C++, that aims
to provide fast, extensible implementations of cutting-edge machine learning
algorithms.  mlpack provides these algorithms as standalone Python functions,
which wrap the fast C++ implementations of the algorithms.mlpack's techniques fall into a handful of categories:Classification: logistic regression, perceptrons, random forests, linear
SVMs, AdaBoost, etc.Regression: linear regression, least angle regression, etc.Clustering: Gaussian mixture models, k-means, mean shift, DBSCAN, etc.Geometry: k-nearest-neighbor search, max-kernel search, locality sensitive
hashing (LSH), etc.Preprocessing: dataset splitting, binarization, scaling, one hot encoding,
etc.Misc. / Other: collaborative filtering, density estimation trees, Hidden
Markov Models, kernel density estimation (KDE), etc.Transformations: kernel PCA, sparse coding, large margin nearest neighbors,
PCA, etc.For more documentation on each individual function that mlpack provides, see thePython binding
documentation.
Package: ml-pentest
ML - Pentest | Are malware detector robust?This is a software framework that can be used for the evaluation of the robustness of Malware Detection methods with respect to adversarial attacks. Currently, there is a focus on black-box adversarial attacks on PE malware detector.The high level architecture of the software framework is shown in the following figure.Attacks includedGAMMA, formulated byDemetrio et al., with section injection and API injection manipulations. This implementation of the attack is easily used against any target model by implementing only the specific wrapper. Some code is reused from the open-source repositorysecml-malware.GAMMA V2, introducted in this framework. Is an augmented version of GAMMA that optimize the section injection position, the section characteristics and the section names.Models includedSome of the known malware detectors in the literature have already been included by default within the library.Specifically, the models included include:MalConv(link) in its original formulation. The PyTorch implementation of MalConv was taken fromthisopen source repository.MalConv2(link), an improved version of MalConv that requires less memory and time to train the model. The PyTorch implementation of MalConv was taken fromthisopen source repository. A pre-trained version of the model is available into the library.EMBER Gradient-Boosted Decision Tree (GBDT)(link): a gradient-boosted decision tree that use EMBER features for classification. A pre-trained version of the model on the EMBER dataset (taken fromthis repositoryis available into the library.It should be noted that any requirements needed to run the models must already be available in the software environment used for execution.The library offers support for any type of model upon implementation of a specific wrapper, with no software dependencies statically encoded in the library.Therefore,PyTorchmust be installed to use the MalConv and MalConv2 models,lgbmfor the GBDT model.Any other model can be used after implementing the specific wrapper and installing the necessary dependencies on the used environment.Table of ContentsInstallationLicenseInstallationThe library is tested withPython 3.8. The library can be used with later versions of Python as long as they are compatible withLIEFversion 0.12.0.You can install the library by using the following command.pipinstall-ihttps://test.pypi.org/simple/ml_pentestLicenseThis system uses the GNU General Public License v3.0 (GPL-3.0) to ensure that the software remains open-source and free for everyone to use, modify and distribute. The license allows users to use the system for personal or commercial use, modify the code, and distribute the modified code as long as they maintain the same license. The GPL-3.0 ensures that the system's source code remains open and accessible, fostering a collaborative development environment.
Package: mlpepr
ML-PePR stands for Machine Learning Pentesting for Privacy and Robustness and is a Python library for evaluating machine
learning models. PePR is easily extensible and hackable. PePR’s attack runner allows structured pentesting, and the
report generator produces straightforward privacy and robustness reports (LaTeX/PDF) from the attack results.Caution, we cannot guarantee the correctness of PePR. Always do check the plausibility of your results!InstallationTo install pepr usepip install mlpepr.
Package: mlperceptron
Multilayer Perceptron in PythonPython implementation of multilayer perceptron neural network from scratch.Minimal neural network class with regularization using scipy minimize. Contains clear pydoc for learners to better understand each stage in the neural network.https://github.com/paulokuong/mlperceptronRequirementsPython 3.4 (tested)GoalTo provide an example of a simple MLP for educational purpose.Code samplePredicting outcome of AND logic gate:X = 000, 001, 010, 011, 100, 101, 110, 111y = 0,0,0,0,0,0,1Data we want to predict:
p = 011, 111, 000, 010, 111
Expected results are: 0, 1, 0, 0, 1importnumpyasnpfrommlperceptron.mlperceptronimportNeuralNetworkX=np.matrix('0 0 0;0 0 1;0 1 0;0 1 1;1 0 0;1 0 1;1 1 0;1 1 1')y=np.matrix('0;0;0;0;0;0;0;1')n=NeuralNetwork((5,5,))g=n.train(X,y,0.01,show_cost=True)y_pred=n.predict(np.matrix('0 1 1;1 1 1;0 0 0;0 1 0;1 1 1'),g)print(y_pred)print(n.accuracy(y_pred,np.matrix('0;1;0;0;1')))ContributorsPaulo Kuong (@pkuong)
Package: ml-pilot
msdsf22m002ml_pilotML_Pilot is a python packes that is providing very easy implementation of data wranling task. You just need to call the fuctions and implement your desired functionality like data preprocessing and feature engineering.EDA Packagedata_summary(data_frame)this function gets data frame as argument and return summary of data values present in the datast.null_summary(data_frame)this function gets data frame as argument and return summary of null values present in the datast.null_percent(data_frame,limit)this function returns the feature that contains percentage of null values greater than equal to limit.Feature Engnieeringfeatures_summary(data_frame)this functions return details about numerical features of the dataset like mean,mode,min.. valuesdrop_features(data_frame,features)this function allow us to drop features in the dataset
Package: mlp-image-classifier
TheNeural Network MLPClassifiersoftware package is both a QGIS plugin and stand-alone python package
that provides a supervised classification method for multi-band passive optical remote sensing data.
It uses an MLP (Multi-Layer Perception) Neural Network Classifier and is based on the Neural Network MLPClassifier
by scikit-learn:https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html.The program was originally developed by Lieven P.C. Verbeke (Ghent University, Laboratory of Forest Management and
Spatial Information Techniques). It was written in C++ and ported to PyQGIS in 2019 - 2020. It has been developed in an
open source environment to encourage further development of the tool.Theinstruction pagescan be found at <https://mlp-image-classifier.readthedocs.io>.The coderepositorycan be found athttps://bitbucket.org/kul-reseco/lnns.PLEASE GIVE US CREDITWhen using the Neural Network MLPClassifier, please use the following citation:Crabbé, A. H., Cahy, T., Somers, B., Verbeke, L.P., Van Coillie, F. (2020). Neural Network MLPClassifier(Version x.x) [Software]. Available from https://bitbucket.org/kul-reseco/lnns.ACKNOWLEDGEMENTSThe software and user guide are based on the Linear Neural Network Simulator [C++ software]:
Ghent University, Laboratory of Forest Management and Spatial Information Techniques, Lieven P.C. VerbekeThe revision into a QGIS plugin is funded primarily through BELSPO (the Belgian Science Policy Office) in the framework
of the STEREO III Programme – Project LUMOS - SR/01/321.The LUMOS logo was created for free athttps://logomakr.com.SOFTWARE LICENSEThis program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
License as published by the Free Software Foundation, either version 3 of the License, or any later version.This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.You should have received a copy of the GNU General Public License (COPYING.txt). If not see www.gnu.org/licenses.
Package: mlpipeline
mlpipelineThis is a simple framework to organize you machine learning workflow. It automates most of the basic functionalities such as logging, a framework for testing models and gluing together different steps at different stages. This project came about as a result of me abstracting the boilerplate code and automating different parts of the process.The aim of this simple framework is to consolidate the different sub-problems (such as loading data, model configurations, training process, evaluation process, exporting trained models, etc.) when working/researching with machine learning models. This allows the user to define how the different sub-problems are to be solved using their choice of tools and mlpipeline would handle piecing them together.Core operationsThis framework chains the different operations (sub-problems) depending on the mode it is executed in. mlpipeline currently has 3 modes:TEST mode: When in TEST mode, it doesn't perform any logging or tracking. It creates a temporary empty directory for the experiment to store the artifacts of an experiment in. When developing and testing the different operations, this mode can be used.RUN mode: In this mode, logging and tracking is performed. In addition, for each experiment run (referred to as a experiment version in mlpipeline) a directory is created for artifacts to be stored.EXPORT mode: In this mode, the exporting related operations will be executed instead of the training/evaluation related operations.In addition to providing different modes, the pipeline also supports logging and recording various details. Currently mlpipeline records all logs, metrics and artifacts using a basic log files as well usingmlflow <https://github.com/databricks/mlflow>_.The following information is recorded:The scripts that were executed/imported in relation to an experiment.The any output resultsThe metrics and parametersDocumentationThe documentation is hosted atReadTheDocs <https://mlpipeline.readthedocs.io/>_.InstallingCan be installed directly using the Python Package Index using pip::pip install mlpipelineUsagework in progress
Package: mlpipeline-1
Currently it prepares the data ready for a Machine Learning Classification problem (mainly for now Tabular Dataset). I am soon planning to add other features for Regression problem as well as for Clustering based Problem. My purpose of creating this project is to build an AutoML library, which reduces writing more code to a create a model.
How you can use this is by following the below step:` pip installmlpipeline_1==0.0.7`` from ml_pipeline.pipeline import ml_pipe `Then you need to pass certain parameters to the ml_pipe function, the first one is the “location of the csv file” which you want to do Classification on, second parameter being the “target variable name”, and the last one being the “split size” (value between 0 - 1) i.e., what percent of the whole dataset you want to use as a test set.` X_train, X_test, y_train, y_test = ml_pipe(file_path, target_var, split_ratio) `The output of the above function you can pass to any Classification model for training.Soon planning to coming up with more and more features. Planning to make this a full-fledged AutoML library.Change Log0.0.7 (18/02/2022)This is my Seventh Release of the project with some changes solving some errors from the previous version and updating the readme file for better clarity for the users on how to use this.
Package: ml-pipelines-sdk
ML Pipelines SDKTheml-pipelines-sdkpackage provides the pipeline-authoring SDK for theTFXmachine learning framework. This package is
a subset of thetfxpackage and is provided for TFX pipeline authors who wish
to minimize runtime dependencies.Releases are synchronized in lock-step with thetfxpackageand overall release notes
can be found athttps://github.com/tensorflow/tfx/releases.
Package: mlpj
mlpj: Tools for machine learning projectsInstallation of thePyPi package:pip install -U mlpjContents of this repository:Utilities and convenience functions for various libraries and purposes:python_utils: for the Python standard libraryfunctions for basic datatypesfunctions for filepaths and temporary filesfunctions on input and output streamsfunctions for printing to the consoledate functionsnumpy_utils: fornumpypandas_utils: forpandasfunctions to handle dataframe columns and their namesfunctions to handle undefined valuesother dataframe convenience functions (e.g. for special cases)fast groupby transform of multiple columnsfunctions to describe the contents of dataframes and seriesmany datetime convenience functionse.g. add missing days to a multi-indexstats_utils: for statistical modelingnegative-binomial (Gamma-Poisson) distributions and overdispersion
estimationplot_utils: formatplotlibhistogramsprofile plotstimeseries_utils: for timeseries modelsml_utils: forsklearnand other standard machine
learning librariestypes (Protocols) for sklearn estimators and transformersFind an enclosed estimator or transformer within a meta-estimator.functions to print analyses of certain kinds of trained modelsmeta-estimators and meta-transformersproject_utils: project management utilitiesactions_looper: Execute selected parts of your
program based on persisted results of earlier steps. Together with the
functionality mentioned below, this is meant as an alternative to Jupyter
notebooks that integrates more seamlessly with reuse of code and
test-driven development (TDD) while still being fairly interactive.result_display: Collect textual and numerical
results and plots on HTML pages.
Package: mlpkg
ML PackageA Package through which multiple things can be done in a go like fitting a model of your own choice (regression/classification) and get final results in terms of model accuracy/ score/ mse/ mae/ confusion matrix and direct submission file which we need to upload in case of competitions.Two things can be achieved from this package:Results after fitting any Regression/classification algorithm of your own choice. Function to be used -train_modelFinal submission file to be submitted directly in competitions. Function to be used -return_csvRequirements:sklearnnumpypandasPre-processed data to be passed - data already cleaned, splitted into train and testIntrain_modelfunction, parameters to be passed:x_train, y_train, x_test, y_testmodel objectregression=True(if addressing regression problem)regression=False(if addressing classification problem (default is True))Inreturn_csvfunction, parameters to be passed:x_train, y_train, x_test, y_testmodel objectsample submission file(dataframe)target column name(string)file location name(filepath where to be saved)Installation & UsageMake sure that your pip version is up-to-date: pip install --upgrade pip. Check version with pip -V.Select the correct package:There are two packages (two versions of the package )and you should SELECT ONLY ONE OF THEM which is the latest one.Install usingpip install mlpkgwith latest versionImport the package and use its functions:from ML_Utility import ML_package
Package: mlplot
mlplotMachine learning evaluation plots usingmatplotlibandsklearn.Installpip install mlplotML Plot runs with python 3.5 and above! (using format strings and type annotations)ContributingCreate a PR!PlotsWork was inspired bysklearn model evaluation.ClassificationROC with AUC numberfrom mlplot.evaluation import ClassificationEvaluation
eval = ClassificationEvaluation(y_true, y_pred, class_names, model_name)
eval.roc_curve()https://github.com/sbarton272/mlplot/blob/master/tests/output/tests.evaluation.test_classification.test_calibration.png?raw=trueCalibrationfrom mlplot.evaluation import ClassificationEvaluation
eval = ClassificationEvaluation(y_true, y_pred, class_names, model_name)
eval.calibration()Precision-Recallfrom mlplot.evaluation import ClassificationEvaluation
eval = ClassificationEvaluation(y_true, y_pred, class_names, model_name)
eval.precision_recall(x_axis='recall')
eval.precision_recall(x_axis='thresold')Distributionfrom mlplot.evaluation import ClassificationEvaluation
eval = ClassificationEvaluation(y_true, y_pred, class_names, model_name)
eval.distribution()Confusion Matrixfrom mlplot.evaluation import ClassificationEvaluation
eval = ClassificationEvaluation(y_true, y_pred, class_names, model_name)
eval.confusion_matrix(threshold=0.5)Classification Reportfrom mlplot.evaluation import ClassificationEvaluation
eval = ClassificationEvaluation(y_true, y_pred, class_names, model_name)
eval.report_table()RegressionScatter Plotfrom mlplot.evaluation import RegressionEvaluation
eval = RegressionEvaluation(y_true, y_pred, class_names, model_name)
eval.scatter()Residuals Plotfrom mlplot.evaluation import RegressionEvaluation
eval = RegressionEvaluation(y_true, y_pred, class_names, model_name)
eval.residuals()Residuals Histogramfrom mlplot.evaluation import RegressionEvaluation
eval = RegressionEvaluation(y_true, y_pred, class_names, model_name)
eval.residuals_histogram()Regression Reportfrom mlplot.evaluation import RegressionEvaluation
eval = RegressionEvaluation(y_true, y_pred, class_names, model_name)
eval.report_table()ForecastsTBDRankingsTBDDevelopmentPublish to pypipython setup.py sdist bdist_wheel
twine upload --repository-url https://upload.pypi.org/legacy/ dist/*DesignBasic interface thoughtsfrom mlplot.evaluation import ClassificationEvaluation
from mlplot.evaluation import RegressorEvaluation
from mlplot.evaluation import MultiClassificationEvaluation
from mlplot.evaluation import MultiRegressorEvaluation
from mlplot.evaluation import ModelComparison
from mlplot.feature_evaluation import *

eval = ClassificationEvaluation(y_true, y_pred)
ax = eval.roc_curve()
auc = eval.auc_score()
f1_score = eval.f1_score()
ax = eval.confusion_matrix(threshold=0.7)ModelEvaluation base classClassificationEvaluation classtake in y_true, y_pred, class names, model_nameRegressorEvaluation classMultiClassificationEvaluation classModelComparisontakes in two evaluations of the same typeTODOFix distribution plot, make linesAdd legend with R2 to regression plotsAdd tests for regression comparisonSplit apart files for comparison classesAdd comparisons to README
Package: mlp-mixer
MLP Mixer PytorchPytorch implementation ofMLP-Mixer.Sample usagefoo@bar:❯ pip install mlp_mixerfrommlp_mixerimportMLPMixermodel=MLPMixer(img_size=IMG_SZ,img_channels=IMG_CHANNELS,num_classes=NUM_CLASSES,mixer_depth=DEPTH,num_patches=NUM_PATCHES,num_channels=NUM_CHANNELS,expansion=EXPANSION,dropout=DROPOUT,)Citations@misc{tolstikhin2021mlpmixer,title={MLP-Mixer: An all-MLP Architecture for Vision},author={Ilya Tolstikhin and Neil Houlsby and Alexander Kolesnikov and Lucas Beyer and Xiaohua Zhai and Thomas Unterthiner and Jessica Yung and Daniel Keysers and Jakob Uszkoreit and Mario Lucic and Alexey Dosovitskiy},year={2021},eprint={2105.01601},archivePrefix={arXiv},primaryClass={cs.CV}}
Package: mlp-mixer-keras
MLP-Mixer in KerasThis is a simple keras implementation of MLP-Mixer. MLP-Mixer is an almost exclusivly multi-layer perceptions approach to vision like tasks.Install$pipinstallmlp-mixer-kerasExample usagefrommlp_mixer_kerasimportMlpMixerModelimportnumpyasnp(x_train,y_train),(x_test,y_test)=tf.keras.datasets.cifar10.load_data()model=MlpMixerModel(input_shape=x_train.shape[1:],num_classes=len(np.unique(y_train)),num_blocks=4,patch_size=8,hidden_dim=32,tokens_mlp_dim=64,channels_mlp_dim=128,use_softmax=True)model.compile(loss='sparse_categorical_crossentropy',metrics='acc')model.fit(x_train,y_train,validation_data=(x_test,y_test))ReferencesMLP-Mixer: An all-MLP Architecture for VisionIlya Tolstikhin, Neil Houlsby, Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Thomas Unterthiner, Jessica Yung, Daniel Keysers, Jakob Uszkoreit, Mario Lucic, Alexey Dosovitskiy,MLP-Mixer: An all-MLP Architecture for Vision@misc{tolstikhin2021mlpmixer,title={MLP-Mixer: An all-MLP Architecture for Vision},author={Ilya Tolstikhin and Neil Houlsby and Alexander Kolesnikov and Lucas Beyer and Xiaohua Zhai and Thomas Unterthiner and Jessica Yung and Daniel Keysers and Jakob Uszkoreit and Mario Lucic and Alexey Dosovitskiy},year={2021},eprint={2105.01601},archivePrefix={arXiv},primaryClass={cs.CV}}MLP-Mixer: An all-MLP Architecture for Vision (Machine Learning Research Paper Explained)Excellent Yannic Kilcher explainervideo.MLP Mixer - PytorchA pytorch implementation of MLP-Mixer. This repo helped a alot as I learned the ways of making a nice github repo for a project.Phil Wang -lucidrainsMLP Mixer - Pytorch
Package: mlpractice
MLpracticeMLpractice 🚀 is a course, in which you will learn about the most effective machine learning techniques, and gain practice implementing them.DocumentationSee theMLpractice Docsfor full documentation on course task functions.Quick StartInstallPipPip install it in aPython>=3.7.0environment.pipinstallmlpracticeInitMake a course folder with tasks by simply runningmlpracticeinitContactFor MLpractice bugs and feature requests please visitGitHub Issues.
Package: ml-pretrained
ML Pretrained$pipinstallml-pretrained# Try out the RWKV model. This requires the `tokenizers` package.$pipinstalltokenizers
$python-mpretrained.rwkv430m'Scientists recently discovered an island populated entirely by cats. To their astonishment, none of the cats were hungry. Upon further investigation,'Scientistsrecentlydiscoveredanislandpopulatedentirelybycats.Totheirastonishment,noneofthecatswerehungry.Uponfurtherinvestigation,infact,researchersdiscoveredthattheyweremembersofanancestral,livingspecies.Whenthisresearchwaspublishedin2009inthejournalCurrentBiology,therewaswidespreadpraisefortheirresearch.

Sowhatdowemakeofthecurrentunderstandingofwhathappenstotheseamazingcreatureswhentheynolongerexistonacoldplanet?Muchoftheliteratureonthematterseemstoconcludethatthere’snohopeofcomingtogripswiththisquestion,thateverythingweknowaboutthisspecies,orevenanyofthenon-humanspeciesthatmaybeoutthereinspace,issimplyahuman’soranimal’sinvention.# Try out the Tacotron2 model. This requires the `sounddevice`, `inflect` and `ftfy` packages.$pipinstallsounddeviceinflectftfy
$python-mpretrained.tacotron2'Scientists recently discovered an island populated entirely by cats. To their astonishment, none of the cats were hungry.'# Chain these together.$python-mpretrained.tacotron2"$(python-mpretrained.rwkv430m'Scientists recently discovered an island populated entirely by cats. To their surprise,'--tsz64)"What is this?This is a collection of pre-trained model implementations, which can be used in down-stream packages.GoalThe goal of this repository is to make it as easy as possible to try out a pre-trained model, and eventually incorporate it into a new project. To that end, each implementation is a self-contained file, so that you can just copy-paste it wholesale into whatever project your using or use it directly without adding a bunch of dependencies. Additionally, the implementations use high-quality, modern Python syntax to be as easy to follow as possible.This also includes some custom Triton kernels for certain operations which may benefit from GPU acceleration.LicenseNote that while this particular code is MIT licensed, but that does not mean that all of the model weights are. You should comply with the upstream licenses for models that you use.