3spds

The prospect of analyzing, categorizing, or evaluating something before it has reached fruition is somewhat problematic. However, for practical reasons I find it necessary to put some thoughts on “The Data and Tension” into type. “The Data and Tension” (abbrev. tdat) is a language-event for four vocalists. I find it useful to describe vocalist interaction as though it were a game. For a thorough explanation of the rules, libretti, or development of this family of compositions, I refer the reader to the project page, and to my thesis; both are available here.

My goals in constructing tdat changed as my understanding of it did. The major changes that occurred along my process involved tdat’s content, production, and naming. Perhaps the most significant of these changes emerged when I began talking about tdat as an oral notative event.

For the first iterations of tdat, the rulesets were constructed through a labor-intensive analysis method of an arbitrary text. At first these texts were hand-edited and compiled from various sources, from class notes to pro-gun blogs. The most frequent significant words were rated for their frequencies and selected to be part of the rulesets. Then, using hand-drawn matrices, I attempted to construct rulesets that seemed balanced. The result was an arbitrarily structured game whose dynamics were unpredictable. After doing around six of these, I gave up with this method and inverted the process. I wrote a simulation library in SuperCollider and encoded the structural components of the games into a character string. Then I began searching for strings representing games with specific traits. Despite that the first few searches were not fully automated, the results were impressive. I eventually took each step in the algorithm and wrote a routine to schedule them, searching a very wide space for the perfect candidate. When the time came to realize one of these pieces, I replaced each of the characters with a sentence, written by me. The sentences, put in order of the characters in the string, would comprise the text. I eventually made one further inversion to the process, which was to write out the entire text in the order I wanted it, and to determine the mapping between the sentences and their functions from there.

As I worked, I became increasingly invested in the idea that my model of creative processes should support nested systems of signification. This decision also precipitated as I pored over book after book calling for the universal reform of the common practice notational system. It frustrated me that, even today, music discourses are obsessed with the Western canons’ practices of visualized parameterization. An oral notation is subversive to these practices because they comprise an event that is experienced through time. This subversion is attractive because oral notation practices are extremely common, even in the Western conservatory system. When is an event a notation for another event?

Another impetus for moving toward calling tdat a notation were some of the responses I would get from individuals regarding my thesis and the genealogy
of my compositions. It was suggested by numerous individuals that since “Solo for Amplified Window” came from the realization of a meta-notation of “Sanction of the Victim” (and indeed many other compositions), that tdat must bear the same relationship to “Sanction” as well. These individuals wanted me to explicitly define, in the form of another notation, the mapping between the two pieces’ parameters. I do not believe such a notation is necessary, nor does it contribute to the richness of the two pieces relating to each other.

I will probably continue my explorations into vocal/theatrical modes of production. While it is technologically deterministic to assume that computers make good performers or composers on their own, since it attributes intention, it is not unreasonable to consider that they offer the performing or composing human very sophisticated tools. I have been questioning what the term “computer music” even refers to. In the past, computers required a great amount of expertise and money to operate, and music-making was a separate practice. Today, computers are very easily and effectively integrated with musical processes and are much more readily understood, purchased, and maintained. What, then, is a specifically computerized music?

This composition requires a level of virtuosity on the part of the performer, both in that the task itself is difficult to complete and difficult to listen to. This virtuosic listening is also required of the experiencer. Rehearsal gave the performers the ability to make the piece more intelligible, or at least to consider intelligibility as an issue and exploit the elegance or performativity of the unintelligible. For the audience, the experience of being overwhelmed by language is attractive because it provides the opportunity for multiple paths through the arc of the piece. However, in order for this to be successful there must be an adequate recognition of the pleasure and care with which the performance is realized. This experience can be difficult to communicate effectively. To a certain extent, however, it is my intention that the experience of this piece also remain outside the realm of the understood, because I don’t fully understand it either, because the mere event of having all of these parties strive jointly for the communication of pleasure precludes the understanding of such an event. Paul Chan said it best:

There is nothing to be gained by making work that relates, except perhaps the cheap thrill of understanding. Better to let the work be as foreign and distant as a star, or an ambush.

