Genetic programming process that produces functions for morphogenic

October 10, 2018 | Author: Anonymous | Category: Documents
Share Embed

Short Description

Download scientific diagram| Genetic programming process that produces ... morphogenic primitives (MPs) [1], to aggregat...


Automated Shape Composition Based on Cell Biology and Distributed Genetic Programming Linge Bai [email protected]

Manolya Eyiyurekli [email protected]

David E. Breen [email protected]

Department of Computer Science Drexel University

ABSTRACT Motivated by the ability of living cells to form specific shapes and structures, we present a computational approach using distributed genetic programming to discover cell-cell interaction rules for automated shape composition. The key concept is to evolve local rules that direct virtual cells to produce a self-organizing behavior that leads to the formation of a macroscopic, user-defined shape. The interactions of the virtual cells, called Morphogenic Primitives (MPs), are based on chemotaxis-driven aggregation behaviors exhibited by actual living cells. Cells emit a chemical into their environment. Each cell responds to the stimulus by moving in the direction of the gradient of the cumulative chemical field detected at its surface. MPs, though, do not attempt to completely mimic the behavior of real cells. The chemical fields are explicitly defined as mathematical functions and are not necessarily physically accurate. The functions are derived via a distributed genetic programming process. A fitness measure, based on the shape that emerges from the chemical-field-driven aggregation, determines which functions will be passed along to later generations. This paper describes the cell interactions of MPs and a distributed genetic programming method to discover the chemical fields needed to produce macroscopic shapes from simple aggregating primitives.

Categories and Subject Descriptors I.3.5 [Computing Methodologies]: Computational Geometry and Object Modeling

General Terms Algorithms, Experimentation, Performance

Keywords Shape Composition, Morphogenesis, Chemotaxis, Distributed Genetic Programming, Self-organization

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. GECCO’08, July 12–16, 2008, Atlanta, Georgia, USA. Copyright 2008 ACM 978-1-60558-131-6/08/07 ...$5.00.

Figure 1: A set of randomly placed Morphogenic Primitives (left) aggregate to form a “gear” (right).



In living things, cells aggregate and grow to create complicated structures. This process, called morphogenesis, is one of the fundamental components involved in the development of all complex organisms [17]. One of the essential processes involved in morphogenesis is chemotaxis [6]. Chemotaxis is the phenomenon where cells interact with other cells by emitting a chemical that diffuses into the surrounding environment. Neighboring cells detect the overall chemical concentration at their surfaces and respond to the chemical stimulus by moving either towards or away from the source [9]. The motions induced by chemotaxis may then produce patterns or sortings of cells [12], or even large-scale structures, e.g. cavities or vessels. These phenomena have motivated us to look to developmental biology for concepts that lead to a more organic, cell-biology-inspired approach to shape composition. In this approach, we discover the local interaction rules that direct the self-organizing primitives, that we call morphogenic primitives (MPs) [1], to aggregate into a particular user-defined shape. Macroscopic shapes are formed automatically by the aggregation of these simple primitives responding only to local information. A collection of MPs are at first randomly placed in the modeling environment. The primitives emit a field, and then respond to the cumulative field by moving along its gradient. A macroscopic, user-defined shape then emerges from the combined actions of the individual primitives.


Morphogenic Primitives

Several principles were followed when developing morphogenic primitives. 1) MPs are autonomous “agents”. Each MP is an independent entity that senses the environment, responds to it, and then modifies the environment and its internal state. There is no “master designer” directing the

Figure 2: Genetic programming process that produces functions for morphogenic primitive interactions. actions/motions of the MPs. 2) Actions are based on local information. Each primitive emits a finite “chemical” field that can be sensed only by other primitives within a certain range. The only information received by an MP is gathered at its surface, namely the concentration of the cumulative field and contact with immediate neighboring MPs. 3) MPs respond to information with prescribed behaviors. The actions performed by each MP are the same, but the specifics of the individual actions are based on information received from the environment. 4) MPs have no representation of the final, macroscopic shape to be produced. MPs do not use information about the final shape to determine what actions to take. Their actions are pre-determined by the ultimate shape to produce, but MPs do not carry or access information about the shape. The MP’s final global position relative to the shape is not known ahead of time. 5) The shape emerges from the aggregation of local interactions and behaviors. Rather than following a plan to produce the shape, MPs sense, change and respond to the cumulative field concentration. This simple behavior, when combined with somewhat complex chemical fields, will direct the MPs to take individual actions based on local information that will ultimately aggregate to produce a user-defined, macroscopic shape. The main challenge here is to determine which local chemical fields will direct the MPs to ultimately come together into the desired shape. While MPs’ fundamental interaction is based on chemotaxis, we do not limit their behaviors/properties to be physically realistic or completely consistent with biology. Instead, developmental biology provides a motivating starting point for MPs. As a way to customize chemotaxis-driven cells for shape composition, we alter the chemical concentration fields around individual cells. Instead of the chemical concentration dropping off as a function of distance (the physically accurate description), we define the concentration field with a mathematical function of distance, angle and time. Since it is extremely difficult to determine which

