Saravanan666/pypi-org huggingface dataset:
Package: evogression
EvogressionEvogression is a Python package providing an evolutionary algorithm to develop a regression function for a target parameter.  An arbitrary number of input parameters can be used, and data samples need not have all parameters populated to be used in training the regression.As of version 0.7.0, the core calculations are rewritten in Rust for much improved performance (~10x) compared to the previous Cython design.QuickstartUse pip to install Evogressionpip install evogressionFormat your input data as a list of dictionaries.Run the following to generate a regression function and then output this function as a python module:import evogression

evolution = evogression.Evolution('target_variable_key', data, num_creatures=10000, num_cycles=10)
evolution.output_regression()At this point, there will be a "regression_function.py" file within a newly-created "regression_modules" directory.  The "regression" function within this Python module can be imported and used with a dictionary of inputs to generate an estimated output value.Current FeaturesThe goal of the evolution algorithm is to generate a group of "creatures" (each a unique regression function) which then compete to most accurately model the training data.  Creatures are saved when they are better at modeling results than their peers, and a survival-of-the-fittest situation emerges.  Creatures mutate individually and with other creatures to search for better solutions.groups.py provides high-level approaches to regression by running multiple evolution groups.Parameter pruning algorithm can determine the most useful attributes in a dataset and progressively discard the least useful data while determining a best fit equation for the target attribute.TestingBrute force generation of creatures successfully models linear and parabolic 2D data.Evolution algorithm successfully models linear and parabolic 2D data.Evolution algorithm successfully uses a surface to approximate 3D data using two input attributes; this illustrates how multivariate relationships can be modeled.  While the case of two inputs is visualized below, any number of input attributes can be used to build a regression function.A "Population" can develop separate prediction models for data separated into different categories.LicenseMIT
Package: evogrid
Componentized Machine Learning system whose design is mainly based onEvolutionary Computation ideas, especially Memetic Computing: building blocksare ``Replicators`` that evolve in a potentially networked environment.The goal of EvoGrid is to provide a pluggable framework (based on the ZopeComponent Architecture) and reuse as much as possible existing ML algorithmsimplementations (either in Python or other language as long as the can bewrapped into a pythonic component).The project is currently at an early development stage providing onlyimplementation for base evolutionary components (not GRID / networking supportyet).For more details of what is included and what is planned, please refer to thelaunchpad project page at https://launchpad.net/products/evogrid .To get started with evogrid, please read the HTML rendered doctests published onthe homepage and especially the main tutorial at:http://champiland.homelinux.net/evogrid/doc/components_overview.html
Package: evohome-rf
evohome_rfIt does three things:
a) convert the RF packets in useful JSON
b) builds a picture (schema, config & state) of an evohome-compatible system - either passively (by eavesdropping), or actively (probing)
c) allows you to send commands to evohomeIt provides services tohttps://github.com/zxdavb/evohome_cc, a Home Assistant integrationIt requires a USB-to-RF device, either a Honeywell HGI80 (rare, expensive) or something runningevofw3, such as the one fromhere.Installationgit clone https://github.com/zxdavb/evohome_rf
cd evohome_rf
pip install -r requirements.txtYou may want to clean up/create a virtual environment somewhere along the way, something like:deactivate
rm -rf venv
python -m venv venv
. venv/bin/activate
pip install --upgrade pipInstructionspython client.py monitor /dev/ttyUSB0Be sure to have a look at-o packet_log.outand-p(probe).
Package: evoke
The evoke module allows you to create evoke apps, which are twisted web-server-applications which:use twisted webserver (optionally proxied via apache) to serve the datause mysql for data storage, and present the data to you as python objectsproduce HTML output via evoke’s own “evo” templatingrequirementspython3 (tested on 3.6.2)linux (should work on BSD and MacOS also - but not yet tested)mysqlcautionEvoke is a stable system, which has been in production use for commercial mission-critical systems since its inception in 2001.However, python packaging and automated install are a recent (October 2017) work in progress, and some manual configuration is currently required. (see the file README.md )
Package: evoke-signals
Overviewevoke enables users to recreate signalling game simulations from the academic literature.It comprises a library of methods fromevolutionary game theoryevoke/src/and an ever-growing collection ofuser-friendly examplesevoke/examples/.Online tutorialSee the interactive tutorial onGoogle Colab.InstallationInstall with pip:pip install evoke_signals.Basic usageTo create one of the example figures, simply import the relevant class and create an instance of it:from evoke.examples.skyrms2010signals import Skyrms2010_1_1
fig1_1 = Skyrms2010_1_1()Certain figures allow you to specify your own parameters:from evoke.examples.skyrms2010signals import Skyrms2010_3_3
fig3_3 = Skyrms2010_3_3(iterations=1000)See theexamples/directory for a collection of available figures.
Package: evokity
EvokityCollection of essentialEvolutionary Computaion Kitutilities.DevelopmentRequirespoetryinstalled (tested withv1.2.2).Install the dependencies:poetryinstallSpawn a shell within the project's environment:poetry shellUnit TestsTo run the unit-tests, use:pytest
pytest -s // To show captured stdout.FormattingTo run formatting, use:black evokity tests
Package: evok-ws-client
evok-ws-clientA simple wrapper/library for a client using websockets to connect toEvok APIrunning on Unipi devices.
The library was implemented primarily to be used with home-assistant but hopefully it might find also other usage as well.Functionality wise it supports bare minimum so that my home-assitent project can function.Exampleimport asyncio
from evok_ws_client import *

