plasticity

Eric Kandels study of the aplysia to understand how long term memory is stored in nervous cells.

Eric Kandel with an aplysia

07.11.13 growth processes

roots, Roman Kirschner

simulation of a growth process, click to start,press 'r' to reset, 's' to stop

Growth is fundamental part of plasticity, for example, as we have seen in the juggling study, the brain regions associated with the learning task grow during the period of learning to shrink afterwards. In this session we look at crystalline growth processes. Although the mechanisms in neural growth are quite

figure from Gordon Pasks paper on growth

different from crystalline growth they share one fundamental aspect, which is that the growth process may alter behavior and in turn alter the growth process itself. This analogy had first been examined by Gordon Pask in his works on chemical computing. In Physical Analogues to the Growth of a Concept he proposes a crystal process that he takes as example for a self-building system that illustrates growth. Within the seminar we re-enact this experiment using silver-nitrate dissolved in ammonia and water, because the growth of silver structures as a result of electrolysis happens very fast and can be observed in real-time. We focus on one aspect that is sketched in Pasks paper in figure 6: the effect of competition and bifurcation during the growth of silver-threads when there are multiple attracting anodes. He argues that if initially point X is more attractive than Y, the thread will grow in direction of X and that if at some moment in time Y is made equally attractive the thread might bifurcate and split into two branches. If after this bifurcation, the initial parameters for X and Y are re-established, the behavior of the system will now be very different, because it has already formed a thread towards Y. He argues that the behavior after bifurcation can not be predicted from the observations of the system before the bifurcation. From this observation he concludes (quote) Thus an observer would say that the assemblage learned and modified its behavior, or looking inside the system, that it built up a structure adapted to dealing with an otherwise insoluble ambiguity in its surroundings.

hands-on experiments with an arduino controlled growth process using silver-nitrate

14.11.13 guest: Hubert Dinse on Controlling plasticity and learning

co-activation of the finger and test device for assessing tactile acuity

Hubert Dinse heads the neural plasticity lab at the institute for neural computation in bochum. Hubert Dinse is a world leading researcher on the topic

Hubert Dinse

of neural plasticity. With his group at the neural plasticity lab he has discovered how to trigger learning and structural brain reorganization through passive stimulation protocols. They have also developed advanced methods for measuring behavioral improvement, in for example tactile acuity. Combining these methods with brain imaging technologies such as functional magnetic resonance imaging and electroencephalography (EEG) they could show that, for example, extended training of a musical instrument, wearing a cast or even meditation all drive structural changes of the brain.

21.11.13 models and algorithms of growth

screenshot from the german television program Spass am Dienstag

zinified version of the storing input example, click to start

Programming is a skill and like any other skill programming can be learned. We will use the study of algorithms of growth to learn programming basics. As programming environment we will use processing. Processing provides a very good documentation and many examples and tutorials. My favorite processing example is called Storing Input. The code is very minimalistic and the result reminds me of zini, a character that was starred in the german television program Spass am Dienstag.

/**
 * Storing Input. 
 * 
 * Move the mouse across the screen to change the position
 * of the circles. The positions of the mouse are recorded
 * into an array and played back every frame. Between each
 * frame, the newest value are added to the end of each array
 * and the oldest value is deleted. 
 */
 
int num = 60;
float mx[] = new float[num];
float my[] = new float[num];

void setup() {
  size(640, 360);
  noStroke();
  fill(255, 153); 
}

void draw() {
  background(51); 
  
  // Cycle through the array, using a different entry on each frame. 
  // Using modulo (%) like this is faster than moving all the values over.
  int which = frameCount % num;
  mx[which] = mouseX;
  my[which] = mouseY;
  
  for (int i = 0; i < num; i++) {
    // which+1 is the smallest (the oldest in the array)
    int index = (which+1 + i) % num;
    ellipse(mx[index], my[index], i, i);
  }
}