particular local field function will direct MPs to form a specific macroscopic shape, we employ genetic programming [21] to produce the expressions that explicitly specify the field function. A fitness measure, based on the shape that emerges from the chemical-field-driven aggregation, determines which functions will be passed along to later generations. The genetic process stops once a function in the population provides the desired shape, or after a certain number of function generations have been produced and evaluated. The evaluation of each potential chemical field function involves a complex and compute-intensive cell aggregation simulation process. Since thousands of functions are generated and evaluated, the GP process that generates the correct MP interactions has extraordinarily high computational requirements. To meet these requirements, we have implemented a distributed GP system that is capable of exploiting the computational power of a Linux cluster.


Approach Overview

The general approach, which has been implemented within the Open Beagle Framework [16], to defining the field functions that ultimately produce the user-desired shape is presented in Figure 2. We start with a population of functions, which is initially randomly generated. Each function is compiled into a chemotaxis-based cell aggregation simulation program, and defines the chemical field that surrounds the individual cells. A simulation program is executed for each field function on a node in our cluster, usually producing some kind of aggregated structure. The resulting MP configuration is compared to the user-desired shape, and a scalar fitness value is calculated that quantifies how well the computed shape matches the desired shape. A subset of the top candidates are then used to create the next generation of field functions. The process continues until a field function produces the desired shape or the maximum number of generations is reached. Once the local field function has been identified for a spe-

cific shape, MPs may be randomly placed in the computing environment, with each MP surrounded by the GP-produced concentration field. A simulation is performed where the cumulative field is computed, and each MP moves along its gradient, until the MP population reaches an equilibrium, which is the desired shape. We have utilized this new approach to define morphogenic primitives that aggregate to form a number of user-defined shapes, e.g. an ellipse, a diamond, a boomerang, and an hourglass. In the process of evolving the field functions for user-defined shapes, a few pleasant surprises materialized. Most of them included repeated patterns, e.g. stripes, spots and sine waves, but most interestingly a gear shape emerged from the evolutionary process. See Figures 5 through 12.



Sims [26] applied genetic programming to create functional representations of intricate, interesting images and solid textures. In this work, an interactive process allows a user to guide the evolution of the image functions by the selection of preferred images and results. The repeated interaction between the user and the evolutionary process leads to the definition of functions for a large number of surprising and appealing images. This approach was extended for the creation of procedural models [27] and the definition of motions and behaviors of virtual creatures [28]. Fleischer explored a cell-based developmental model for self-organizing geometric structures [13, 14]. He applied his cell interaction simulation system to produce an approach to cellular texture generation [15]. Eggenberger Hotz proposed the use of genetic regulatory networks coupled with developmental processes for use in artificial evolution and was able to evolve simple shapes [7, 18]. The combination of artificial evolutionary techniques and developmental processes provides a comprehensible framework for the analysis of evolutionary shape creation. Additional shape generation methods based on grammars and cellular automata are described in [2]. Theraulaz and Bonabeau present a modeling approach based on the swarming behavior of social insects [29, 30], a type of swarm intelligence [3]. They combine swarm techniques with 3D cellular automata to create autonomous agents that indirectly interact in order to create complex 3D structures. This indirect interaction, known as stigmergy [31], allows the agents to act cooperatively, but independently, through a stimulus-response mechanism based on modifications made to the environment. Bonabeau et al. [4] apply genetic algorithms (GA) to the stigmergic swarm-based 3D construction method in order to improve the overall process. A fitness function, chosen by human observers, is assigned to each pattern in this approach, and a GA is used to search the space of all possible patterns. Given the heavy computation requirements of evolutionary computing and its applications, distributed evolutionary algorithms have been implemented to shorten computation times [24]. Tomassini [32] characterizes the different types of parallel evolutionary algorithms based on the granularity of the data structure and parallel synchronization. Experimentation with and analysis of different distributed genetic programming models have indicated that asynchronous models are more efficient in terms of execution time than other approaches [34]. Software frameworks for distributed genetic programming have also been developed, from tools based on

