jazzparser.taggers.segmidi.chordclass.train

53 """ 54 Evaluates the forward/backward probability matrices for a 55 single sequence under the model that came from the previous 56 iteration and returns matrices that contain the updates 57 to be made to the distributions during this iteration. 58 59 This is wrapped up in a function so it can be run in 60 parallel for each sequence. Once all sequences have been 61 evaluated, the results are combined and model updated. 62 63 @type update_initial: bool 64 @param update_initial: usually you want to update all distributions, 65 including the initial state distribution. If update_initial=False, 66 the initial state distribution updates won't be made for this sequence. 67 We want this when the sequence is actually a non-initial fragment of 68 a longer sequence 69 @type catch_interrupt: bool 70 @param catch_interrupt: catch KeyboardInterrupt exceptions and return 71 None. This is useful behaviour when calling this in a process pool, 72 since it allows the parent process to handle the interrupt, but should 73 be set to False (default) if calling directly. 74 75 """ 76 try: 77 # Get the sizes we'll need for the matrix 78 num_schemata = len(last_model.schemata) 79 num_root_changes = 12 80 num_chord_classes = len(last_model.chord_classes) 81 num_emission_conds = len(emission_cond_ids) 82 num_emissions = 12 83 84 T = len(sequence) 85 86 state_ids = dict([(state,id) for (id,state) in \ 87 enumerate(last_model.label_dom)]) 88 89 # Local versions of the matrices store the accumulated values 90 # for just this sequence (so we can normalize before adding 91 # to the global matrices) 92 # The numerators 93 schema_trans = zeros((num_schemata,num_schemata+1), float64) 94 root_trans = zeros((num_schemata,num_schemata,num_root_changes), float64) 95 ems = zeros((num_emission_conds,num_emissions), float64) 96 sinit = zeros(num_schemata, float64) 97 98 # Compute the forward and backward probabilities 99 # These are normalized, but that makes no difference to the outcome of 100 # compute_gamma and compute_xi 101 alpha,scale,seq_logprob = last_model.normal_forward_probabilities(sequence, array=True) 102 beta,scale = last_model.normal_backward_probabilities(sequence, array=True) 103 # gamma contains the state occupation probability for each state at each 104 # timestep 105 gamma = last_model.compute_gamma(sequence, forward=alpha, backward=beta) 106 # xi contains the probability of every state transition at every timestep 107 xi = last_model.compute_xi(sequence, forward=alpha, backward=beta) 108 109 # Update the initial state distribution if requested 110 if update_initial: 111 for state in label_dom: 112 schema, root, chord_class = state 113 schema_i = schema_ids[schema] 114 # Add this contribution to the sum of the states with this schema 115 sinit[schema_i] += gamma[0][state_ids[state]] 116 117 for time in range(T): 118 for state in label_dom: 119 schema, root, chord_class = state 120 schema_i = schema_ids[schema] 121 state_i = state_ids[state] 122 123 if time < T-1: 124 # Go through all possible pairs of states to update the 125 # transition distributions 126 for next_state in label_dom: 127 next_schema, next_root, next_chord_class = next_state 128 schema_j = schema_ids[next_schema] 129 state_j = state_ids[next_state] 130 131 ## Transition dist update ## 132 root_change = (next_root - root) % 12 133 schema_trans[schema_i][schema_j] += \ 134 xi[time][state_i][state_j] 135 root_trans[schema_i][schema_j][root_change] += \ 136 xi[time][state_i][state_j] 137 else: 138 # Final state: update the probs of transitioning to end 139 schema_trans[schema_i][num_schemata] += gamma[T-1][state_i] 140 141 ## Emission dist update ## 142 # Add the state occupation probability to the emission numerator 143 # for every note 144 for pc,beat in sequence[time]: 145 # Take the pitch class relative to the root 146 rel_pc = (pc - root) % 12 147 ems[emission_cond_ids[(chord_class,beat)]][rel_pc] += \ 148 gamma[time][state_i] 149 150 # Calculate the denominators 151 schema_trans_denom = array_sum(schema_trans, axis=1) 152 root_trans_denom = array_sum(root_trans, axis=2) 153 ems_denom = array_sum(ems, axis=1) 154 # This should come to 1.0 155 sinit_denom = array_sum(sinit) 156 157 # Wrap this all up in a tuple to return to the master 158 return (schema_trans, root_trans, ems, sinit, \ 159 schema_trans_denom, root_trans_denom, ems_denom, sinit_denom, \ 160 seq_logprob) 161 except KeyboardInterrupt: 162 if catch_interrupt: 163 return 164 else: 165 raise