To simulate the crystalline growth process with a processing sketch we program an algorithm that is called diffusion limited aggregation (dla). The basic principle of dla is to simulate a diffusion process of particles, that form into a cluster when they hit an aggregate. The aggregate is initialized with a single seed. The diffusion process of the particles is simulated with a random walk.
The following sketch creates 50 particles that do a random walk and it illustrates nicely how the random walk of all particles leads to a diffusion. The area in which the particles are allowed to move is unlimited, ultimately the particles diffuse into the void.

int numberOfParticles = 50;
int particleSize=20;
Particle[] particles = new Particle[numberOfParticles]; 
void setup()
{
  size(584, 180);
  for (int i=0;i < numberOfParticles; i++)
  {
    particles[i] = new Particle(particleSize,particleSize,color(random(255), random(255), random(255)), width/2, height/2);
  } 
}
void draw()
{
  background(100);
  for (int i=0;i < numberOfParticles; i++)
  {
    particles[i].move();
    particles[i].draw();
  }
}

class Particle
{
  float x,y;
  color c;
  int particleSizeX,particleSizeY;
  Particle(int particleSizeX,int particleSizeY,color c,float x_pos, float y_pos)
  {
    x=x_pos;
    y=y_pos;
    this.c=c;
    this.particleSizeX=particleSizeX;
    this.particleSizeY=particleSizeY;
  }
  void draw()
  {
    stroke(c);
    fill(c);
    ellipse((int)(x),int(y),particleSizeX,particleSizeY);
  }
  void move()
  {
      x += random(-sqrt(2*particleSizeX),sqrt(2*particleSizeY));   
      y +=  random(-sqrt(2*particleSizeX),sqrt(2*particleSizeY));     
  }
}

In order to make the sketch more readable the particle movement and drawing functions are encapsulated in a class called Particle. This class has three functions:

• the constructor that is used for the setup of the class, which takes as parameters the size in x and y direction, the color and the initial x and y position of the particle.
• the move function, this is the core function that creates the random move by computing a random movement in x and y direction that is added to the particles current position.
• the draw function, to paint a circle at the current position of the particle.

The second part of the dla algorithm is the building up of a cluster, which is actually the crystalline like structure, also refered to as aggregation. Usually a single seeding point is defined and when a particle in its random motion hits the seeding point it builds an aggregate with the seeding point by sticking at the location where it did hit the point. Whenever a another particle hits the aggregate it also sticks to it. To keep track of whether a particle hits the aggregate and to keep track of the growing structure we need a second element which is an occupancy grid. For the sake of simplicity we define a two dimensional rectangular grid, although others are possible (more dimension, hexagonal shape).

float fcenterX;
float fcenterY;
Grid grid;
int particleSize=40;
void setup()
{
  size(584, 240);
  fcenterX=width/2;
  fcenterY=height/2;
  grid = new Grid(particleSize, particleSize);
  grid.setOccupied((int)fcenterX, (int) fcenterY);
  background(100);
  fill(255);
  stroke(255);
}
void draw()
{
  background(100);
  grid.draw();
}

void mouseReleased() { 
  if (!grid.alone(mouseX, mouseY))
  {
    grid.occupancyMap[grid.findGridPointIndex(mouseX, mouseY)]=true;
  }
  loop();
}

void mousePressed() {
  noLoop();
  if ((!grid.alone(mouseX, mouseY))&&(!grid.occupied(mouseX, mouseY)))
  { 
    grid.drawGridCell(mouseX, mouseY, color(255, 0, 0));
  }
}