This thesis is, in some ways, rather inappropriate to the conventions of ITP: it is academic, murky, and, genetic algorithms aside, fairly low-tech. In some other ways, however, it speaks a language that I hope resonates with the people of that program. I want its strangeness to elicit laughter at the familiar.

I can’t wait!  This is actually turning out to be more fun than terrifying.  For a while there, it was pretty terrifying…

I found a group of ITP students who seem to like doing the piece, and do it well.  They are: Elizabeth Fuller, Ted Hayes (Tedb0t), Lee-Sean Huang, and Kristen Smart.  I could not have asked for a better group, to be honest.

Our first performance will be today at 12:30 and I am totally psyched and not at all terrified.  The project site may be found here.

The text that we have settled on is technically version 8A, although this is misleading because between version 6 and 7, and version 7 and 8, are a very large number of simulated versions that were never tried by humans.  That number is even larger for the ‘demo’ versions a and b, which may not end up happening at all.  At least the genome files are intact for the demo versions, so they can be pored through and represented / appropriated however anyone should see fit.  The entire genome for demo b, a trio, is available here.

The version we will be performing is available in pdf form here: rules, text.

I plan on making an audio recording of the debut.  I’ll post it when I do.

this week i have four final project presentations in a row, and “the data and tension” will comprise no less than three of them.  mostly, this decision was arrived at for practical reasons: i want my performers to have a few chances to practice before the actual presentation on may 8th.  it will also be nice to have the experience of trying to explain it a few times before the big date as well.

i have decided that in addition to my preamble where i problematize transiency and opacity in creative work with technology, just after i play the binaural recordings from the installation, i should engage two audience members in a demonstration of the tdat system.  this way, in explaining the rules we can see them applied to a smaller system first, and the audience has the opportunity to experience the dilemma i’m trying to communicate.

this new ruleset is currently being located by a massive automated genetic search algorithm i wrote in supercollider.  i’m searching for this new ruleset with a lot of improvements to the code that both automate the entire workflow and properly log each step of the process for future sonification / visualization work.

i am still uncertain if a duet version is viable, because it’s currently on its 140th generation of 32 and we’re still not getting reasonable results.  i may can the duet idea and go for a trio instead, but i’m going to let this run for a few more hours and we’ll see if i eat my words.  i hope i do, words are tasty.

“linguini” are what im calling this family of objects. originally their shape comes from analyzing a very short section of recorded audio. since the analysis divides the single burst of audio into many hierarchically organized streams (some bigger/more influential than others, in a tree format), and also due to their noodle-like appearance, i’m calling them “linguini” (little languages). they’ve all been constructed the same way, so they look pretty similar. at first, i was going to assemble each one slightly differently, but this is the layout that i kept coming back to. even so, each one is different simply due to their physicality– that and my incompetence with regard to fabrication. i made these in an attempt to play with the idea that a sculpture could serve as notation for something else. already, without further realizing, the linguini are transcriptions of a previous event. they are inscribed with the representation of that event’s micro-worlds. since they are the result of an analysis process (the Haar wavelet transform), the details are encoded rather than directly represented. i find the form itself to fairly reek of musicality: there are 8 layers, with each successive layer (after the first two) doubling in complexity, with most complex layers approaching the look of a noisy, organic surface.

there is, as always, a fairly rich precedent for visualizing sound, even into sculpture. formally speaking, the linguini do not break new ground. it’s their proposed function that does.

what does calling an (otherwise formally pleasing, sculptural) object a notation really accomplish? musical notation is a system that contributes to the creation of worlds pertaining to specific roles, artifacts, and events. Cage and others categorize the roles involved as “composer” /”performer” / “listener”, while still others prefer categories that favor other aspects of this dynamic. the artifacts of music could be things like instruments, venues, and notations. (i even begrudgingly concede the inclusion of the grammy award as an artifact.) events may include composition, audition, practice, participation, experience, etc. semiologically, notation participates in an infinite regress of meaning, and, especially in the thoroughly fragmented worlds of contemporary thought on the subject, notation implies a relationship between events, any of which must be potentially resolvable to another notation. because of this troublingly recursive nature of the system at play, a piece like Paik’s “Zen for Head” can be positioned as a realization of La Monte Young’s “Composition 1960 #10″, and Young’s piece “Second Composition for David Tudor” a pithy realization of Cage’s 4′33″. in the continuum of African American creative music, this practice may be observed as well, for example in the work of restructural master Charlie Parker. notation is essentially incomplete, by which i mean it is almost always analogic to its signified, and often there is a loss of clarity at the more homologic end of the spectrum. examples of more homologic notational practices include the concrete arts, where tape-splicing or typography have the tendency to ‘point to themselves’. pop musics may often allude to this practice as well.