ip_addr = "192.168.77.21"

async def main():
    neuron = UnipiEvokWsClient(ip_addr, "M203", "test_neuron")
    try:
        await neuron.evok_connect()
        await neuron.evok_full_state_sync()
        print (await neuron.evok_receive())
    except:
        pass

if __name__ == "__main__":
    asyncio.run(main())LicenseMIT License
Package: evolly
Evollyis anevolutionaryneural architecture searchframework designed to make running evolution as flexible as possible.Learn details of the Evolly's pipeline in ourTowards Data Science post.What does Evolly do?Evolly allows you to:Boost metrics of your deep learning modelby tuning backbone
architectureSearch for new backbone architecturesby finding optimal types,
order of the blocks and optimizing block parameters (kernel sizes, strides, filters and dropouts).You can apply it with to any Deep Learning task:
classification, detection, segmentation, pose estimation, GAN, etc.FeaturesWe've added following features to make it possible to implement Evolly
in any training pipeline:Build models using common DL frameworks (tensorflow, torch)Set multiple branches (stems) of different data typesDefine custom backbone depth and widthPass custom architecture blocksChoose parameters to mutateCustomize allowed values and intervals of the mutationsRun training in distributed or parallel modeMonitor evolution via TensorBoardEstimate search space sizeVisualize evolutionGetting startedTo launch evolution with Evolly:Make sure you have tensorflow >= 2.3 and torch >= 1.9.0 installedInstall Evolly via pip:pip install evollyFollowMaking your first evolutionguideImprovementsWe are open to any help. Check outour ideas hereto learn how we can upgrade Evolly together:Test default PyTorch blocksAdd new data typesAdd new default blocksUtilizemutation rateand add mutation probabilitiesImplement reinforcement learningUpgrade branch connectionsImplement ability to build multiple branches with torchReferencesEvoPose2D: genotype storing approach and MobileNetV2 block implementationInception_ResNet_v2block implementationResNetblock implementationContactsContact us if you are interested in collaborating or ready to invest
in us:revisorteam@pm.me
Package: evolocity
Evolocity implements evolutionary velocity (evo-velocity), which models a protein sequence landscape as an evolutionary “vector field” by using the local evolutionary predictions enabled by language models to enable global evolutionary insight.Evo-velocity uses the change in languge model likelihoods to estimate directionality between two biological sequences.
Then, over an entire sequence similarity network, this procedure is used to direct network edges.
Finally, network diffusion analysis can identify roots, order sequences in pseudotime, and identify mutations driving the velocity.Evolocity is a fork of thescVelotool for RNA velocity and relies on many aspects of theScanpylibrary for high-dimensional biological data analysis.
Like Scanpy and scVelo, evolocity makes use ofanndata, an extremely convenient way to store and organize biological data.Quick StartInstallationYou should be able to install evolocity usingpip:python -m pip install evolocityAPI exampleBelow is a quick Python example of using evolocity to load and analyze sequences in a FASTA file.importevolocityasevoimportscanpyassc# Load sequences and compute language model embeddings.fasta_fname='data.fasta'adata=evo.pp.featurize_fasta(fasta_fname)# Construct sequence similarity network.evo.pp.neighbors(adata)# Run evolocity analysis.evo.tl.velocity_graph(adata)# Embed network and velocities in two-dimensions and plot.sc.tl.umap(adata)evo.tl.velocity_embedding(adata)evo.pl.velocity_embedding_grid(adata)evo.pl.velocity_embedding_stream(adata)
Package: evolutionary-algorithm
evolutionary_algorithmevolutionary-algorithmis a Python library adapted fromhttps://pypi.org/project/geneticalgorithm/with modifications for streamlining the fine-tuning of predictive models.Random-search parameter optimization tends to be extremely sample-inefficient. This library attempts to address this sample efficiency issue by intelligently moving through parameter spaces to discover (locally or globally) optimimal solutions. Noteworthy improvements over existing Python implementations are the ability to pass a dictionary as input to the objective function, as well as a structured dictionary as the final output. The algorithm also handles categorical (Boolean and multilabel) data in a manner similar to Hyperopt (https://github.com/hyperopt/hyperopt).InstallationThe recommended installation process makes use ofpip(orpip3):pip install evolutionary-algorithmA minimal exampleAn ideal use case is passing a list of parameters and parameter bounds directly to ascikit-learnmodel, unpacking the paramters as model arguments within the objective function, and receiving a set of fine-tuned parameters as a result, which can be unpacked directly for downstream usage.# Dependencies
from evolutionary_algorithm import EvolutionaryAlgorithm as ea
from sklearn.linear_model import SGDClassifier
from sklearn import datasets
from sklearn.metrics import accuracy_score