170 """ 171 Class with methods to retrain a chordclass model using the Baum-Welch 172 EM algorithm. 173 174 Module options must be processed already - we do that in the 175 ChordClassTaggerModel, not here. 176 177 @todo: Inherit from the 178 L{jazzparser.utils.nltk.ngram.baumwelch.BaumWelchTrainer}. Currently, 179 the generic trainer duplicates a lot of this code, since it was based on 180 it. 181 182 """ 183 # These will be included in the training options 184 OPTIONS = [ 185 ModuleOption('max_iterations', filter=int, 186 help_text="Number of training iterations to give up after "\ 187 "if we don't reach convergence before.", 188 usage="max_iterations=N, where N is an integer", default=100), 189 ModuleOption('convergence_logprob', filter=float, 190 help_text="Difference in overall log probability of the "\ 191 "training data made by one iteration after which we "\ 192 "consider the training to have converged.", 193 usage="convergence_logprob=X, where X is a small floating "\ 194 "point number (e.g. 1e-3)", default=1e-3), 195 ModuleOption('split', filter=int, 196 help_text="Limits the length of inputs by splitting them into "\ 197 "fragments of at most this length. The initial state "\ 198 "distribution will only be updated for the initial fragments.", 199 usage="split=X, where X is an int"), 200 ModuleOption('truncate', filter=int, 201 help_text="Limits the length of inputs by truncating them to this "\ 202 "number of timesteps. Truncation is applied before splitting.", 203 usage="truncate=X, where X is an int"), 204 ModuleOption('save_intermediate', filter=str_to_bool, 205 help_text="Save the model between iterations", 206 usage="save_intermediate=B, where B is 'true' or 'false' "\ 207 "(default true)", 208 default=True), 209 ModuleOption('trainprocs', filter=int, 210 help_text="Number of processes to spawn during training. Use -1 "\ 211 "to spawn a process for every sequence.", 212 usage="trainprocs=P, where P is an integer", 213 default=1), 214 ] 215

216 - def __init__(self, model, options={}):

217 self.model = model 218 self.options = options

219

220 - def train(self, emissions, logger=None, save_callback=None):