despite its apparent ambiguity as a notation, a physical object has mass, texture, fragility, uniqueness, and an abundance of other attributes that can constrain the variety of approaches to realize it. while the set of legal realizations remains infinite (just the same as, say, the set of legal realizations of a Bach fugue), the notation’s physicality both enriches and limits the variations among set members.

against my better judgement, i have attempted to realize the first linguini, “A”, by amplifying it with a contact microphone and rubbing it. using that sound material as a source, i produced a sonification of the most recent TDAT system. this sonification only responds to the pauses that happen as the result of a player hitting the end of her text without further re-triggering. i actually sonify each unit with a different grain lifted from the source material, but i constrained the amplitude such that we only hear the pauses, and perhaps part of the following and preceding units. each player’s stream is differentiated by a filter that emphasizes one of four resonant tones of the object, derived from a fourier analysis.

i’m very excited to distribute these notations among friends to see their decisions. that’s such an essential part of this idea: that a tool that was such a normalizing force, one that eventually grew up to encompass the property aspects of a piece of music, could be used in a way that confounds traditional forms of ownership, and meanwhile, lets us try to disentangle (or re-entangle) the idea from the technology.

finally, after all manner of disasters, i have 4 fully functional vocal pieces. all using the same text, this complex represents the 20th generation of a rigorous genetic algorithm whose fitness function takes an average over 32 scenarios. in a tested setting, piece 7A should be the most likely to continue indefinitely, since its average running time was 72,167.65625 turns. each generation of the algorithm spanned 32 possible pieces, and tested them 32 times to get a reasonable average for the fitness function. given the wide variation in output, however, i wouldn’t mind it if future generations applied some other filtering techniques to punish inconsistency. right now, though, i feel good about these four. they not only test well, but they look good too, imho: i have come up with a rough draft of filled in verbal ‘content’. from here, i’ll probably pick one of the four (most likely 7A but you never know) and i’ll spend the rest of my time tweaking it until it’s just right. i also have to leave some time in to find a group and rehearse. my current plan is to have this piece comprise a large portion of my thesis talk– a pretty risky move, considering how many other things i’m doing that i could talk about. i really don’t want to address the thesis paper directly, and i think a lot of the concepts are better seen from a multi-resolutioned perspective. hey– it’s that or show documentation footage. this seems more enjoyable for my audience.

still unclear if i’ll project the entire text or just the rulesets. the rulesets all happen to be nice and oblique for system 7, so if it stays that way, i may just project the rules to the audience and let the more prose like stuff lean on the conversational side.

continuing the thread from the previous post…

i’m on generation lucky thirteen, and i have doubled the gene pool size to 32 rulesets.  i’ve also automated the testing – scoring – averaging process, which was the bit that was so time consuming and required the majority of the mindless repetitive human input.  now i have a routine taking care of that for me, although i had to fork it off the SystemClock instead of the TempoClock to avoid overloading the scheduler.  also, it still takes about half a minute to run through each game, which means about 15 minutes for each generation.  again, this isn’t because the processor is slow, but because the turns actually take miniscule (but not zero) amounts of time.  i did this because i can’t figure out how to model the system in any way that does not involve forked scheduled routines.  at least im not still sitting in front of my computer pressing buttons every few seconds like a trained monkey.  well… that’s debatable.

also, i have been writing out data files representing the genomes for each generation, but i discovered today that the first 10 files had been corrupted.  i have fixed the problem, and was able to save my breeders for generation 11.

i am interested in the possibility of sonifying rulesets as computer music.  obviously i’m interested in sonifying them as vocal music and instrumental music, but today i was thinking about how i’d do it with a computer as the source.  i think the concept that hurt my head when thinking about computer sonification before was that i assumed i’d let each unit resolve to a sound.  a more attractive approach, at least to me, would be to let only significant units (ie those with transitions) resolve to audible sounds, and let everything else resolve to blocks of silence.