# Sample dataset
X, y = datasets.load_iris(return_X_y=True, as_frame=False)

# Declare objective function parameters and bounds
objective_parameters = [
    {'name' : 'average',
     'bounds' : [0, 1],
     'type' : 'bool'},
    {'name' : 'alpha',
     'bounds' : [1e-5, 1e-1],
     'type' : 'float'},
    {'name' : 'loss',   
     'bounds' : ['hinge', 'log', 'squared_hinge', 'modified_huber', 'perceptron'],
     'type' : 'cat'},
    {'name' : 'penalty',
     'bounds' : ['l1', 'l2', 'elasticnet'], 
     'type' : 'cat'},
    {'name' : 'l1_ratio',
     'bounds' : [0, 1],
     'type' : 'float'}
]

# Define the objective function (with embedded predictive model)
def objective_function(args):

    clf = SGDClassifier(**args)
    clf.fit(X, y)
    preds = clf.predict(X)

    return accuracy_score(y, preds) * -1 # Expects a value to be minimized

# Create instance of EA object
evo_algo = ea(function=objective_function, 
           parameters=objective_parameters)

# Run EA
evo_algo.run()

# Access best model parameters
evo_algo.best_parameters
Package: evolutionary-forest
Evolutionary ForestAn open source python library for automated feature engineering based on Genetic ProgrammingFree software: BSD licenseDocumentation:https://evolutionary-forest.readthedocs.io.IntroductionFeature engineering is a long-standing issue that has plagued machine learning practitioners for many years. Deep learning techniques have significantly reduced the need for manual feature engineering in recent years. However, a critical issue is that the features discovered by deep learning methods are difficult to interpret.In the domain of interpretable machine learning, genetic programming has demonstrated to be a promising method for automated feature construction, as it can improve the performance of traditional machine learning systems while maintaining similar interpretability. Nonetheless, such a potent method is rarely mentioned by practitioners. We believe that the main reason for this phenomenon is that there is still a lack of a mature package that can automatically build features based on the genetic programming algorithm. As a result, we propose this package with the goal of providing a powerful feature construction tool for enhancing existing state-of-the-art machine learning algorithms, particularly decision-tree based algorithms.FeaturesA powerful feature construction tool for generating interpretable machine learning features.A reliable machine learning model has powerful performance on the small dataset.InstallationFrom PyPI:pipinstall-Uevolutionary_forestFrom GitHub (Latest Code):pipinstallgit+https://github.com/hengzhe-zhang/EvolutionaryForest.gitSupported AlgorithmsEvolutionary Forest (TEVC 2021)SR-Forest (TEVC 2023)ExampleAn example of usage:X,y=load_diabetes(return_X_y=True)x_train,x_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=0)r=EvolutionaryForestRegressor(max_height=3,normalize=True,select='AutomaticLexicase',gene_num=10,boost_size=100,n_gen=20,n_pop=200,cross_pb=1,base_learner='Random-DT',verbose=True)r.fit(x_train,y_train)print(r2_score(y_test,r.predict(x_test)))An example of improvements brought about by constructed features:TutorialsHere are some nodebook examples of using Evolutionary Forest:Regression on Diabetes DatasetDocumentationTutorial:English Version|中文版本CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.CitationPlease cite our paper if you find it helpful :)@article{zhang2021evolutionary,
  title={An Evolutionary Forest for Regression},
  author={Zhang, Hengzhe and Zhou, Aimin and Zhang, Hu},
  journal={IEEE Transactions on Evolutionary Computation},
  volume={26},
  number={4},
  pages={735--749},
  year={2021},
  publisher={IEEE}
}