//class to manage an occupancy grid   
class Grid {
  int cellWidth, cellHeight;  //width and heigth of a single grid cell
  boolean [] occupancyMap; //linear vector that keeps track wether a cell is occupied or not
  int array_size;
  int grid_width;
  int grid_height;
  Grid(int cellWidth, int cellHeight)
  {
    this.cellWidth=cellWidth;
    this.cellHeight=cellHeight;
    //size of the linear array 
    array_size = round(width/cellWidth * height/cellHeight);
    //full width of the grid in screen coordinates
    grid_width= round(width/cellWidth);
    //full height of the grid in screen coordinates
    grid_height= round(height/cellHeight);
    print(grid_width);
    //initialize occupancymap
    occupancyMap = new boolean[array_size];
    for (int i=0;i= grid_width || left_of_x < 0 || left_of_x >grid_width || rigt_of_x <= 0 || rigt_of_x >= grid_width || 
      cy < 0 || cy >= grid_height || top_of_y < 0 || top_of_y >=grid_height || bottom_of_y <= 0 || bottom_of_y >=grid_height) 
    {
      return true;
    }    
    // pre multiply the ys     
    cy *= grid_width;     
    bottom_of_y *= grid_width;     
    top_of_y *= grid_width;   
    // N, W, E, S    
    if (occupancyMap[cx + top_of_y] ||  occupancyMap[left_of_x + cy] || 
      occupancyMap[rigt_of_x + cy] ||  occupancyMap[cx + bottom_of_y]) 
    {
      return false;
    }
    // NW, NE, SW, SE    
    if (occupancyMap[left_of_x + top_of_y] ||  occupancyMap[left_of_x + bottom_of_y] ||  
      occupancyMap[rigt_of_x + top_of_y] ||  occupancyMap[rigt_of_x + bottom_of_y]) 
    {
      return false;
    }      
    return true;
  }

  void draw()
  {
    fill(150);
    stroke(150);
    strokeWeight(2);
    for (int x = 0; x< grid_width; x++)
      for (int y = 0;y< grid_height; y++)
      {
        fill((occupancyMap[y * grid_width + x]?1:0)*150+100);
        rect(x*cellWidth, y*cellHeight, cellWidth, cellHeight);
      }
  }
}

With the particle class and the grid class at hand constructing the dla is now straightforward.

float fcenterX;
float fcenterY;
int numberOfParticles = 160;
int particleSize=10;
Particle[] particles = new Particle[numberOfParticles]; 
Grid grid;
void setup()
{
  size(584, 360);
  fcenterX=width/2;
  fcenterY=height/2;
  grid = new Grid(particleSize, particleSize);
  grid.occupancyMap[grid.findGridPointIndex((int)fcenterX, (int) fcenterY)]=true;
  for (int i=0;i < numberOfParticles;i++)
  {
    particles[i] = new Particle(particleSize,particleSize,color(random(255), random(255), random(255)), random(0,width), random(0,height));
  } 
  background(100);
  fill(255);
  stroke(255);
  ellipse((int)fcenterX, (int)fcenterY, 10, 10);
}
void draw()
{
  background(100);
  //grid.draw();
  for (int i=0;i < numberOfParticles;i++)
  {
    if (grid.alone((int)particles[i].x, (int)particles[i].y))
    {
      particles[i].move();
    }
    else
     {
       grid.occupancyMap[grid.findGridPointIndex((int) particles[i].x,  (int) particles[i].y)]=true;
       particles[i].x= grid.findGridCellCenterX((int) particles[i].x);
       particles[i].y= grid.findGridCellCenterY((int) particles[i].y);
     }
    particles[i].draw();
  }
}

