code: def eaMuPlusLambda(
      population,
      toolbox,
      mu,
      lambda_,
      cxpb,
      mutpb,
      ngen,
      pbar,
      stats=None,
      halloffame=None,
      verbose=0,
      per_generation_function=None,
      log_file=None,
  ):
      """This is the :math:`(\mu + \lambda)` evolutionary algorithm.
      :param population: A list of individuals.
      :param toolbox: A :class:`~deap.base.Toolbox` that contains the evolution
                      operators.
      :param mu: The number of individuals to select for the next generation.
      :param lambda\_: The number of children to produce at each generation.
      :param cxpb: The probability that an offspring is produced by crossover.
      :param mutpb: The probability that an offspring is produced by mutation.
      :param ngen: The number of generation.
      :param pbar: processing bar
      :param stats: A :class:`~deap.tools.Statistics` object that is updated
                    inplace, optional.
      :param halloffame: A :class:`~deap.tools.HallOfFame` object that will
                         contain the best individuals, optional.
      :param verbose: Whether or not to log the statistics.
      :param per_generation_function: if supplied, call this function before each generation
                              used by tpot to save best pipeline before each new generation
      :param log_file: io.TextIOWrapper or io.StringIO, optional (defaul: sys.stdout)
      :returns: The final population
      :returns: A class:`~deap.tools.Logbook` with the statistics of the
                evolution.
      The algorithm takes in a population and evolves it in place using the
      :func:`varOr` function. It returns the optimized population and a
      :class:`~deap.tools.Logbook` with the statistics of the evolution. The
      logbook will contain the generation number, the number of evalutions for
      each generation and the statistics if a :class:`~deap.tools.Statistics` is
      given as argument. The *cxpb* and *mutpb* arguments are passed to the
      :func:`varOr` function. The pseudocode goes as follow ::
          evaluate(population)
          for g in range(ngen):
              offspring = varOr(population, toolbox, lambda_, cxpb, mutpb)
              evaluate(offspring)
              population = select(population + offspring, mu)
      First, the individuals having an invalid fitness are evaluated. Second,
      the evolutionary loop begins by producing *lambda_* offspring from the
      population, the offspring are generated by the :func:`varOr` function. The
      offspring are then evaluated and the next generation population is
      selected from both the offspring **and** the population. Finally, when
      *ngen* generations are done, the algorithm returns a tuple with the final
      population and a :class:`~deap.tools.Logbook` of the evolution.
      This function expects :meth:`toolbox.mate`, :meth:`toolbox.mutate`,
      :meth:`toolbox.select` and :meth:`toolbox.evaluate` aliases to be
      registered in the toolbox. This algorithm uses the :func:`varOr`
      variation.
      """
      logbook = tools.Logbook()
      logbook.header = ["gen", "nevals"] + (
          stats.fields if stats else []
      )
  
      # Initialize statistics dict for the individuals in the population, to keep track of mutation/crossover operations and predecessor relations
      for ind in population:
          initialize_stats_dict(ind)
  
      population[:] = toolbox.evaluate(population)
  
      record = stats.compile(population) if stats is not None else {}
      logbook.record(gen=0, nevals=len(population), **record)
  
      # Begin the generational process
      for gen in range(1, ngen + 1):
          # Vary the population
          offspring = varOr(population, toolbox, lambda_, cxpb, mutpb)
  
          # Update generation statistic for all individuals which have invalid 'generation' stats
          # This hold for individuals that have been altered in the varOr function
          for ind in offspring:
              if ind.statistics["generation"] == "INVALID":
                  ind.statistics["generation"] = gen
  
          # Evaluate the individuals with an invalid fitness
          invalid_ind = [
              ind for ind in offspring if not ind.fitness.valid
          ]
  
          offspring = toolbox.evaluate(offspring)
  
          # Select the next generation population
          population[:] = toolbox.select(population + offspring, mu)
  
          # pbar process
          if not pbar.disable:
              # Print only the best individual fitness
              if verbose == 2:
                  high_score = max(
                      halloffame.keys[x].wvalues[1]
                      for x in range(len(halloffame.keys))
                  )
                  pbar.write(
                      "\nGeneration {0} - Current "
                      "best internal CV score: {1}".format(
                          gen, high_score
                      ),
                      file=log_file,
                  )
  
              # Print the entire Pareto front
              elif verbose == 3:
                  pbar.write(
                      "\nGeneration {} - "
                      "Current Pareto front scores:".format(gen),
                      file=log_file,
                  )
                  for pipeline, pipeline_scores in zip(
                      halloffame.items, reversed(halloffame.keys)
                  ):
                      pbar.write(
                          "\n{}\t{}\t{}".format(
                              int(pipeline_scores.wvalues[0]),
                              pipeline_scores.wvalues[1],
                              pipeline,
                          ),
                          file=log_file,
                      )
  
          # after each population save a periodic pipeline
          if per_generation_function is not None:
              per_generation_function(gen)
  
          # Update the statistics with the new population
          record = (
              stats.compile(population) if stats is not None else {}
          )
          logbook.record(gen=gen, nevals=len(invalid_ind), **record)
  
      return population, logbook
  
file_path: tpot/tpot/gp_deap.py
imports: import numpy
  from deap import tools, gp
  from inspect import isclass
  from .operator_utils import set_sample_weight
  from sklearn.utils import indexable
  from sklearn.metrics import check_scoring
  from sklearn.model_selection._validation import _fit_and_score
  from sklearn.base import clone
  from collections import defaultdict
  import warnings
  from stopit import threading_timeoutable, TimeoutException
label_desc: Use image node_id 5 for calling a global function with example usage: eaMuPlusLambda(population, toolbox, mu, lambda_, cxpb, mutpb, ngen, pbar, stats, halloffame, verbose, per_generation_function, log_file) and returns: population,  logbook