so, the last post on this topic left me with a ruleset that i liked and moving on to start filling in those ascii characters with meaningful content. i am sorry to say that i have hit a snag. that is, i ran a few simulations of the ‘tHl’ ruleset and got enough unsatisfactory results that i decided to can it. i was not thrilled to do this, to be sure.

i have somewhat intentionally been allowing my ideas to stew about what to fill into those characters, since i will be performing the piece as my thesis presentation and i’m still doing some research. it no longer worries me that i do not have this content, since i’m bursting at the seams with ideas for what that content should be. what worries me now is that the structure is inadequate, and that i had prematurely settled on such a structure.

my solution has been to use a genetic algorithm to traverse the massive search space and find a ruleset with a reasonably good chance of lasting longer than a few asynchronous turns. i am not modeling sexual reproduction because the bitmasking involved makes it somewhat unwieldy. in other situations breeding would make more sense. Jenny and i just aren’t ready for that just yet. har har har. seriously though, sexual reproduction is terrifying.

so these rulesets don’t breed, they split and mutate. charming, no? i spend most of my time testing them, all 16 variants at a time, 32 times per generation. the variants are then evaluated for their average longevity. in my implementation, since i do plan on sonifying these systems, each player in each game is a routine forked off of the system clock. that is, each turn does take an amount of time, albeit small. i have tuned down this timing element to vary between 1/128 to 1/256 th of a second. i was able to do smaller subdivisions with smaller gene pools, but i decided to go for bigger populations. at the end of each generation, i write out a little data file, keeping track of the population as it evolves, and then remove all but the top 25%. these four are permitted to pass on their genes to 3 other children each, and themselves live on to compete in the next generation.

right now, i’m on my fifth generation. generations take about 20 minutes each and require intermittent input. not the best implementation, but for now it’ll do. i may eventually get this running on its own. perhaps i could distribute the breeding process across the cattri. right now that seems like more trouble than it’s worth, but who knows. there are so many variables at play here that perhaps the only way though is by brute force.

The vocal piece and its corresponding realization as an instrumental piece uses the following algorithm:

Four players share an identical sourcetext, divided into four sections. Each player has all four sections.

Each player has a unique ruleset consisting of four trigger words, each linked to one of the four sections of the sourcetext.

The piece starts with one player starting from anywhere in the text. The player reads aloud ten of the words in the section. Since the player may start anywhere on a given section, the player should wrap up to the top of the section when she hits the end.

When a player hears one of the other three players say one of her trigger words, she must move to the section of the sourcetext associated with that trigger word in her ruleset, beginning anywhere within the section. Players do not trigger themselves. If a trigger word is said that would move her to the same page she is already on, she ignores it.

An end state is reached when all four players have stopped reading.

In the above description I refer to the smallest significant unit of text as words, but this clearly need not be the case. It is actually a much easier prospect to listen for longer events such as phrases or sentences. Scale is a huge factor. For the instrumental realization of this piece I am planning to have my performers listen for musical phrases or contours, not absolute pitch.

I wrote a small class library in SuperCollider for handling simulations of rulesets. There are two classes: a player and a game. In various implementations ( 0 1 2 3 ) I have been using them slightly differently to pull different kinds of data from them. I started by running a few lines of code that generates sourcetexts with pseudorandom numbers. I was able to collapse rulesets and sourcetexts into one axis by keeping the rulesets the same throughout. I used the ascii characters [a-zA-Z] to stand for ‘words’, and the ruleset matrix remains

A    B    C    D

E     F    G    H

I     J    K    L

M     N     O    P

where along the rows are players, and along the columns are sections triggered by the character. Since all other ascii letters trigger nothing, they are interchangeable. What is really significant is where each of the trigger words are placed within the text. To simulate playing the game without turns, I had each player fork off and make moves after pausing for an exponentially weighted random amount of time, spanning from 1x to 2x. I am working, then, with sourcetexts of 52 ‘words’, divided into 4 sections with 13 ‘words’ in each.