221 """ 222 Performs unsupervised training using Baum-Welch EM. 223 224 This is performed on a model that has already been initialized. 225 You might, for example, create such a model using 226 L{jazzparser.taggers.segmidi.chordclass.hmm.ChordClassHmm.initialize_chord_classes}. 227 228 This is based on the training procedure in NLTK for HMMs: 229 C{nltk.tag.hmm.HiddenMarkovModelTrainer.train_unsupervised}. 230 231 @type emissions: L{jazzparser.data.input.MidiTaggerTrainingBulkInput} or 232 list of L{jazzparser.data.input.Input}s 233 @param emissions: training MIDI data 234 @type logger: logging.Logger 235 @param logger: a logger to send progress logging to 236 237 """ 238 if logger is None: 239 from jazzparser.utils.loggers import create_dummy_logger 240 logger = create_dummy_logger() 241 242 self.model.add_history("Beginning Baum-Welch training on %s" % get_host_info_string()) 243 self.model.add_history("Training on %d MIDI sequences (with %s segments)" % \ 244 (len(emissions), ", ".join("%d" % len(seq) for seq in emissions))) 245 logger.info("Beginning Baum-Welch training on %s" % get_host_info_string()) 246 247 # Get some options out of the module options 248 max_iterations = self.options['max_iterations'] 249 convergence_logprob = self.options['convergence_logprob'] 250 split_length = self.options['split'] 251 truncate_length = self.options['truncate'] 252 save_intermediate = self.options['save_intermediate'] 253 processes = self.options['trainprocs'] 254 255 # Make a mutable distribution for each of the distributions 256 # we'll be updating 257 emission_mdist = cond_prob_dist_to_dictionary_cond_prob_dist( 258 self.model.emission_dist, mutable=True) 259 schema_trans_mdist = cond_prob_dist_to_dictionary_cond_prob_dist( 260 self.model.schema_transition_dist, mutable=True) 261 root_trans_mdist = cond_prob_dist_to_dictionary_cond_prob_dist( 262 self.model.root_transition_dist, mutable=True) 263 init_state_mdist = prob_dist_to_dictionary_prob_dist( 264 self.model.initial_state_dist, mutable=True) 265 266 # Get the sizes we'll need for the matrices 267 num_schemata = len(self.model.schemata) 268 num_root_changes = 12 269 num_chord_classes = len(self.model.chord_classes) 270 if self.model.metric: 271 num_emission_conds = num_chord_classes * 4 272 else: 273 num_emission_conds = num_chord_classes 274 num_emissions = 12 275 276 # Enumerations to use for the matrices, so we know what they mean 277 schema_ids = dict([(sch,i) for (i,sch) in enumerate(self.model.schemata+[None])]) 278 if self.model.metric: 279 rs = range(4) 280 else: 281 rs = [0] 282 emission_cond_ids = dict([(cc,i) for (i,cc) in enumerate(\ 283 sum([[ 284 (str(cclass.name),r) for r in rs] for cclass in self.model.chord_classes], 285 []))]) 286 287 # Construct a model using these mutable distributions so we can 288 # evaluate using them 289 model = ChordClassHmm(schema_trans_mdist, 290 root_trans_mdist, 291 emission_mdist, 292 self.model.emission_number_dist, 293 init_state_mdist, 294 self.model.schemata, 295 self.model.chord_class_mapping, 296 self.model.chord_classes, 297 metric=self.model.metric, 298 illegal_transitions=self.model.illegal_transitions, 299 fixed_root_transitions=self.model.fixed_root_transitions) 300 301 def _save(): 302 if save_callback is None: 303 logger.error("Could not save model, as no callback was given") 304 else: 305 # If the writing fails, wait till I've had a chance to sort it 306 # out and then try again. This happens when my AFS token runs 307 # out 308 while True: 309 try: 310 save_callback() 311 except (IOError, OSError), err: 312 print "Error writing model to disk: %s. " % err 313 raw_input("Press <enter> to try again... ") 314 else: 315 break

