int byteSlice(byte input, byte startIndex, byte endIndex){

  // generates an integer value from an arbitrary slice of a byte
  // Example:
  //
  // index:   01234567
  // input = B01101100 (int 108)
  //
  // startIndex = 1
  // endIndex = 4
  // slice = B1101
  // returns int 13

  byte output;

  // shift left to shave off bits before startIndex
  output = input << startIndex;
  // shift right to shave off bits after endIndex
  output = output >> (7-endIndex) + startIndex;

  return int(output);
}

This basically takes out a chunk of a byte and gives you the integer representation of its bits.  The input index byte datatypes are a neurotic memory optimization, since the indices can’t be greater than 7. Example Arduino implementation:

void setup(){

  Serial.begin(9600);
  byte in = 108;

  Serial.print(in, DEC);
  Serial.print("\t");
  Serial.println(in, BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 0, 7), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 0, 7), BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 1, 4), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 1, 4), BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 3, 6), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 3, 6), BIN);
}

void loop(){
}

byte arrayToByte(int arr[], int len){
  // Convert -1 to 0 and pack the array into a byte
  int i;
  byte result = 0;

  for(i=len-1; i>=0; i--){
    if(arr[i] == -1){
      result &= ~(0 << i);
    } else {
      result |= (1 << i);
    }
  }
  return result;
}

int* byteToArray(byte in){
  int i, temp, out[8];

  for(i=0; i<8; i++){     temp = (in >> i) & 1;
    if(temp == 0) temp = -1;
    out[i] = temp;
  }
  return out;
}

The first function takes in an array of up to 8 integers valued 1 or -1 and generates a corresponding byte; the second does the reverse.  Easy to modify for other integer values.

The network consists of an input and output layer (and optional “hidden” layers in between) with weighted connections between all of them.  To train a perceptron, you present an input pattern and the output pattern it should learn to output.  Then you step through each pair of neurons in each pair of layers and modify their weights with this equation:

∆w_i = c (d – sign( ∑x_iw_i)) x_i

…where w_i is the ith weight (real-valued), c is the learning constant (i.e. 0.1), d is the desired output for this node (1 or -1), and x_i is the input activation (1 or -1).  The input activation term indicates that the input node in question “contributes” to the output or “inhibits” it.  sign() is given by:

sign(x) = 1 if x ≥ 0, else -1

Here’s a C++ implementation from my Neuroduino Arduino library:

int Neuroduino::signThreshold(double sum){
	if (sum >= _net.Theta) {
		return 1;
	} else {
		return -1;
	}
}

double Neuroduino::weightedSum(int l, int node){
	// calculates input activation for a particular neuron
	int i;
	double currentWeight, sum = 0.0;

	for (i=0; i<_net.Layer[l-1]->Units; i++) {
		currentWeight = _net.Layer[l]->Weight[node][i];
		sum += currentWeight * _net.Layer[l-1]->Output[i];
	}

	return sum;
}

void Neuroduino::adjustWeights(int trainArray[]){
	int l,i,j;
	int in,out, error;
	int activation;	// for each "rightmost" node
	double delta;

	for (l=1; l<_numLayers; l++) {
		// cycle through each pair of nodes
		for (i=0; i<_net.Layer[l]->Units; i++) {
			// "rightmost" layer
			// calculate current activation of this output node
			activation = signThreshold(weightedSum(l,i));
			out = trainArray[i];	// correct activation
			error = out - activation;	// -2, 2, or 0

			for (j=0; j<_net.Layer[l-1]->Units; j++) {
				// "leftmost" layer

				in = _net.Layer[l-1]->Output[j];

				delta = _net.Eta * in * error;
				_net.Layer[l]->Weight[i][j] += delta;
			}
		}
	}
}

void Neuroduino::simulateNetwork(){
	/*****
	 Calculate activations of each output node
	 *****/
	int l,j;

	for (l=_numLayers-1; l>0; l--) {
		// step backwards through layers
		// TODO: this will only work for _numLayers = 2!
		for (j=0; j < _net.Layer[l]->Units; j++) {
			_output[j] = signThreshold(weightedSum(1, j));
		}
	}
}

function gcd(a, b){
	// Euclidean algorithm
	var t;
	while (b != 0){
		t = b;
		b = a % b;
		a = t;
	}
	return a;
}

function lcm(a, b){
	return (a * b / gcd(a, b));
}

function lcmm(args){
	// Recursively iterate through pairs of arguments
	// i.e. lcm(args[0], lcm(args[1], lcm(args[2], args[3])))

	if(args.length == 2){
		return lcm(args[0], args[1]);
	} else {
		var arg0 = args[0];
		args.shift();
		return lcm(arg0, lcmm(args));
	}
}

Just pass in an array like so:

trace(lcmm([1,2,3,4]));

1. Connect the RSSI pin (pin 6) to a digital pin on your microcontroller.
2. Use this line of code in your Arduino loop:

   rssiDur = pulseIn(digitalPin, LOW, 200);

pulseIn returns the duration of a pulse (specified HIGH or LOW) in microseconds (µs).  The 200 is a timeout value in µs—it waits this long to see if there’s going to be a pulse.  Since the XBee’s RSSI PWM period is 200µs, we want to wait at most that long to see if there’s a pulse at all.

Since this function gives you a duration, it’s up to you to map that to a value relevant to your program.  Since the maximum duration of the pulse would be 200µs, you could map that to your logical maximum.

Seem them in action:

My final thesis presentation:

All the technical details are in the thesis paper!

In the gray pre-dawn, there sits, near the window-sill, a group of small, still beings.  Gradually, the diffuse edge of dawn crawls over them and, slowly, one or two of the pale, hooded entities begin to hum.  Softly and slowly, the pitches of their humming move toward consonance, and as a third and fourth join them, diverge again into dissonance.

This Dawn Chorus has gradually and emergently developed its own song-language, a metastructure that was never designed into any of the Chorus’s individual members.  Each member of the Chorus has the ability to sense the light and sound of its environment and the ability to vocalize—as well as the ability to learn from the actions of its neighbors.  In this way, the Chorus is able to naturally develop its own set of linguistic, musical conventions, entirely independently.

These sculptures contain a compact set of electronics comprising a microcontroller, sound and light sensors, a hybrid digital-analog synthesizer of my own design, a radio module and a speaker.  Each unit uses a simple neural network learning algorithm to associate environmental events and the actions of its milieu with generative sound patterns.  In short, the entities that make up the Dawn Chorus learn to talk to each other.

But what about?  The Dawn Chorus is not meant as an attempt to mimic animal behavior, but rather as an experiment in emergent poetics.  I see the songs of the Chorus as more musical than communicative, as more of a series of conversational poems than a survival strategy.  In time, we humans may even learn their language—but they will continue to enjoy it on their own.

Cryptoanarchism

See Enpersonator in action here: http://soniayuditskaya.tumblr.com/

Enpersonator is in development here: http://github.com/virgildisgr4ce/Enpersonator.  It requires the Python Tumblr library, which requires Django for its utilities.  The Markov Generator is modified from Adam Parrish’s.

The current version uses all 5 of the blogs in the Political Blog Corpora, comprising 133,953 tokens.  Not too shabby, but still not enough to avoid lots of wholesale reproductions.