Metadata-Version: 1.1
Name: deap
Version: 1.2.2
Summary: Distributed Evolutionary Algorithms in Python
Home-page: https://www.github.com/deap
Author: deap Development Team
Author-email: deap-users@googlegroups.com
License: LGPL
Description: DEAP

        ====

        

        `Build status <https://travis-ci.org/DEAP/deap>`__

        `Download <https://pypi.python.org/pypi/deap>`__ `Join the chat at

        https://gitter.im/DEAP/deap <https://gitter.im/DEAP/deap?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge>`__

        

        DEAP is a novel evolutionary computation framework for rapid prototyping

        and testing of ideas. It seeks to make algorithms explicit and data

        structures transparent. It works in perfect harmony with parallelisation

        mechanism such as multiprocessing and `SCOOP <http://pyscoop.org>`__.

        

        DEAP includes the following features:

        

        -  Genetic algorithm using any imaginable representation

        

           -  List, Array, Set, Dictionary, Tree, Numpy Array, etc.

        

        -  Genetic programing using prefix trees

        

           -  Loosely typed, Strongly typed

           -  Automatically defined functions

        

        -  Evolution strategies (including CMA-ES)

        -  Multi-objective optimisation (NSGA-II, SPEA2, MO-CMA-ES)

        -  Co-evolution (cooperative and competitive) of multiple populations

        -  Parallelization of the evaluations (and more)

        -  Hall of Fame of the best individuals that lived in the population

        -  Checkpoints that take snapshots of a system regularly

        -  Benchmarks module containing most common test functions

        -  Genealogy of an evolution (that is compatible with

           `NetworkX <https://github.com/networkx/networkx>`__)

        -  Examples of alternative algorithms : Particle Swarm Optimization,

           Differential Evolution, Estimation of Distribution Algorithm

        

        Downloads

        ---------

        

        Following acceptation of `PEP

        438 <http://www.python.org/dev/peps/pep-0438/>`__ by the Python

        community, we have moved DEAP’s source releases on

        `PyPI <https://pypi.python.org>`__.

        

        You can find the most recent releases at:

        https://pypi.python.org/pypi/deap/.

        

        Documentation

        -------------

        

        See the `DEAP User’s Guide <http://deap.readthedocs.org/>`__ for DEAP

        documentation.

        

        In order to get the tip documentation, change directory to the ``doc``

        subfolder and type in ``make html``, the documentation will be under

        ``_build/html``. You will need `Sphinx <http://sphinx.pocoo.org>`__ to

        build the documentation.

        

        Notebooks

        ~~~~~~~~~

        

        Also checkout our new `notebook

        examples <https://github.com/DEAP/notebooks>`__. Using

        `IPython’s <http://ipython.org/>`__ notebook feature you’ll be able to

        navigate and execute each block of code individually and tell what every

        line is doing. Either, look at the notebooks online using the notebook

        viewer links at the botom of the page or download the notebooks,

        navigate to the you download directory and run

        

        .. code:: bash

        

           ipython notebook --pylab inline

        

        Installation

        ------------

        

        We encourage you to use easy_install or pip to install DEAP on your

        system. Other installation procedure like apt-get, yum, etc. usually

        provide an outdated version.

        

        .. code:: bash

        

           pip install deap

        

        The latest version can be installed with

        

        .. code:: bash

        

           pip install git+https://github.com/DEAP/deap@master

        

        If you wish to build from sources, download or clone the repository and

        type

        

        .. code:: bash

        

           python setup.py install

        

        Build Status

        ------------

        

        DEAP build status is available on Travis-CI

        https://travis-ci.org/DEAP/deap.

        

        Requirements

        ------------

        

        The most basic features of DEAP requires Python2.6. In order to combine

        the toolbox and the multiprocessing module Python2.7 is needed for its

        support to pickle partial functions. CMA-ES requires Numpy, and we

        recommend matplotlib for visualization of results as it is fully

        compatible with DEAP’s API.

        

        Since version 0.8, DEAP is compatible out of the box with Python 3. The

        installation procedure automatically translates the source to Python 3

        with 2to3.

        

        Example

        -------

        

        The following code gives a quick overview how simple it is to implement

        the Onemax problem optimization with genetic algorithm using DEAP. More

        examples are provided

        `here <http://deap.readthedocs.org/en/master/examples/index.html>`__.

        

        .. code:: python

        

           import random

           from deap import creator, base, tools, algorithms

        

           creator.create("FitnessMax", base.Fitness, weights=(1.0,))

           creator.create("Individual", list, fitness=creator.FitnessMax)

        

           toolbox = base.Toolbox()

        

           toolbox.register("attr_bool", random.randint, 0, 1)

           toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=100)

           toolbox.register("population", tools.initRepeat, list, toolbox.individual)

        

           def evalOneMax(individual):

               return sum(individual),

        

           toolbox.register("evaluate", evalOneMax)

           toolbox.register("mate", tools.cxTwoPoint)

           toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)

           toolbox.register("select", tools.selTournament, tournsize=3)

        

           population = toolbox.population(n=300)

        

           NGEN=40

           for gen in range(NGEN):

               offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1)

               fits = toolbox.map(toolbox.evaluate, offspring)

               for fit, ind in zip(fits, offspring):

                   ind.fitness.values = fit

               population = toolbox.select(offspring, k=len(population))

           top10 = tools.selBest(population, k=10)

        

        How to cite DEAP

        ----------------

        

        Authors of scientific papers including results generated using DEAP are

        encouraged to cite the following paper.

        

        .. code:: xml

        

           @article{DEAP_JMLR2012, 

               author    = " F\'elix-Antoine Fortin and Fran\c{c}ois-Michel {De Rainville} and Marc-Andr\'e Gardner and Marc Parizeau and Christian Gagn\'e ",

               title     = { {DEAP}: Evolutionary Algorithms Made Easy },

               pages    = { 2171--2175 },

               volume    = { 13 },

               month     = { jul },

               year      = { 2012 },

               journal   = { Journal of Machine Learning Research }

           }

        

        Publications on DEAP

        --------------------

        

        -  François-Michel De Rainville, Félix-Antoine Fortin, Marc-André

           Gardner, Marc Parizeau and Christian Gagné, “DEAP – Enabling Nimbler

           Evolutions”, SIGEVOlution, vol. 6, no 2, pp. 17-26, February 2014.

           `Paper <http://goo.gl/tOrXTp>`__

        -  Félix-Antoine Fortin, François-Michel De Rainville, Marc-André

           Gardner, Marc Parizeau and Christian Gagné, “DEAP: Evolutionary

           Algorithms Made Easy”, Journal of Machine Learning Research, vol. 13,

           pp. 2171-2175, jul 2012. `Paper <http://goo.gl/amJ3x>`__

        -  François-Michel De Rainville, Félix-Antoine Fortin, Marc-André

           Gardner, Marc Parizeau and Christian Gagné, “DEAP: A Python Framework

           for Evolutionary Algorithms”, in !EvoSoft Workshop, Companion proc.

           of the Genetic and Evolutionary Computation Conference (GECCO 2012),

           July 07-11 2012. `Paper <http://goo.gl/pXXug>`__

        

        Projects using DEAP

        -------------------

        

        -  S. Chardon, B. Brangeon, E. Bozonnet, C. Inard (2016), Construction

           cost and energy performance of single family houses : From integrated

           design to automated optimization, Automation in Construction, Volume

           70, p.1-13.

        -  B. Brangeon, E. Bozonnet, C. Inard (2016), Integrated refurbishment

           of collective housing and optimization process with real products

           databases, Building Simulation Optimization, pp. 531–538 Newcastle,

           England.

        -  Randal S. Olson, Ryan J. Urbanowicz, Peter C. Andrews, Nicole A.

           Lavender, La Creis Kidd, and Jason H. Moore (2016). Automating

           biomedical data science through tree-based pipeline optimization.

           Applications of Evolutionary Computation, pages 123-137.

        -  Randal S. Olson, Nathan Bartley, Ryan J. Urbanowicz, and Jason H.

           Moore (2016). Evaluation of a Tree-based Pipeline Optimization Tool

           for Automating Data Science. Proceedings of GECCO 2016, pages

           485-492.

        -  Van Geit W, Gevaert M, Chindemi G, Rössert C, Courcol J, Muller EB,

           Schürmann F, Segev I and Markram H (2016). BluePyOpt: Leveraging open

           source software and cloud infrastructure to optimise model parameters

           in neuroscience. Front. Neuroinform. 10:17. doi:

           10.3389/fninf.2016.00017 https://github.com/BlueBrain/BluePyOpt

        -  Lara-Cabrera, R., Cotta, C. and Fernández-Leiva, A.J. (2014).

           Geometrical vs topological measures for the evolution of aesthetic

           maps in a rts game, Entertainment Computing,

        -  Macret, M. and Pasquier, P. (2013). Automatic Tuning of the OP-1

           Synthesizer Using a Multi-objective Genetic Algorithm. In Proceedings

           of the 10th Sound and Music Computing Conference (SMC). (pp 614-621).

        -  Fortin, F. A., Grenier, S., & Parizeau, M. (2013, July). Generalizing

           the improved run-time complexity algorithm for non-dominated sorting.

           In Proceeding of the fifteenth annual conference on Genetic and

           evolutionary computation conference (pp. 615-622). ACM.

        -  Fortin, F. A., & Parizeau, M. (2013, July). Revisiting the NSGA-II

           crowding-distance computation. In Proceeding of the fifteenth annual

           conference on Genetic and evolutionary computation conference

           (pp. 623-630). ACM.

        -  Marc-André Gardner, Christian Gagné, and Marc Parizeau. Estimation of

           Distribution Algorithm based on Hidden Markov Models for

           Combinatorial Optimization. in Comp. Proc. Genetic and Evolutionary

           Computation Conference (GECCO 2013), July 2013.

        -  J. T. Zhai, M. A. Bamakhrama, and T. Stefanov. “Exploiting

           Just-enough Parallelism when Mapping Streaming Applications in Hard

           Real-time Systems”. Design Automation Conference (DAC 2013), 2013.

        -  V. Akbarzadeh, C. Gagné, M. Parizeau, M. Argany, M. A Mostafavi,

           “Probabilistic Sensing Model for Sensor Placement Optimization Based

           on Line-of-Sight Coverage”, Accepted in IEEE Transactions on

           Instrumentation and Measurement, 2012.

        -  M. Reif, F. Shafait, and A. Dengel. “Dataset Generation for

           Meta-Learning”. Proceedings of the German Conference on Artificial

           Intelligence (KI’12). 2012.

        -  M. T. Ribeiro, A. Lacerda, A. Veloso, and N. Ziviani.

           “Pareto-Efficient Hybridization for Multi-Objective Recommender

           Systems”. Proceedings of the Conference on Recommanders Systems

           (!RecSys’12). 2012.

        -  M. Pérez-Ortiz, A. Arauzo-Azofra, C. Hervás-Martínez, L.

           García-Hernández and L. Salas-Morera. “A system learning user

           preferences for multiobjective optimization of facility layouts”.

           Pr,oceedings on the Int. Conference on Soft Computing Models in

           Industrial and Environmental Applications (SOCO’12). 2012.

        -  Lévesque, J.C., Durand, A., Gagné, C., and Sabourin, R.,

           Multi-Objective Evolutionary Optimization for Generating Ensembles of

           Classifiers in the ROC Space, Genetic and Evolutionary Computation

           Conference (GECCO 2012), 2012.

        -  Marc-André Gardner, Christian Gagné, and Marc Parizeau, “Bloat

           Control in Genetic Programming with Histogram-based Accept-Reject

           Method”, in Proc. Genetic and Evolutionary Computation Conference

           (GECCO 2011), 2011.

        -  Vahab Akbarzadeh, Albert Ko, Christian Gagné, and Marc Parizeau,

           “Topography-Aware Sensor Deployment Optimization with CMA-ES”, in

           Proc. of Parallel Problem Solving from Nature (PPSN 2010), Springer,

           2010.

        -  DEAP is used in `TPOT <https://github.com/rhiever/tpot>`__, an open

           source tool that uses genetic programming to optimize machine

           learning pipelines.

        -  DEAP is also used in ROS as an optimization package

           http://www.ros.org/wiki/deap.

        -  DEAP is an optional dependency for

           `PyXRD <https://github.com/mathijs-dumon/PyXRD>`__, a Python

           implementation of the matrix algorithm developed for the X-ray

           diffraction analysis of disordered lamellar structures.

        -  DEAP is used in `glyph <https://github.com/Ambrosys/glyph>`__, a

           library for symbolic regression with applications to

           `MLC <https://en.wikipedia.org/wiki/Machine_learning_control>`__.

        

        If you want your project listed here, send us a link and a brief

        description and we’ll be glad to add it.

        
Keywords: evolutionary algorithms,genetic algorithms,genetic programming,cma-es,ga,gp,es,pso
Platform: any
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Software Development