MPI on a Linux cluster [33] to the open-source Java environment DGPF run over large networks [35]. Distributed evolutionary algorithms have been utilized to solve a number of challenging computational problems. Rao and Hansdah have proposed Extended Distributed Genetic Algorithm to generate algorithms for channel routing problems [25]. Koza and Andre have implemented coarse-grained parallel genetic programming with 64 computers as processing nodes and successfully solved the 5-parity problem [22]. Implementation of fine-grained parallel genetic programming has been proposed by Juille and Pollack, in which parallel evaluation of different S-expressions was implemented on a SIMD computer [19]. Messom and Walker have applied distributed genetic programming in evolving cooperative robotic behaviors in robot soccer games [23]. Klein and Spector have proposed a system of distributed genetic programming based on JavaScript and XML, which does not require the installation of client-side software or explicit user participation [20]. Similar to some previous work, we have developed a chemotaxis-based cell aggregation simulation system. However we have extended and modified the system in order to utilize evolutionary computing to discover rules for shape composition. In our work, MPs cooperate with each other only through local interactions. The primitives have no information about the predefined global shape that is being composed. We have also developed a steady-state distributed genetic programming system, based on Unix programming [5], that provides the computational resources needed to perform numerous cell aggregation simulations. Moreover, an automated fitness evaluation process has been implemented that quantifies the similarity between the shape of the aggregated MPs produced by each cell simulation and the userdefined macroscopic shape.



We have previously developed a computational model and software system that is capable of simulating chemotaxisbased cell aggregation in 2-D [10, 11]. Our 2-D model incorporated fundamental parameters involved in cell-cell aggregation, such as a cell’s ability to emit and detect chemoattractant chemicals, cell motility, attachment, proliferation, aggregation and various stages of a cell’s life cycle. This model and system provide the conceptual and software foundation for morphogenic primitives. The full complexity of the original chemotaxis-based cell aggregation model was not needed for the initial implementation of MPs. The model was simplified and we focused the evolutionary process on one aspect of the possible cell interactions, the definition of the chemoattractant chemical field surrounding a single cell. Therefore we only utilize the chemoattractant emission and response portion of the cell simulation system. We also modified the system to allow for a general functional description of chemical fields. The chemical fields are defined as a function of the distance d and the angle θ between two MPs, as well as the MP’s age t. Since we define the chemical fields as mathematical expressions, we utilize a number of protected operators, such as protected division and protected logarithm. These protected operators safely handle invalid input values, for example divide by zero and non-positive logarithms. Additionally, the field function is truncated at a fixed distance (RM ax = 200 units) in order to keep the MP interactions finite and local.

Receive individual i

Initialize first generation


Termination criteria met?

Set slave node status to busy End

Make individual i the chemical field equation in cell simulation

No Store the generation in the individuals buffer

Buffer empty?

Run cell simulation with new chemical field equation


Compare the MP aggregation with user-defined shape

No Look through node list for available slave node s

Store fitness value of individual i in the fitness buffer Slave node available?



set slave node status to available Yes Send individual i to slave node s Start sl ave process on node s

Figure 4: The slave process.

4. Wait for all fitness values to be written into fitness buffer


Perform GP operations based on fitness values to produce a new generation

Figure 3: The master process. Each MP simulation process begins by randomly placing a number of MPs (500 for our examples) in the computational environment. A morphogenic primitive is represented by a small disk existing in a toroidal 2D environment. The environment is effectively infinite with no boundaries, since the top edge of our computational world is connected to the bottom edge, and the left edge is connected to the right edge. A single aggregation simulation is comprised of a series of time steps. For each time step, each cell performs a prescribed set of actions. Each MP emits a “chemical” into the environment. It then detects the cumulative field at eight receptors on its surface, and calculates the field gradient from this input. The gradient is used to determine the primitive’s velocity. We assume that MPs travel at a terminal velocity through a viscous fluid environment, therefore an MP’s velocity is directly proportional to the chemical field gradient (∇C). When an MP moves in the direction of the chemical gradient, its velocity is calculated as Velocity = λ ∗ ∇C,