316 317 ########## Data preprocessing 318 # Preprocess the inputs so they're ready for the model training 319 emissions = [midi_to_emission_stream(seq, 320 metric=self.model.metric, 321 remove_empty=False)[0] \ 322 for seq in emissions] 323 logger.info("%d input sequences" % len(emissions)) 324 # Truncate long streams 325 if truncate_length is not None: 326 logger.info("Truncating sequences to max %d timesteps" % \ 327 truncate_length) 328 emissions = [stream[:truncate_length] for stream in emissions] 329 # Split up long streams if requested 330 # After this, each stream is a tuple (first,stream), where first 331 # indicates whether the stream segment begins a song 332 if split_length is not None: 333 logger.info("Splitting sequences into max %d-sized chunks" % \ 334 split_length) 335 split_emissions = [] 336 # Split each stream 337 for emstream in emissions: 338 input_ems = emstream 339 splits = [] 340 first = True 341 # Take bits of length split_length until we're under the max 342 while len(input_ems) >= split_length: 343 # Overlap the splits by one so we get all transitions 344 splits.append((first, input_ems[:split_length])) 345 input_ems = input_ems[split_length-1:] 346 first = False 347 # Get the last short one 348 if len(input_ems): 349 splits.append((first, input_ems)) 350 split_emissions.extend(splits) 351 else: 352 # All streams begin a song 353 split_emissions = [(True,stream) for stream in emissions] 354 logger.info("Sequence lengths after preprocessing: %s" % 355 " ".join([str(len(em[1])) for em in split_emissions])) 356 ########## 357 358 # Train the emission number distribution on this data to start with 359 # This doesn't get updated by the iterative steps, because it's not 360 # dependent on chord classes 361 model.train_emission_number_distribution(emissions) 362 logger.info("Trained emission number distribution") 363 # Save the model with this 364 if save_intermediate: 365 _save() 366 367 ############### 368 # TODO: remove this section - it's for debugging 369 if False: 370 from jazzparser.prototype.baumwelch import TempBaumWelchTrainer 371 temptrainer = TempBaumWelchTrainer(model, self.options) 372 temptrainer.train(split_emissions, logger=logger) 373 return 374 ############### 375 376 # Special case of -1 for number of sequences 377 # No point in creating more processes than there are sequences 378 if processes == -1 or processes > len(split_emissions): 379 processes = len(split_emissions) 380 381 iteration = 0 382 last_logprob = None 383 try: 384 while iteration < max_iterations: 385 logger.info("Beginning iteration %d" % iteration) 386 current_logprob = 0.0 387 388 ### Matrices in which to accumulate new probability estimates 389 # trans contains new transition numerator probabilities 390 # TODO: update this... 391 # trans[s][s'][dr] = Sum_{t_n=t_(n+1), m_n=m_(n+1),c_n=c,c_(n+1)=c'} 392 # alpha(x_n).beta(x_(n+1)). 393 # p(x_(n+1)|x_n).p(y_(n+1)|x_(n+1)) 394 schema_trans = zeros((num_schemata,num_schemata+1), float64) 395 root_trans = zeros((num_schemata,num_schemata,num_root_changes), float64) 396 # ems contains the new emission numerator probabilities 397 # TODO: update this... 398 # ems[r][d] = Sum_{d(y_n^k, x_n)=d, r_n^k=r} 399 # alpha(x_n).beta(x_n) / 400 # Sum_{x'_n} (alpha(x'_n).beta(x'_n)) 401 ems = zeros((num_emission_conds,num_emissions), float64) 402 # sinit contains the initial state numerator probabilities 403 sinit = zeros(num_schemata, float64) 404 # And these are the denominators 405 schema_trans_denom = zeros(num_schemata, float64) 406 root_trans_denom = zeros((num_schemata,num_schemata), float64) 407 ems_denom = zeros(num_emission_conds, float64) 408 # It may seem silly to use a matrix for this, but it allows 409 # us to update it in the callback 410 sinit_denom = zeros(1, float64) 411 412 def _training_callback(result): 413 """ 414 Callback for the _sequence_updates processes that takes 415 the updates from a single sequence and adds them onto 416 the global update accumulators. 417 418 """ 419 if result is None: 420 # Process cancelled: do no updates 421 logger.warning("Child process was cancelled") 422 return 423 # _sequence_updates() returns all of this as a tuple 424 (schema_trans_local, root_trans_local, ems_local, sinit_local, \ 425 schema_trans_denom_local, root_trans_denom_local, \ 426 ems_denom_local, sinit_denom_local, \ 427 seq_logprob) = result 428 429 # Add these probabilities from this sequence to the 430 # global matrices 431 # We don't need to scale these using the seq prob because 432 # they're already normalized 433 434 # Emission numerator 435 array_add(ems, ems_local, ems) 436 # Transition numerator 437 array_add(schema_trans, schema_trans_local, schema_trans) 438 array_add(root_trans, root_trans_local, root_trans) 439 # Initial state numerator 440 array_add(sinit, sinit_local, sinit) 441 # Denominators 442 array_add(ems_denom, ems_denom_local, ems_denom) 443 array_add(schema_trans_denom, schema_trans_denom_local, schema_trans_denom) 444 array_add(root_trans_denom, root_trans_denom_local, root_trans_denom) 445 array_add(sinit_denom, sinit_denom_local, sinit_denom)

Source Code for Module jazzparser.taggers.segmidi.chordclass.train