/* * Copyright 2006-2007 Columbia University. * * This file is part of MEAPsoft. * * MEAPsoft is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * MEAPsoft is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with MEAPsoft; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA * * See the file "COPYING" for the text of the license. */ package com.meapsoft.composers; import gnu.getopt.Getopt; import java.io.IOException; import java.util.Iterator; import java.util.Vector; import java.util.Arrays; import java.util.Random; import com.meapsoft.ChunkDist; import com.meapsoft.EuclideanDist; import com.meapsoft.DSP; import com.meapsoft.EDLChunk; import com.meapsoft.EDLFile; import com.meapsoft.FeatChunk; import com.meapsoft.FeatFile; import com.meapsoft.MinHeap; import com.meapsoft.ParserException; /** * Program that learns a simple fully connected hidden Markov model * from a FeatFile and generates chunk sequences from it. * * This doesn't produce very compelling compositions because the * markov assumption (that the currect chunk only depends on the * previous chunk) is not at all valid for most music which has a more * complex structure. Later versions will support more constrained HMM * topologies that should make for more interesting compositions. * * All about HMMs: http://en.wikipedia.org/wiki/Hidden_Markov_model * * @author Ron Weiss (ronw@ee.columbia.edu) */ public class HMMComposer extends VQComposer { public static String description = "HMMComposer uses a features file to train a simple statistical model of a song and uses it to randomly generate a new sequence of chunks. This works best when used with chunks created by the beat detector."; private int sequenceLength = 50; // prior probability of starting in a given state private double[] startProbs; // probability of transitioning from one state to another private double[][] transitionMatrix; public HMMComposer(FeatFile trainFN, EDLFile outFN) { super(trainFN, outFN); } public void printUsageAndExit() { System.out.println("Usage: HMMComposer [-options] features.feat \n\n" + " where options include:\n" + " -o output_file the file to write the output to (defaults to "+outFileName+")\n" + " -g debug mode\n" + " -q codebook_size number of states in the HMM (defaults to "+cbSize+")\n" + " -b nbeats number of beats each HMM state should contain (defaults to "+beatsPerCodeword+")\n" + " -s sequence_len length of chunk sequence to generate (defaults to "+sequenceLength+")."); printCommandLineOptions('i'); printCommandLineOptions('d'); printCommandLineOptions('c'); System.out.println(); System.exit(0); } public HMMComposer(String[] args) { // java demands that we do this super(null, null); if(args.length == 0) printUsageAndExit(); Vector features = new Vector(); // Parse arguments String argString = "o:c:q:i:gd:s:b:"; featdim = parseFeatDim(args, argString); dist = parseChunkDist(args, argString, featdim); parseCommands(args, argString); Getopt opt = new Getopt("HMMComposer", args, argString); opt.setOpterr(false); int c = -1; while ((c =opt.getopt()) != -1) { switch(c) { case 'o': outFileName = opt.getOptarg(); break; case 'g': debug = true; break; case 'q': cbSize = Integer.parseInt(opt.getOptarg()); break; case 'b': beatsPerCodeword = Integer.parseInt(opt.getOptarg()); break; case 's': sequenceLength = Integer.parseInt(opt.getOptarg()); break; case 'c': // already handled above break; case 'd': // already handled above break; case 'i': // already handled above break; case '?': printUsageAndExit(); break; default: System.out.print("getopt() returned " + c + "\n"); } } // parse arguments int ind = opt.getOptind(); if(ind > args.length) printUsageAndExit(); trainFile = new FeatFile(args[args.length-1]); outFile = new EDLFile(outFileName); System.out.println("Composing " + outFileName + " from " + args[args.length-1] + "."); } public void setSequenceLength(int len) { sequenceLength = len; } private void learnTransitionMatrix(FeatFile trainFile) { startProbs = new double[cbSize]; Arrays.fill(startProbs, 0); transitionMatrix = new double[cbSize][cbSize]; for(int x = 0; x < cbSize; x++) Arrays.fill(transitionMatrix[x], 0); // sort the chunks in order of increasing startTime, while // keeping all chunks from the same srcFile together trainFile = (FeatFile)trainFile.clone(); trainFile.chunks = new MinHeap(trainFile.chunks); ((MinHeap)trainFile.chunks).sort(); int ndat = trainFile.chunks.size(); int prevState = -1; String lastSrcFile = ""; for(int n = 0; n < ndat; n++) { FeatChunk ch = (FeatChunk)trainFile.chunks.get(n); int currState = quantizeChunk(ch); // is this the beginning of a srcFile? if(!lastSrcFile.equals(ch.srcFile)) { lastSrcFile = ch.srcFile; startProbs[currState] += 1.0; } else transitionMatrix[prevState][currState] += 1.0; prevState = currState; } // normalize probabilities double s = DSP.sum(startProbs); for(int x = 0; x < startProbs.length; x++) startProbs[x] /= s; for(int x = 0; x < transitionMatrix.length; x++) { s = DSP.sum(transitionMatrix[x]); for(int y = 0; y < transitionMatrix[x].length; y++) transitionMatrix[x][y] /= s; } if(debug) { FeatFile f = new FeatFile("tmp"); f.chunks = templateChunks; DSP.imagesc(f.getFeatures(), "codebook"); DSP.imagesc(transitionMatrix, "transitionMatrix"); DSP.imagesc(startProbs, "startProbs"); } } private int multinomialSample(double uniformRV, double[] prob) { if(uniformRV <= prob[0]) return 0; double[] cdf = DSP.cumsum(prob); for(int x = 1; x < cdf.length; x++) if(uniformRV > cdf[x-1] && uniformRV <= cdf[x]) return x; return prob.length; } public EDLFile compose() { learnCodebook(trainFile); learnTransitionMatrix(trainFile); // generate a sequence of chunks from the codebook and // transition matrix Random rand = new Random(); double currTime = 0; // get first chunk from startProbs int lastIdx = multinomialSample(rand.nextDouble(), startProbs); EDLChunk nc = new EDLChunk((FeatChunk)templateChunks.get(lastIdx), currTime); outFile.chunks.add(nc); currTime += nc.length; progress.setValue(progress.getValue()+1); // use transitionMatrix for the remaining chunks for(int x = 1; x < sequenceLength; x++) { int currIdx = multinomialSample(rand.nextDouble(), transitionMatrix[lastIdx]); nc = new EDLChunk((FeatChunk)templateChunks.get(currIdx), currTime); outFile.chunks.add(nc); currTime += nc.length; progress.setValue(progress.getValue()+1); lastIdx = currIdx; } return outFile; } public static void main(String[] args) { HMMComposer m = new HMMComposer(args); long startTime = System.currentTimeMillis(); m.run(); System.out.println("Done. Took " + ((System.currentTimeMillis() - startTime)/1000.0) + "s"); System.exit(0); } }