def __init__(self, interval_size, *args, **kwargs): #self.obsSeqBuilder= ModuloObsSeq(self.obsSeqBuilder, interval_size) super(RythmHMM, self).__init__(*args, **kwargs) self.params['interval_size']= interval_size self.interval_size= interval_size self.learner= HiddenMarkovLearner() self.hidden_states= set()
class HmmAlgorithm(Algorithm): def __init__(self, channel=None, instrument=None, *args, **kwargs): """ El instrumento que voy a usar para entrenar la HMM """ self.obsSeqBuilder = None if channel is not None: self.obsSeqBuilder = MidiChannelObsSeq(channel) if instrument is not None: self.obsSeqBuilder = MidiPatchObsSeq(instrument) super(HmmAlgorithm, self).__init__(self, *args, **kwargs) # self.obsSeqBuilder= MidiObsSeqOrder3(self.obsSeqBuilder) self.learner = HiddenMarkovLearner() self.hidden_states = set() def train(self, score): obs_seq = self.obsSeqBuilder(score) if not obs_seq: return self.hidden_states.update(imap(lambda x: x[0], obs_seq)) self.learner.train(obs_seq)
def __init__(self, channel=None, instrument=None, *args, **kwargs): """ El instrumento que voy a usar para entrenar la HMM """ self.obsSeqBuilder = None if channel is not None: self.obsSeqBuilder = MidiChannelObsSeq(channel) if instrument is not None: self.obsSeqBuilder = MidiPatchObsSeq(instrument) super(HmmAlgorithm, self).__init__(self, *args, **kwargs) # self.obsSeqBuilder= MidiObsSeqOrder3(self.obsSeqBuilder) self.learner = HiddenMarkovLearner() self.hidden_states = set()
class RythmHMM(Algorithm): def __new__(cls, *args, **kwargs): instance= super(RythmHMM, cls).__new__(cls, *args, **kwargs) instance.params.update(dict(robs_alpha = 0.5, enable_dp_robs = True, global_robs = False)) return instance def __init__(self, interval_size, *args, **kwargs): #self.obsSeqBuilder= ModuloObsSeq(self.obsSeqBuilder, interval_size) super(RythmHMM, self).__init__(*args, **kwargs) self.params['interval_size']= interval_size self.interval_size= interval_size self.learner= HiddenMarkovLearner() self.hidden_states= set() def train(self, score): for instrument in score.instruments: obs_seqs= ModuloObsSeq(InstrumentObsSeq(instrument), self.interval_size).get_observations(score) for obs_seq in obs_seqs: self.hidden_states.update(imap(lambda x:x[0], obs_seq)) self.learner.train(obs_seq) def create_model(self): a_state= iter(self.hidden_states).next() if isinstance(a_state, int): initial_probability= dict( ((s,1.0 if s == 0 else 0) for s in self.hidden_states) ) else: initial_probability= dict( ((s,1.0 if s[1] == 0 else 0) for s in self.hidden_states) ) s= sum(initial_probability.itervalues()) for k, v in initial_probability.iteritems(): initial_probability[k]= v/s hmm= self.learner.get_trainned_model(initial_probability, lambda: RythmModel(interval_size=self.interval_size), random=self.random) hmm.make_walkable() self.model= hmm return hmm def start_creation(self): self.ec= ExecutionContext() self.ec.hmm= self.create_model() self.ec.robses= {} self.ec.actual_interval= 0 self.ec.actual_state= 0 def get_current_robs(self, robsid): if self.params['global_robs']: robs= RandomObservation(self.ec.hmm, random=self.random) else: robs= self.ec.robses.get(robsid) if robs is None: if self.params['enable_dp_robs']: robs= DPRandomObservation(self.ec.hmm, self.params['robs_alpha'], random=self.random) for i in xrange(1000): robs.next() else: #import ipdb;ipdb.set_trace() robs= RandomObservation(self.ec.hmm, random=self.random) self.ec.robses[robsid]= robs robs.actual_state= self.ec.actual_state return robs @produces('start', 'duration') def next(self, input, result, prev_notes): robs= self.get_current_robs(input.get('phrase_id')) last_interval_time= robs.actual_state actual_interval= self.ec.actual_interval #obs= robs.actual_obs() robs.next() self.ec.actual_state= robs.actual_state interval_time= robs.actual_state start= actual_interval*self.interval_size + last_interval_time if interval_time <= last_interval_time: actual_interval+=1 end= actual_interval*self.interval_size + interval_time # actualizo el ec self.ec.actual_interval= actual_interval # esto pasa cuando tenes un salto congruente a 0 modulo interval_size if end == start: import ipdb;ipdb.set_trace() result.start= start result.duration= end-start #result.volume= obs['volume'] #result.pitch= obs['pitch'] def _adjust_interval(self, notes, n_intervals): if notes[-1].start + notes[-1].duration > self.interval_size*n_intervals: notes[-1].duration= self.interval_size*n_intervals - notes[-1].start return notes def move(self, notes, n_intervals): res= [n.copy() for n in notes] for n in res: n.start+= n_intervals*self.interval_size return res def save_info(self, folder, score, params): if len(self.model.state_transition) > 50: print "EL MODELO RITMICO TIENE MAS DE 50 NODOS" return import os self.model.draw(os.path.join(folder, 'rhythm.png'), score.divisions)