def run(self, tuple_in): shape, midi_in = tuple_in pianorolls = self.decoder.encode_midi_to_pianoroll(midi_in, shape) # fill in the silences masks = lib_sampling.CompletionMasker()(pianorolls) gibbs = self.make_sampler("gibbs", masker=lib_sampling.BernoulliMasker(), sampler=self.make_sampler( "independent", temperature=FLAGS.temperature), schedule=lib_sampling.YaoSchedule()) with self.logger.section("context"): context = np.array([ lib_mask.apply_mask(pianoroll, mask) for pianoroll, mask in zip(pianorolls, masks) ]) self.logger.log(pianorolls=context, masks=masks, predictions=context) pianorolls = gibbs(pianorolls, masks) with self.logger.section("result"): self.logger.log(pianorolls=pianorolls, masks=masks, predictions=pianorolls) return pianorolls
def run(self, pianorolls, masks=None, sample_steps=0, current_step=0, total_gibbs_steps=0, temperature=0.99): """Given input pianorolls, runs Gibbs sampling to fill in the rest. When total_gibbs_steps is 0, total_gibbs_steps is set to time * instruments. If faster sampling is desired on the expanse of sample quality, total_gibbs_steps can be explicitly set to a lower number, possibly to the value of sample_steps if do not plan on stopping sample early to obtain intermediate results. This function can be used to return intermediate results by setting the sample_steps to when results should be returned and leaving total_gibbs_steps to be 0. To continue sampling from intermediate results, set current_step to the number of steps taken, and feed in the intermediate pianorolls. Again leaving total_gibbs_steps as 0. Builds the graph and restores checkpoint if necessary. Args: pianorolls: a 4D numpy array of shape (batch, time, pitch, instrument) masks: a 4D numpy array of the same shape as pianorolls, with 1s indicating mask out. If is None, then the masks will be where have 1s where there are no notes, indicating to the model they should be filled in. sample_steps: an integer indicating the number of steps to sample in this call. If set to 0, then it defaults to total_gibbs_steps. current_step: an integer indicating how many steps might have already sampled before. total_gibbs_steps: an integer indicating the total number of steps that a complete sampling procedure would take. temperature: a float indicating the temperature for sampling from softmax. Returns: A dictionary, consisting of "pianorolls" which is a 4D numpy array of the sampled results and "time_taken" which is the time taken in sampling. """ if self.sess is None: # Build graph and restore checkpoint. self.instantiate_sess_and_restore_checkpoint() outer_masks = masks if outer_masks is None: outer_masks = lib_sampling.CompletionMasker()(pianorolls) start_time = time.time() new_piece = self.sess.run( self.samples, feed_dict={ self.placeholders["pianorolls"]: pianorolls, self.placeholders["outer_masks"]: outer_masks, self.placeholders["sample_steps"]: sample_steps, self.placeholders["total_gibbs_steps"]: total_gibbs_steps, self.placeholders["current_step"]: current_step, self.placeholders["temperature"]: temperature }) label = "independent blocked gibbs" time_taken = (time.time() - start_time) / 60.0 tf.logging.info("exit %s (%.3fmin)" % (label, time_taken)) return dict(pianorolls=new_piece, time_taken=time_taken)