where λ (1 for our examples) is a constant that determines the magnitude of a cell’s response to the gradient. At each simulation time step (∆t) the displacement of the MP is ∆x = Velocity ∗ ∆t.


If the displacement makes the MP collide with another MP, a small random step is taken instead. MPs do not always follow the field gradient. 10% of the time MPs take a random small step instead of following the field gradient. This randomness injects a small amount of noise into the system, helping to prevent the set of MPs from collecting into local minima configurations.


Given the magnitude of the search space, i.e. all possible polynomial and trigonometric functions, we have developed an steady-state, fine-grained, master-slave, distributed computing system that parallelizes the cell simulation and fitness evaluation components of our GP-based shape composition method. We have implemented an N-slave, 1-master model, with the master process adaptively distributing individuals among the slave processes, based on Unix shell scripting [5]. Open Beagle [16], a C++ evolutionary computing framework, has been utilized and altered to function as the distributed genetic programming framework. The master process, as outlined in Figure 3, adaptively sends out individual functions over a network to a number of slave processes, and performs most of the genetic programming steps. Each slave node hosts one slave process. As outlined in Figure 4, the slave process is responsible for incorporating the individual (chemical field function) into the cell simulation program, running the cell aggregation simulation, comparing the resulting aggregated shape with the user-defined shape and returning a fitness value to the master process. The master process then utilizes the fitness value associated with the individual function to perform genetic programming operations.


Evolutionary Process

The ramped half-and-half method [8, 21] is used to generate the initial population of functions which consists of GP trees of a predefined maximum depth. The master process first stores the whole generation into a buffer and then adaptively sends all the individuals to slave processes. Once all of the individuals have been distributed to the slave nodes, the master process waits until all of the individuals have been evaluated by the slave nodes. This is indicated when the fitness buffer contains the same number of values as individual functions. The slave process receives an individual function and modifies the cell aggregation simulation program by setting its chemical field function to the expression. A cell aggregation

Example ellipse diamond hourglass boomerang wave annulus

Function Divide((Log(Divide(d,t))-Log(cos(theta))),Divide(d,t)) Divide(((Log(Divide(d,t))-Divide((0.924414),theta))-(0.363563)),Divide(d,t)) Log(d)+cos(Divide((t*theta),Divide((t+Log(Divide(t,Log(d)))),(-0.356662)))) Log((d*exp(d))) Divide(Log((Log((sin(t)+cos(theta)))*d)),exp((sin(theta)+(Log(d)+theta)))) exp(exp(theta))

Generation 7th 11th 18th 13th 25th 25th

Fitness value 0.717403 0.659776 0.436527 0.560553 0.491477 0.435082

Table 1: Summary of shapes, field functions, number of generations and fitness values simulation is performed for each field function, producing an image of the aggregated shape that emerges from the local interactions defined by the function. Each aggregated result is then evaluated by the fitness function, which compares the aggregate image with a target image. A fitness value (a scalar between 0 and 1) that quantifies how closely the resulting aggregate matches the target shape is assigned to each individual function. The fitness values are stored in the master process’s fitness buffer. The slave process pauses until it receives another individual and then the slave process begins again. Once all the fitness values have been calculated, parent selection is performed on the population based on the fitness values. Variation then takes place using a swap subtree operation and single-point mutation. Generational replacement is used for survivor selection, i.e. the offspring replace the parents from the previous generation. The distributed genetic programming process repeats until the termination criteria are met, either after generating a maximum number of generations or when the fitness of an individual surpasses the threshold, i.e. the associated aggregate is approximately the same shape as the target.



• Individuals: Each individual is represented as a prefix tree with a maximum depth DM ax = 17. • Function and terminal set: F = {+, −, ∗, /, exp, log, sin, cos} T = {E, d, t, θ} In order to maintain the closure property of the GP process [8, 21], we use protected division and protected logarithm, which allows for the most general description of the functions. Here, E ∈
View more...


Copyright © 2017 EDOC Inc.