class Grid {
  int colSize, rowSize;  
  boolean [] occupancyMap;
  int array_size;
  int grid_width;
  int grid_height;
  Grid(int colSize, int rowSize)
  {
    this.colSize=colSize;
    this.rowSize=rowSize;
    array_size = round(width/colSize * height/rowSize);
    grid_width= round(width/colSize);
    grid_height= round(height/rowSize);
    occupancyMap = new boolean[array_size];
    for (int i=0;i < array_size;i++)
    {
      occupancyMap[i]=false;
    }
  }
  int findGridPointIndex(int x, int y)
  {
    int x_grid=(int)(x/colSize);
    int y_grid=(int)(y/rowSize);
    return (y_grid * grid_width + x_grid);
  }
  void drawGridPoint(int x, int y)
  {
    int x_grid=(int)(x/colSize);
    int y_grid=(int)(y/rowSize);
    stroke(100,50);
    fill(100,50);
    rect(x_grid*colSize, y_grid*rowSize, colSize, rowSize);
  }
  int findGridCellCenterX(int x)
  {
    int x_grid=(int)(x/colSize);
    return x_grid*colSize+round(colSize/2.);
  }
  int findGridCellCenterY(int y)
  {
    int y_grid=(int)(y/rowSize);
    return y_grid*rowSize+(int)(rowSize/2.);
  }
  // returns true if no neighboring pixels  
  boolean alone(int x, int y) 
  {     
    int cx = (int)(x/colSize); 
    int cy = (int)(y/rowSize);
    // get positions   
    int lx = cx-1;     
    int rx = cx+1;     
    int ty = cy-1;     
    int by = cy+1;     
    //checks that index is not out of bounds or just on the borders
     if (cx <= 0 || cx >= grid_width || lx <= 0 || lx >= grid_width || rx <= 0 
     || rx >= grid_width || cy <= 0 || cy >= grid_height || ty <= 0 || ty >= grid_height || by <= 0 
     || by >= grid_height) 
    {
      return true;
    }    
    // pre multiply the ys     
    cy *= grid_width;     
    by *= grid_width;     
    ty *= grid_width;        
    // N, W, E, S    
    if (occupancyMap[cx + ty] ||  occupancyMap[lx + cy] || occupancyMap[rx + cy] ||  occupancyMap[cx + by]) 
    {
      return false;       
    }
    // NW, NE, SW, SE    
    if (occupancyMap[lx + ty] ||  occupancyMap[lx + by] ||  occupancyMap[rx + ty] ||  occupancyMap[rx + by]) 
    {
      return false;      
    }      
    return true;
  }

  void draw()
  {
    fill(150,100);
    stroke(150,100);
    for (int x=0;x < grid_width;x++)
      for (int y=0;y < grid_height;y++)
      {
        fill((occupancyMap[y * grid_width + x]?1:0)*255+100);
        rect(x*colSize, y*rowSize, colSize, rowSize);
      }
  }
}

class Particle
{
  float x,y;
  color c;
  int particleSizeX,particleSizeY;
  Particle(int particleSizeX,int particleSizeY,color c,float x_pos, float y_pos)
  {
    x=x_pos;
    y=y_pos;
    this.c=c;
    this.particleSizeX=particleSizeX;
    this.particleSizeY=particleSizeY;
  }
  void draw()
  {
    stroke(c,150);
    fill(c,150);
    ellipse((int)(x),int(y),particleSizeX-2,particleSizeY-2);
  }
  void move()
  {
      x += random(-sqrt(2*particleSizeX),sqrt(2*particleSizeX));   
      y +=  random(-sqrt(2*particleSizeX),sqrt(2*particleSizeX));     
  }
}

A modified version that recycles particles, with a dipole: two sources where the particles are released.

5.12.13 sensory deprivation the dark and the bright side

Donald Ewen Cameron

John Cunningham Lilly.

12.12.13 excursion floating

a floating tank

1. Qvm Antrag Pilotprojekt Floating

Literatur – Referenzen

28.11.13 models and algorithms of self organizing maps

05.12.13 process based art

metronomic irregularity I, Eva Hesse 1966.

16.01.14 philosophy: Catherine Malabou's What to do with our brains?

06.02.14

literature references

Driemeyer J, Boyke J, Gaser C, Büchel C, May A (2008) Changes in Gray Matter Induced by Learning—Revisited. PLoS ONE 3(7) link
Boyke, J., Driemeyer, J., Gaser, C., Büchel, C., & May, A. (2008). Training-induced brain structure changes in the elderly. The Journal of neuroscience, 28(28), 7031-7035. link