@article{zhang2023sr,
  title={SR-Forest: A Genetic Programming based Heterogeneous Ensemble Learning Method},
  author={Zhang, Hengzhe and Zhou, Aimin and Chen, Qi and Xue, Bing and Zhang, Mengjie},
  journal={IEEE Transactions on Evolutionary Computation},
  year={2023},
  publisher={IEEE}
}History0.1.0 (2021-05-22)First release on PyPI.
Package: evolutionary-keras
evolutionary_kerasKeras is one of the most widely used Machine Learning frameworks available in the market. It is a high-level API written in Python and that can run on mulitple backends. Their goal is to be able to build and test new model as fast as possible.Keras models are trained through the usage of optimizers, all of which are Gradient Descent based. This module deals with that shortcoming of Keras by implementing several Evolutionary Algorithms on top of Keras while keeping the main philosophy of the project: it must be easy to prototype.The default project library now provides support for:Nodal Genetical Algorithm (NGA)Covariance Matrix Adaptation Evolution Strategy (CMA-ES)Installationevolutionary_keras is available to install from pip and conda using the following commands:pipinstallevolutionary-kerascondainstallevolutionary_keras-cconda-forgeAfter which it can readily be imported in your python projectimportevolutionary_keras
Package: evolutionary-optimization
Evolutionary-OptimizationA generic evolutionary algorithm for function optimization.IntroductionThis package allows the user to optimise a function using an evolutionary algorithm.
Anevolutionary algorithmuses the principles of evolution to find optimal solutions.Using the PackageGetting StartedTo get started with this package install this package:pipinstallevolutionary_optimizationRunning ExperimentsTo run the code type the following in your terminal. The default experiment is a
simple optimization of the $x^{2}$ using integers.run_evolutionThe parameters used for the run can be edited within the main.py file.Personalising ExperimentsTo personalise your experiment you can either use the prebuilt phenotypes and genotypes using our interface,
or you can build your own.
To do so, you simply need to create a new phenotype / genotype class that
inherits from the corresponding abstract class and implement the methods to suit your needs.
Package: evolutionary-optimization-algorithm
Evolutionary-OptimizationA generic evolutionary algorithm for function optimization.IntroductionThis package allows the user to optimise a function using an evolutionary algorithm.
Anevolutionary algorithmuses the principles of evolution to find optimal solutions.Using the PackageGetting StartedTo get started with this package install this package:pipinstallevolutionary-optimization-algorithmRunning ExperimentsTo run the code type the following in your terminal. The default experiment is a
simple optimization of the $x^{2}$ using integers.run_evolutionThe parameters used for the run can be edited within the main.py file.Personalising ExperimentsTo personalise your experiment you can either use the prebuilt phenotypes and genotypes using our interface,
or you can build your own.
To do so, you simply need to create a new phenotype / genotype class that
inherits from the corresponding abstract class and implement the methods to suit your needs.
You can mimic the structure of the main script to run your own experiments, like so:genotype_class=Genotype.get_genotype(Genotypes.<your_phenotype>)phenotype_class=Phenotype.get_phenotype(Phenotypes.<your_genotype>)fitness_function_class=FitnessFunction.get_fitness_function(FitnessFunctions.<your_fitness_function>)fitness_function_instance=fitness_function_class()evolutionary_algorithm=Evolution(phenotype=phenotype_class(genotype_class()),number_of_individuals=<desired_number_of_individuals>,number_of_generations=<desired_number_of_generations>,fitness_function=fitness_function_instance,ratio_of_elite_individuals=<desired_elitism_ratio>)You can also plot your fitness over time and the phenotype over time:evolutionary_algorithm.plot_fitness_score_over_time()phenotype_function_points_tuple=generate_points_for_function(phenotype=evolutionary_algorithm.population.best_individual,bottom_plotting_limit=-10,upper_plotting_limit=10,number_of_points=100,)evolutionary_algorithm.plot_phenotype_function_and_best_individuals(phenotype_function_points_tuple)or plot a gif of the algorithm over time:evolutionary_algorithm.create_gif(phenotype_function_points_tuple)
Package: evolution-opt
DescriptionThis package is a Python aims at providing a range of nature-inspired optimisation algorithms.
The purpose of an optimisation algorithm is to find the maximum or minimum of a function.Genetic algorithms are particularly useful when it comes tohigh-dimensional, non-linear and non-convex problems(e.g. finding a needle in a 10-dimensional hay).
They have a wide range of application from supply chain optimisation to hyperparameter tuning.
This first version includes an implementation of genetic algorithm with "regularized evolution".Genetic algorithms are very useful in machine learning, especially inhyperparameter tuning.
The example folder contains two examples of genetic algorithms used to:Optimise the architecture and hyperparameters of a Neural Network (link)Tune the hyperparameters of a Support Vector Machine and XGBoost model (link)The full documentation can be foundhere.InstallationThis package can be installed with "pip" or by cloning this repository$ pip install evolution_optDependenciesTo install and run evolution_opt make sure that you have installed the following packages$ pip install numpy pandas scipy matplotlibImporting evolution_optimportnumpyasnpimportpandasaspdfromevolution_opt.geneticimport*Example Usage1) Define a function to be optimisedThis function has to take a dictionary of parameter as argument:defdifficult_problem(param_dict):result=param_dict['x']**2+(param_dict['y']+1)**2ifparam_dict['luck']=='lucky':passelse:result+=10returnresultThis function could beany processthat takes parameters as input and outputs a scalar value.It could evaluate a model's cross-validation score based on given hyperparameter values,
a profit/cost function, the efficiency of a resourcing plan... The possibilities are limitless.2) Define a search spacesearch_space=[Integer(-100,100,'x'),Real(-100,100,'y'),Categorical(['lucky','unlucky'],'luck')]The search space can be composed of Integer, Real and Categorical variables.
Numeric parameters are initialised with a lower bound, upper bound and a parameter name.
Categorical parameters require a list of possible values and a parameter name.3) Run the evolutionary algorithmbest_params=optimise(difficult_problem,search_space,minimize=True,population_size=20,n_rounds=500)# Prints:# Number of Iterations: 500# Best score: 0.00410559779230605# Best parameters: {'x': -0.0, 'y': -1.0640749388786759, 'luck': 'lucky'}CreditsIcon featured in the logo: Icon made byFreepikfromwww.flaticon.comRegularized Evolution Algorithm inspiration: Saltori, Cristiano, et al."Regularized Evolutionary Algorithm for Dynamic Neural Topology Search."International Conference on Image Analysis and Processing. Springer, Cham, 2019.