def build_network(self, build_encoder=True):
if build_encoder:
self.encoder = Encoder(self._hp)
self.decoder = DecoderModule(self._hp, # infer actions in decoder if not using SH-Pred model
regress_actions=self._hp.regress_actions and self._hp.one_step_planner is not 'sh_pred')
self.build_inference()
if self._hp.regress_length:
self.length_pred = LengthPredictorModule(self._hp)
self.build_inference_encoder()
if self._hp.attach_inv_mdl:
self.inv_mdl = InverseModel(self._hp.inv_mdl_params, self._logger)
if self._hp.attach_cost_mdl:
self.cost_mdl = CostModel(self._hp.cost_mdl_params, self._logger)
if self._hp.attach_state_regressor:
self.state_regressor = BaseProcessingNet(self._hp.nz_enc, self._hp.nz_mid, self._hp.state_dim,
self._hp.n_processing_layers, self._hp.fc_builder)
if self._hp.separate_cnn_start_goal_encoder:
from blox.torch.layers import LayerBuilderParams
from tensorflow.contrib.training import HParams
with_conv_hp = HParams()
for k in self._hp.values().keys():
with_conv_hp.add_hparam(k, self._hp.values()[k])
#with_conv_hp = self._hp
with_conv_hp.set_hparam('use_convs', True)
with_conv_hp.set_hparam('input_nc', 3)
with_conv_hp.set_hparam('builder', LayerBuilderParams(
True, self._hp.use_batchnorm, self._hp.normalization, self._hp.predictor_normalization))
self.start_goal_enc = Encoder(with_conv_hp)
def _default_hparams(self):
# Data Dimensions
default_dict = AttrDict({
'batch_size': -1,
'max_seq_len': -1,
'n_actions': -1,
'state_dim': -1,
'input_nc': 3, # number of input feature maps
'device': None,
'data_conf': None,
'img_sz': None,
'goal_cond': True
})
# Network params
default_dict.update({
'use_convs': True,
'use_batchnorm': True, # TODO deprecate
'normalization': 'batch',
})
# add new params to parent params
parent_params = HParams()
for k in default_dict.keys():
parent_params.add_hparam(k, default_dict[k])
return parent_params
def _default_hparams(self):
# put new parameters in here:
default_dict = {
'model': None,
'model_test': None,
'logger': None,
'logger_test': None,
'data_dir': None, # directory where dataset is in
'batch_size': 64,
'mpar': None, # model parameters
'data_conf': None, # model parameters
'exp_path': None, # Path to the folder with experiments
'num_epochs': 200,
'epoch_cycles_train': 1,
'mujoco_xml': None,
'optimizer': 'adam', # supported: 'adam', 'rmsprop', 'sgd'
'lr': 1e-3,
'momentum': 0, # momentum in RMSProp / SGD optimizer
'adam_beta': 0.9, # beta1 param in Adam
}
# add new params to parent params
parent_params = HParams()
for k in default_dict.keys():
parent_params.add_hparam(k, default_dict[k])
return parent_params
def _default_hparams(self):
default_dict = {
'save_format': ['hdf5', 'raw'],
'save_data': True,
'agent': {},
'policy': {},
'start_index': -1,
'end_index': -1,
'ntraj': -1,
'gpu_id': -1,
'current_dir': '',
'record_saver': None,
'counter': None,
'traj_per_file': 10,
'data_save_dir': '',
'log_dir': '',
'result_dir': '',
'split_train_val_test': True,
'logging_conf': None, # only needed for training loop
}
# add new params to parent params
parent_params = HParams()
for k in default_dict.keys():
parent_params.add_hparam(k, default_dict[k])
return parent_params
def _default_hparams(self):
default_dict = {
'T': None,
'adim': None,
'sdim': None,
'ncam': 1,
'rejection_sample': False, # repeatedly attemp to collect a trajectory if error occurs
'type': None,
'env': None,
'image_height': 48,
'image_width': 64,
'nchannels': 3,
'data_save_dir': '',
'log_dir': '',
'make_final_gif': True, # whether to make final gif
'make_final_gif_freq': 1, # final gif, frequency
'make_final_gif_pointoverlay': False,
'gen_xml': (True, 1), # whether to generate xml, and how often
'start_goal_confs': None,
'show_progress': False,
'state_resets': False, # reset the simluator state zeroing velocities according to policies replan frequency
'do_not_save_images': False # dataset savers will not save images if True
}
# add new params to parent params
parent_params = HParams()
for k in default_dict.keys():
parent_params.add_hparam(k, default_dict[k])
return parent_params
def _default_hparams(self):
# put new parameters in here:
default_dict = {
'model': None,
'logger': None,
'dataset_name': None, # directory where dataset is in
'batch_size': 64,
'exp_path': None, # Path to the folder with experiments
'num_epochs': 200,
'epoch_cycles_train': 1,
'optimizer':
'radam', # supported: 'radam', 'adam', 'rmsprop', 'sgd'
'lr': None,
'gradient_clip': None,
'momentum': 0, # momentum in RMSProp / SGD optimizer
'adam_beta': 0.9, # beta1 param in Adam
'metric_pruning_scheme': 'dtw',
'top_of_100_eval': True,
'n_rooms': None,
}
# add new params to parent params
parent_params = HParams()
for k in default_dict.keys():
parent_params.add_hparam(k, default_dict[k])
return parent_params
def args2hparam(args, vocab):
params = vars(args)
params['vocab'] = vocab
p = HParams()
for k, v in params.items():
p.add_hparam(k, v)
return p
def set_params() -> HParams:
params = HParams(coin_pairs = ["BTC_BTS", "BTC_ZEC", "BTC_STRAT", "BTC_XEM", "BTC_STEEM", "BTC_LTC", "BTC_ETC",
"BTC_XRP", "BTC_XMR", "BTC_DASH", "BTC_ETH", "BTC_STR", "BTC_LSK", "BTC_DOGE",
"BTC_SC", "BTC_SYS", "BTC_DGB", "BTC_MAID", "BTC_NXT", "BTC_BCN"],
num_input_channels=5,
live_bot_num_models=5,
len_conv3_filters=1,) # currently only 1x1 filters for conv3 possible
params.add_hparam("num_coins", len(params.coin_pairs))
return params
def merge_hparams(p1, p2):
params = HParams()
v1 = p1.values()
v2 = p2.values()
for (k, v) in v1.items():
params.add_hparam(k, v)
for (k, v) in v2.items():
params.add_hparam(k, v)
return params
def new_hparam(yaml_fn, config_name):
hparam = HParams()
with open(yaml_fn) as fp:
for k, v in YAML().load(fp)[config_name].items():
if isinstance(v, str) and v[0:2] == 'tf':
hparam.add_hparam(k, eval(v))
else:
hparam.add_hparam(k, v)
return hparam
def run_experiment(self, experiment_fn):
"""Run the training experiment."""
# Define model parameters
hparams = HParams()
for k, v in self.default_param_dict.items():
hparams.add_hparam(k, v)
learn_runner.run(
experiment_fn=experiment_fn, # First-class function
run_config=self.run_config, # RunConfig
schedule="train_and_evaluate", # What to run
hparams=hparams # HParams
)
def parse_yaml(yaml_path, model_id):
from tensorflow.contrib.training import HParams
from ruamel.yaml import YAML
hparams = HParams()
hparams.add_hparam('model_id', model_id)
with open(yaml_path) as fp:
customized = YAML().load(fp)
for k, v in customized.items():
if k in hparams:
hparams.set_hparam(k, v)
else:
hparams.add_hparam(k, v)
return hparams
def _default_hparams(self):
# Data Dimensions
default_dict = AttrDict({
'batch_size': -1,
'max_seq_len': -1,
'n_actions': -1,
'state_dim': -1,
'img_sz': 32, # image resolution
'input_nc': 3, # number of input feature maps
'n_conv_layers':
None, # Number of conv layers. Can be of format 'n-<int>' for any int for relative spec
})
# Network params
default_dict.update({
'use_convs': True,
'use_batchnorm': True, # TODO deprecate
'normalization': 'batch',
'predictor_normalization': 'group',
})
# Misc params
default_dict.update({
'filter_repeated_tail':
False, # whether to remove repeated states from the dataset
'rep_tail': False,
'dataset_class': None,
'standardize': None,
'split': None,
'subsampler': None,
'subsample_args': None,
'checkpt_path': None,
})
# add new params to parent params
parent_params = HParams()
for k in default_dict.keys():
parent_params.add_hparam(k, default_dict[k])
return parent_params
def _fetch_model_specific_hparams(network_class, network_type, models_dir):
model_hparams = HParams(model_class=None)
if network_class is not None and network_type is not None:
model_module_name = 'model_%s' % network_type
model_class_name = underline_to_camel(model_module_name)
try:
src_module = __import__(
'%s.%s.%s' %
(models_dir, network_class, model_module_name))
model_class = eval(
'src_module.models.%s.%s.%s' %
(network_class, model_module_name, model_class_name))
model_hparams = model_class.get_default_model_parameters()
model_hparams.add_hparam('model_class',
model_class) # add model class
except ImportError:
print('Fatal Error: no model module: \"src.models.%s.%s\"' %
(network_class, model_module_name))
except AttributeError:
print(
'Fatal Error: probably (1) no model class named as %s.%s, '
'or (2) the class no \"get_default_model_parameters()\"' %
(network_class, model_module_name))
return model_hparams
class HParamsCenter(object):
default_namespace = 'other_hparams'
def __init__(self,
default_preprocessing_hparams=None,
default_model_hparams=None,
default_training_hparams=None,
models_dir="src.models"):
self.hparams_dict = defaultdict(HParams)
self.models_dir = models_dir
# parsed
args = self._parsed_args()
self.parsed_hparams = HParams()
for key, val in args.__dict__.items():
self.parsed_hparams.add_hparam(key, val)
self.register_hparams(self.parsed_hparams, 'parsed_hparams')
# pre-processing
self.preprocessing_hparams = default_preprocessing_hparams or HParams()
self.preprocessing_hparams.parse(
self.parsed_hparams.preprocessing_hparams)
self.register_hparams(self.preprocessing_hparams,
'preprocessing_hparams')
# model
self.model_hparams = default_model_hparams or HParams()
self.model_hparams = merge_hparams(
self.model_hparams,
self._fetch_model_specific_hparams(
self.parsed_hparams.network_class,
self.parsed_hparams.network_type, self.models_dir))
self.model_hparams.parse(self.parsed_hparams.model_hparams)
self.register_hparams(self.model_hparams, 'model_hparams')
# traning
self.training_hparams = default_training_hparams or HParams()
self.training_hparams.parse(self.parsed_hparams.training_hparams)
self.register_hparams(self.training_hparams, 'training_hparams')
@staticmethod
def _fetch_model_specific_hparams(network_class, network_type, models_dir):
model_hparams = HParams(model_class=None)
if network_class is not None and network_type is not None:
model_module_name = 'model_%s' % network_type
model_class_name = underline_to_camel(model_module_name)
try:
src_module = __import__(
'%s.%s.%s' %
(models_dir, network_class, model_module_name))
model_class = eval(
'src_module.models.%s.%s.%s' %
(network_class, model_module_name, model_class_name))
model_hparams = model_class.get_default_model_parameters()
model_hparams.add_hparam('model_class',
model_class) # add model class
except ImportError:
print('Fatal Error: no model module: \"src.models.%s.%s\"' %
(network_class, model_module_name))
except AttributeError:
print(
'Fatal Error: probably (1) no model class named as %s.%s, '
'or (2) the class no \"get_default_model_parameters()\"' %
(network_class, model_module_name))
return model_hparams
@staticmethod
def _parsed_args():
parser = argparse.ArgumentParser()
parser.register('type', 'bool', (lambda x: x.lower() in
("yes", "true", "t", "1")))
parser.add_argument('--mode', type=str, default='train', help='')
parser.add_argument('--dataset', type=str, default='none', help='')
parser.add_argument('--network_class',
type=str,
default='transformer',
help='')
parser.add_argument('--network_type', type=str, default=None, help='')
parser.add_argument('--gpu',
type=str,
default='3',
help='selected gpu index')
parser.add_argument('--gpu_mem',
type=float,
default=None,
help='selected gpu index')
parser.add_argument('--model_dir_prefix',
type=str,
default='prefix',
help='model dir name prefix')
parser.add_argument('--machine',
type=str,
default='none',
help='using aws')
# parsing parameters group
parser.add_argument('--preprocessing_hparams',
type=str,
default='',
help='')
parser.add_argument('--model_hparams', type=str, default='', help='')
parser.add_argument('--training_hparams',
type=str,
default='',
help='')
parser.set_defaults(shuffle=True)
return parser.parse_args()
def register_hparams(self, hparams, name):
assert isinstance(hparams, HParams)
assert isinstance(name, str)
if name in self.hparams_dict:
self.hparams_dict[name] = merge_hparams(self.hparams_dict[name],
hparams)
else:
self.hparams_dict[name] = hparams
@property
def all_hparams(self):
all_hparams = HParams()
for name, hp in self.hparams_dict.items():
all_hparams = merge_hparams(all_hparams, hp)
return all_hparams
def __setitem__(self, key, value):
assert isinstance(key, str)
# this is added to the default
# self.hparams_dict[self.default_namespace][key] = value
key_found = False
for _, hps in self.hparams_dict.items():
try:
if key in hps:
key_found = True
# when tf==1.4.1, directly use "in" will raise TypeError: argument of type 'HParams' is not iterable
except TypeError:
if key in hps.values():
key_found = True
if key_found:
hps.set_hparam(key, value)
break
if not key_found: # not found, set it
self.hparams_dict[self.default_namespace].add_hparam(key, value)
def __getitem__(self, item):
assert isinstance(item, str)
for name, hp in self.hparams_dict.items():
try:
return getattr(hp, item)
except AttributeError:
pass
raise AttributeError('no item named as \'%s\'' % item)
def __contains__(self, item):
if isinstance(item, str):
for key, hps in self.hparams_dict.items():
try:
if item in hps:
return True
# when tf==1.4.1, directly use "in" will raise TypeError: argument of type 'HParams' is not iterable
except TypeError:
if item in hps.values():
return True
return False
class TunatorLSTM:
"""
LSTM model for synthesizing polyphonic MIDI.
When the class is instantiated,
the `update_datastore` method ensures that all the MIDI data from the
files in `midi_dir` are stored in the HDF5 at `hdf5_path`. It queries the
datastore for the song names in `midi_dir` using the `query_datastore`
method, then updates it with any missing songs. The datastore schema is
provided in the `update_datastore` method docstring.
The model is instantiated either via `build_model` or `load_model` and
trained via `train`. The model can be sampled via `compose`, which will
output a MIDI file.
Args:
midi_dir (str): directory to MIDI files
hdf5_path (str): path for HDF5 datastore
hparams (dict): any hyperparameters to be changed from defaults.
Defaults are shown under `hparams` property. They can also be
changed dynamically by passing a dict to the `hparams` setter.
"""
def __init__(self,
midi_dir='music/midi/final_fantasy/',
hdf5_path='data/songs.hdf5',
hparams=None):
self.midi_dir = midi_dir
self.hdf5_path = hdf5_path
self._hparams = hparams
# set up piano roll
octaves = 10
scale = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
sharps = ['A#', 'C#', 'D#', 'F#', 'G#']
flats = ['B-', 'D-', 'E-', 'G-', 'A-']
sharps_scale = sorted(scale + sharps)
sharps_oct = [note + str(i) for i in range(octaves) for note in sharps]
flats_oct = [note + str(i) for i in range(octaves) for note in flats]
flat_sharp_dict = dict(zip(flats_oct, sharps_oct))
self.piano_roll = [
note + str(i) for i in range(octaves) for note in sharps_scale
]
self.piano_roll_dict = {
note: i
for i, note in enumerate(self.piano_roll)
}
self.piano_roll_dict.update({
flat: self.piano_roll_dict[sharp]
for flat, sharp in flat_sharp_dict.items()
})
# prepare data
self.song_file_dict = self.get_song_file_dict()
songs = list(self.song_file_dict)
random.shuffle(songs)
split = int(.8 * len(songs))
self.train_songs = songs[:split]
self.val_songs = songs[split:]
self.update_datastore()
# instantiate tensor generators for lazy evaluation during training
self.train_tensor_gen = NoteChordOneHotTensorGen(
self.train_songs, self.hparams.batch_size, self.hparams.timesteps,
hdf5_path, self.piano_roll_dict, self.n_vocab)
self.val_tensor_gen = NoteChordOneHotTensorGen(
self.val_songs, self.hparams.batch_size, self.hparams.timesteps,
hdf5_path, self.piano_roll_dict, self.n_vocab)
@property
def hparams(self):
defaults = {
'learning_rate': 0.001,
'dropout': 0.0,
'lstm_units': 512,
'dense_units': 512,
'batch_size': 32,
'timesteps': 256,
'epochs': 3,
}
if isinstance(self._hparams, HParams):
return self._hparams
elif self._hparams:
user_entered = self._hparams
else:
user_entered = dict()
combined = dict()
combined.update(defaults)
combined.update(user_entered)
self._hparams = HParams()
for k, v in combined.items():
self._hparams.add_hparam(k, v)
return self._hparams
@hparams.setter
def hparams(self, values):
if not isinstance(self._hparams, HParams):
self._hparams = HParams()
for k, v in values.items():
self._hparams.add_hparam(k, v)
@property
def n_vocab(self):
return len(self.piano_roll)
@property
def timestamp(self):
return datetime.now()
def build_model(self):
"""
Returns:
"""
self.model = Sequential()
input_shape = (None, self.n_vocab)
self.model.add(
CuDNNLSTM(
self.hparams.lstm_units,
input_shape=input_shape,
return_sequences=True,
))
self.model.add(Dropout(self.hparams.dropout))
self.model.add(
CuDNNLSTM(self.hparams.lstm_units, return_sequences=True))
self.model.add(Dropout(self.hparams.dropout))
self.model.add(
CuDNNLSTM(self.hparams.lstm_units, return_sequences=True))
self.model.add(Dropout(self.hparams.dropout))
self.model.add(TimeDistributed(Dense(self.n_vocab)))
self.model.add(Dropout(self.hparams.dropout))
self.model.add(TimeDistributed(Dense(self.n_vocab)))
self.model.add(Dropout(self.hparams.dropout))
self.model.add(TimeDistributed(Activation('sigmoid')))
self.model.compile(loss='binary_crossentropy', optimizer='rmsprop')
def load_model(self, model_path):
"""
Args:
model_path:
Returns:
"""
self.build_model()
self.model.load_weights(model_path)
def train(self):
"""
Returns:
"""
timestamp = datetime.now()
log_name = f'note-chord-one-hot-songs_{timestamp}'
tensorboard = TensorBoard(log_dir=f'logs/{log_name}',
histogram_freq=1,
write_graph=True,
write_grads=True,
batch_size=4) #write_images
# if adding embeddings, add those parameters
checkpoint_name = 'weights-improvement-epoch_{epoch:02d}-loss_{loss:.4f}.hdf5'
checkpoint = ModelCheckpoint(f'checkpoints/{checkpoint_name}',
monitor='loss',
verbose=0,
save_best_only=True,
mode='min')
val_slice = list(islice(self.val_tensor_gen, 10))
X_val_list = list()
Y_val_list = list()
for item in val_slice:
X_val_list.append(item[0])
Y_val_list.append(item[1])
X_val = np.concatenate(X_val_list, axis=0)
del X_val_list
Y_val = np.concatenate(Y_val_list, axis=0)
del Y_val_list
val_data = (X_val, Y_val)
self.model.fit_generator(
self.train_tensor_gen,
validation_data=val_data,
# validation_steps=10,
steps_per_epoch=self.train_tensor_gen.n_batches,
epochs=self.hparams.epochs,
callbacks=[checkpoint, tensorboard])
def get_song_file_dict(self):
"""
Creates a lookup dictionary to get filepath from song name.
Returns:
song_file_dict (dict): Dictionary with song names as keys and
filepaths relative to the current directory as values, including
file extension.
"""
file_exts = ('*.mid', '*.midi', '*.MID', '*.MIDI')
song_files = list()
for ext in file_exts:
song_files += glob.glob(os.path.join(self.midi_dir, ext))
get_song_name = lambda x: os.path.splitext(os.path.basename(x))[0]
song_names = [get_song_name(file) for file in song_files]
# dict to look up filepath by song name
song_file_dict = dict(zip(song_names, song_files))
return song_file_dict
def query_datastore(self, query, grp_path='songs'):
"""
Checks datastore at `hdf5_path` for keys specified by `query` within the
group specified by `grp_path` non-recursively. If the datastore does not
exist, the query will not raise an error, but instead return all of the
queried items in `not_found` and none of them in `found`.
Args:
query (iterable): keys for which to search within the grp_path in
the datastore
grp_path (str): path to the group in which to search for they keys
Returns:
found (set): query items that were found in the group
not_found (set): query items that were not found in the group
"""
# TODO: what about querying the base group?
if os.path.isfile(self.hdf5_path):
grp = h5py.File(self.hdf5_path, 'r')[grp_path]
keys = list(grp.keys())
else:
keys = list()
found = set(query).intersection(keys)
not_found = set(query) - set(found)
return found, not_found
def update_datastore(self):
"""
Updates HDF5 datastore with note sequences for any songs in midi_dir
that are not already present in the datastore.
"""
def _parse_midi(song):
"""
The songs are transposed to the key of A. The parser extracts
the lowest numbered part that has greater than 50 notes. If that
doesn't work, it flattens all of the parts into a single "flat" part
which contains all the instruments.
Args:
song:
Returns:
"""
# TODO: convert output to namedtuples with metadata
file = self.song_file_dict[song]
print(f'updating datastore: {file}...')
midi = m21.converter.parse(file)
# transpose to A
transpose_dict = {
'A#': 11,
'B-': 11,
'B': 10,
'C': 9,
'C#': 8,
'D-': 8,
'D': 7,
'D#': 6,
'E-': 6,
'E': 5,
'F': 4,
'F#': 3,
'G-': 3,
'G': 2,
'G#': 1,
'A-': 1,
'A': 0,
}
key = midi.analyze('key').getTonic().name
midi = midi.transpose(transpose_dict[key])
# extract piano, or other
try:
midi_parts = m21.instrument.partitionByInstrument(midi).parts
part = midi_parts[0]
if not part.partName == 'Piano':
pass
notes_to_parse = part.recurse().notes
part_i = 0
while len(notes_to_parse) < 50:
part_i += 1
part = midi_parts[part_i]
notes_to_parse = part.recurse().notes
except Exception: # file has notes in a flat structure
notes_to_parse = midi.flat.chordify().notes
return notes_to_parse
def _parse_notes(notes_to_parse):
"""
Parse MIDI data to a dictionary of timesteps and corresponding
notes.
"""
notes = dict()
for elem in notes_to_parse:
time = elem.offset
# TODO: remove after time fix
if time % 0.5 != 0:
continue
if time not in notes:
notes[time] = set()
if isinstance(elem, m21.note.Note):
note_int = self.piano_roll_dict[str(elem.pitch)]
notes[time].add(note_int)
elif isinstance(elem, m21.chord.Chord):
note_ints = [
self.piano_roll_dict[str(pitch)]
for pitch in elem.pitches
]
notes[time].update(note_ints)
else:
raise ValueError()
# TODO: SongMap slicable hashmap class
# correct fractional indices
frac_notes = {
k: v
for k, v in notes.items() if isinstance(k, fractions.Fraction)
}
for k, v in frac_notes.items():
del notes[k]
nearest_quarter = round(k * 4) / 4
if nearest_quarter in notes:
notes[nearest_quarter].update(v)
else:
notes[nearest_quarter] = v
# fill missing time indices
# temporarily remove because only rests were generated
time_list = sorted(notes)
if not time_list:
raise ValueError()
end_time = max(time_list)
min_space = min(
[j - i for i, j in zip(time_list[:-1], time_list[1:])])
"""
expected_times = np.array(range(int(end_time / min_space))) * min_space
missing_times = set(expected_times) - set(time_list)
if missing_times:
print(f'filling in {len(missing_times)} missing timepoints in '
f'existing {len(notes)}...')
notes.update({time: set() for time in missing_times})
"""
# convert to half notes
# convert notes to a list of strings
#str_notes = ['.'.join(sorted(notes[k])) for k in sorted(notes)]
# remove leading and trailing rests
#for i in (0, -1):
# while str_notes and str_notes[i] == '':
# str_notes.pop(i)
# encoding required by h5py
#str_notes = np.array(str_notes).astype('|S9')
#vocab = np.array(list(set(str_notes))).astype('|S9')
return notes, min_space
def _write_to_datastore(notes, min_space):
"""
Write a sequence of piano roll integers to HDF5 datastore.
Args:
notes (np.array):
min_space (float):
Returns:
"""
notes_list = np.array(
[np.array(list(notes[k])).astype('i8') for k in sorted(notes)])
with h5py.File(self.hdf5_path, 'a') as f:
grp = f.create_group(f'songs/{song}')
dt = h5py.special_dtype(vlen=np.dtype('int8'))
dset_notes = grp.create_dataset(name='notes',
shape=(len(notes_list), 1),
data=notes_list,
dtype=dt)
dset_notes.attrs['spacing'] = min_space
song_names = set(self.song_file_dict)
_, missing_songs = self.query_datastore(song_names)
for song in missing_songs:
notes_to_parse = _parse_midi(song)
notes, min_space = _parse_notes(notes_to_parse)
_write_to_datastore(notes, min_space)
def compose(self, timesteps):
"""
Generate MIDI file of length `timesteps` starting from a random seed
note from a song in the datastore.
Args:
timesteps (int): number to timesteps to synthesize
Returns:
"""
seed_note = np.array([])
while seed_note.size == 0:
with h5py.File(self.hdf5_path) as f:
grp = f['songs']
song_names = list(grp.keys())
song_idx = np.random.randint(0, len(song_names))
song = grp[song_names[song_idx]]['notes']
note_idx = np.random.randint(0, len(song))
seed_note = song[note_idx][0]
x = np.zeros(self.n_vocab)
x[seed_note] = 1
# generate notes
Y_hat_inds_seq = []
for i in range(timesteps):
x = np.expand_dims(x, axis=0)
x = np.expand_dims(x, axis=0)
y_hat = self.model.predict(x)
y_hat_inds = np.argwhere(y_hat > .5).flatten()
if y_hat_inds.size == 0:
y_hat_inds = np.argmax(y_hat).flatten()
Y_hat_inds_seq.append(y_hat_inds)
x = np.zeros(self.n_vocab)
x[y_hat_inds] = 1
ipdb.set_trace()
rev_piano_roll_dict = {v: k for k, v in self.piano_roll_dict.items()}
Y_hat_strs = [[rev_piano_roll_dict[ind] for ind in Y_hat_inds]
for Y_hat_inds in Y_hat_inds_seq]
self._output_midi(Y_hat_strs)
return Y_hat_strs
def _output_midi(self, Y_hat_strs):
timesteps = len(Y_hat_strs)
offset = 0
output_notes = []
for event_strs in Y_hat_strs: # chord
if len(event_strs) > 1:
notes = []
for note_str in event_strs:
note = m21.note.Note(int(note_str))
m21.note.storedInstrument = m21.instrument.Piano()
notes.append(note)
chord = m21.chord.Chord(notes)
chord.offset = offset
output_notes.append(chord)
elif event_strs: # note
note = m21.note.Note(event_strs[0])
note.offset = offset
note.storedInstrument = m21.instrument.Piano()
output_notes.append(note)
else: # rest
rest = m21.note.Rest()
rest.offset = offset
rest.storedInstrument = m21.instrument.Piano()
output_notes.append(rest)
offset += 1
midi = m21.stream.Stream(output_notes)
midi.write('midi', fp=f'test_output-{timesteps}-{self.timestamp}.mid')
for iids in recommended_items:
item_ranks.append([item_popularities[iid] for iid in iids])
median_ranks = np.median(item_ranks, axis=1)
tf.reset_default_graph()
return np.mean(median_ranks)
if __name__ == '__main__':
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s',
level=logging.DEBUG)
tf.set_random_seed(RANDOM_SEED)
np.random.seed(RANDOM_SEED)
# Add parameter for results folder
params.add_hparam('models_home', '')
params.add_hparam('sampler', '')
params.add_hparam('spreadout_weight', 0.)
params.add_hparam('n_try', 10)
params.add_hparam('num_neg_candidates', 0)
params.add_hparam('max_count', None)
params.add_hparam('update_embeddings_every_n_batches', -1)
# update tensorflow's hparams object using values from
# python's ArgumentParser.
parser = argparse.ArgumentParser()
params, pargs = update_params_from_parser(params, parser)
logger.info('Load echonest dataset')
dataset = fetch_echonest(data_home='data/echonest',
min_playcount=params.min_playcount,
def parse_args(yaml_path, model_id, default_set, followup=None):
logger = logging.getLogger(APP_NAME)
hparams = HParams()
hparams.add_hparam('model_id', model_id)
with open('default.yaml') as fp:
configs = YAML().load(fp)
default_cfg = configs[default_set]
add_param_recur(hparams, default_cfg)
if yaml_path:
logger.info('loading parameters...')
with open(yaml_path) as fp:
customized = YAML().load(fp)
for k, v in customized.items():
if k in hparams and hparams.get(k) != v:
logger.info('%20s: %20s -> %20s' %
(k, hparams.get(k), v))
hparams.set_hparam(k, v)
elif k not in hparams: # add new parameter
hparams.add_hparam(k, v)
logger.info(
'%30s %20s: %20s' %
("[add from %s]" % yaml_path, k, hparams.get(k)))
if followup:
# useful when changing args for prediction
logger.info('override args with follow-up args...')
for k, v in followup.items():
if k in hparams and hparams.get(k) != v:
logger.info('%20s: %20s -> %20s' % (k, hparams.get(k), v))
hparams.set_hparam(k, v)
elif k not in hparams:
logger.warning('%s is not a valid attribute! ignore!' % k)
if 'save_dir' not in hparams:
hparams.add_hparam(
'save_dir',
os.path.join(hparams.get('model_dir'), hparams.get('model_id')))
if 'code_dir' not in hparams:
hparams.add_hparam('code_dir',
os.path.join(hparams.get('save_dir'), 'code'))
hparams.set_hparam('summary_dir',
os.path.join(hparams.get('save_dir'), 'summary'))
# reset logger model id
logger = set_logger(model_id='%s:%s' %
(DEVICE_ID, hparams.get('model_id')))
try:
shutil.copytree('./',
hparams.get('code_dir'),
ignore=shutil.ignore_patterns(*IGNORE_PATTERNS))
logger.info('current code base is copied to %s' %
hparams.get('save_dir'))
except FileExistsError:
logger.info('code base exist, no need to copy!')
# if hparams.get('model_id') != model_id:
# logger.warning('model id is changed %s -> %s! '
# 'This happens when you train a pretrained model' % (
# hparams.get('model_id'), model_id))
# hparams.set_hparam('model_id', model_id)
if 'loss_csv_file' not in hparams:
hparams.add_hparam('loss_csv_file',
os.path.join(hparams.get('save_dir'), 'loss.csv'))
if 'is_serving' not in hparams:
hparams.add_hparam('is_serving', False)
logger.info('current parameters')
for k, v in sorted(vars(hparams).items()):
if not k.startswith('_'):
logger.info('%20s = %-20s' % (k, v))
return hparams
def smnist_hparams():
hparams = HParams()
hparams.add_hparam("g_dim", 128)
hparams.add_hparam("z_dim", 10)
hparams.add_hparam("prior_rnn_layers", 1)
hparams.add_hparam("posterior_rnn_layers", 1)
hparams.add_hparam("predictor_rnn_layers", 2)
hparams.add_hparam("num_input_frames", 5)
hparams.add_hparam("num_target_frames", 10)
hparams.add_hparam("beta", 1e-4)
hparams.add_hparam("learning_rate", 0.002)
hparams.add_hparam("frame_size", (64, 64, 1))
hparams.add_hparam("batch_size", 100)
hparams.add_hparam("rnn_size", 256)
hparams.add_hparam("num_digits", 2)
return hparams
'quant_size': args.quant_size,
'learning_rate': args.learning_rate,
'decay_steps':args.decay_steps,
'decay_rate':args.decay_rate,
'batch_size': args.batch_size,
'steps': args.steps,
'test_per_iterations': args.test_per_iterations,
'queue_capacity':args.queue_capacity,
'max_alpha': args.max_alpha,
'alpha_div': args.alpha_div,
}
for a,b in hyper_parameters.items():
hparams.add_hparam(a, b)
# Load data
data_generator = Dataset(hparams)
# Prepare train dirs
model_name = args.model_name + '_' + datetime.datetime.now().strftime("%Y_%m_%d__%H_%M_%S")
print('Running model: ' + model_name)
print('Hyperparameters: ')
for a,b in hyper_parameters.items():
print(str(a) + ":" + str(b))
pathlib.Path(args.train_dir + '/' + args.savedir).mkdir(parents=True, exist_ok=True)
saved_models_dir = args.train_dir + '/' + args.savedir + '/' + model_name + '/' + 'tmp'