When I was first testing this piece out with people, I would start with a sourcetext that I liked, divided it up by hand, and performed word frequency analysis to arrive at a ruleset. This was incredibly labour intensive. Also, I found that despite certain top-down constraints I would work within, such as maintaining a balanced transition matrix or placing trigger words for each player in each sourcetext, etc, the systems would sometimes misbehave. That could mean we’d get stuck in a loop or the system would end prematurely, or that players would miss out on reading a particular section of material entirely. There are so many sensitive factors that go into the initial conditions of this system that to parameterize these and come up with some linear solving strategy seemed way out of my league. And initial conditions aside, the mere fact that these games are played asynchronously provides us with a further level of inconsistency. There was no way I could be sure that my intuitions in composing the rulesets were guiding the outcomes at all! Plus, how many times can you really find four people willing to try out this exercise, even in grad school?

Using this class library, I’m able to test rulesets out at extremely high speeds, in high numbers, and generate massive datasets from the outcomes of those hundreds of games. I started by randomly generating about 50 systems and testing them for longevity, using a metric that makes sense in light of the fact that we can’t measure time in synchronous turns. From this first round, I selected 13 systems whose longevity metrics were significantly higher than the rest, and tested those for longevity, also generating markovian transition matrices to determine the probability of a particular rule being carried out at any time. A more balanced matrix would suggest a more even distribution of sections to be read by players. Finally, I honed in on two systems whose longevity scores were an order of magnitude higher than the others. I ran tests on both systems to determine the average length of a game started by each player. During this process, I selected the system that will become my piece by taking the average longevity score of all the players longevity scores: tHlcqbunKdrifgojIPEDLXwxmNGMQVJRahZBFUkWsOeAyCpTYzvS. I’ve been calling it ‘tHl’ for short. The initial condition preference weights end up thusly: [ 0.26285490520858, 0.45210917667393, 0.18168356048467, 0.10335235763283 ], so player 2 should start ~45% of the time, with player 1 starting ~26% of the time.

To programmatically allow for changes in density, I would like to try having certain non-trigger words resolve to silences. Because I decided this while I was running tests (a nice affordance calculating machines give us is to let us pay attention to how we’re interpreting them), I was keeping track of the number of times a player reached the end of their sourcetext before getting triggered to change to a new section.

Since I am to perform this piece (possibly as the thesis presentation itself!) in May, I have decided to stop there with the analysis / synthesis of systems and get on with replacing those ascii letters with meaningful bits of stuff. However, with a more rigorously organized setup, I could see myself crunching a lot of numbers to come up with something better. With all that data, I would probably be able to come up with alternative realizations / infra-notations of all kinds. One particularly interesting realization could be to produce a statistically analogous outcome using a classical markov chain based on the transition tables I’m getting from the analyses. That would mean very different things, since in the presentation of the piece I’m also trying to frame the performers’ dilemma for the audience. Because the outcomes could potentially be fairly similar, it raises some interesting points (at least to me) about the typical parameters that conventionally comprise an alternative realization.

ps I will be sonifying this system many times over– that’s why I decided to go with SC instead of python.

here’s a simple markovian sample munger written in python2.5.1. should be compatible with 2.6. all bets are off for 3.0.

analyzes wave files. don’t be a joker and run mp3’s through it unless you’re willing to accept the consequences.

it takes a really long time to generate transition tables for each sample. this is mostly because i’m new to python and my programs are not optimized. eventually i’d like to have some flag that lets you save transition tables based on samples so you can generate new soundfiles from old transition tables without having to re-analyze the soundfile. on any reasonable machine hovering around 2 ghz, a one second sample takes a few seconds (<30) to analyze. generating the soundfile may take a few seconds depending on how long a file you asked for. run the script without params to get its usage. usage is also covered in the comment block at the top of the script.

usage (assuming python aliases python2.5 / 2.6):

python markovSamp.py <path-to-infile (unix-legal paths only)> <depth (samples per unit)> <length (number of units in output file> <path-to-outfile (will write to new file if filename doesn’t exist at path)>

happy munging!

ps- I used this script to generate the following stereo signal from one of the Unwashed guys’ dark psy kicks.  They called it ‘the monster’, hence the name.

Markov Monster

it’s really gross. but it works! and I can use it to help me compose. so whatever.

classfile

patch

screenshot

ps – I’ve left a sonification of a 4 player version of this running for my budgie.