def main(args):
# 1.1 Create Inputs
input_data = optimus.Input(name='cqt', shape=(None, 1, TIME_DIM, 252))
fret_bitmap = optimus.Input(name='fret_bitmap', shape=(None, 6, FRET_DIM))
learning_rate = optimus.Input(name='learning_rate', shape=None)
# 1.2 Create Nodes
layer0 = optimus.Conv3D(name='layer0',
input_shape=input_data.shape,
weight_shape=(12, 1, 3, 19),
pool_shape=(1, 3),
act_type='relu')
layer1 = optimus.Conv3D(name='layer1',
input_shape=layer0.output.shape,
weight_shape=(16, None, 3, 15),
act_type='relu')
layer2 = optimus.Conv3D(name='layer2',
input_shape=layer1.output.shape,
weight_shape=(20, None, 1, 15),
act_type='relu')
layer3 = optimus.Affine(name='layer3',
input_shape=layer2.output.shape,
output_shape=(
None,
512,
),
act_type='relu')
fretboard = optimus.MultiSoftmax(name='fretboard',
input_shape=layer3.output.shape,
output_shape=(None, 6, FRET_DIM),
act_type='linear')
all_nodes = [layer0, layer1, layer2, layer3, fretboard]
# 1.1 Create Losses
mse = optimus.MeanSquaredError(name="mean_squared_error")
# 2. Define Edges
trainer_edges = optimus.ConnectionManager([
(input_data, layer0.input), (layer0.output, layer1.input),
(layer1.output, layer2.input), (layer2.output, layer3.input),
(layer3.output, fretboard.input), (fretboard.output, mse.prediction),
(fret_bitmap, mse.target)
])
update_manager = optimus.ConnectionManager([
(learning_rate, layer0.weights), (learning_rate, layer0.bias),
(learning_rate, layer1.weights), (learning_rate, layer1.bias),
(learning_rate, layer2.weights), (learning_rate, layer2.bias),
(learning_rate, layer3.weights), (learning_rate, layer3.bias),
(learning_rate, fretboard.weights), (learning_rate, fretboard.bias)
])
trainer = optimus.Graph(name=GRAPH_NAME,
inputs=[input_data, fret_bitmap, learning_rate],
nodes=all_nodes,
connections=trainer_edges.connections,
outputs=[optimus.Graph.TOTAL_LOSS],
losses=[mse],
updates=update_manager.connections)
optimus.random_init(fretboard.weights)
validator = optimus.Graph(name=GRAPH_NAME,
inputs=[input_data, fret_bitmap],
nodes=all_nodes,
connections=trainer_edges.connections,
outputs=[optimus.Graph.TOTAL_LOSS],
losses=[mse])
posterior = optimus.Output(name='posterior')
predictor_edges = optimus.ConnectionManager([
(input_data, layer0.input), (layer0.output, layer1.input),
(layer1.output, layer2.input), (layer2.output, layer3.input),
(layer3.output, fretboard.input), (fretboard.output, posterior)
])
predictor = optimus.Graph(name=GRAPH_NAME,
inputs=[input_data],
nodes=all_nodes,
connections=predictor_edges.connections,
outputs=[posterior])
# 3. Create Data
source = optimus.Queue(optimus.File(args.training_file),
transformers=[
T.cqt_sample(input_data.shape[2]),
T.pitch_shift(MAX_FRETS, bins_per_pitch=3),
T.fret_indexes_to_bitmap(FRET_DIM)
],
**SOURCE_ARGS)
driver = optimus.Driver(graph=trainer,
name=args.trial_name,
output_directory=args.model_directory)
hyperparams = {learning_rate.name: LEARNING_RATE}
driver.fit(source, hyperparams=hyperparams, **DRIVER_ARGS)
validator_file = path.join(driver.output_directory, args.validator_file)
optimus.save(validator, def_file=validator_file)
predictor_file = path.join(driver.output_directory, args.predictor_file)
optimus.save(predictor, def_file=predictor_file)
def main(args):
# 1.1 Create Inputs
input_data = optimus.Input(
name='cqt',
shape=(None, 1, TIME_DIM, PITCH_DIM))
target = optimus.Input(
name='target',
shape=(None, VOCAB))
learning_rate = optimus.Input(
name='learning_rate',
shape=None)
# 1.2 Create Nodes
layer0 = optimus.Conv3D(
name='layer0',
input_shape=input_data.shape,
weight_shape=(32, 1, 5, 19),
pool_shape=(2, 3),
act_type='relu')
layer1 = optimus.Conv3D(
name='layer1',
input_shape=layer0.output.shape,
weight_shape=(64, None, 5, 15),
act_type='relu')
layer2 = optimus.Conv3D(
name='layer2',
input_shape=layer1.output.shape,
weight_shape=(128, None, 3, 15),
act_type='relu')
layer3 = optimus.Affine(
name='layer3',
input_shape=layer2.output.shape,
output_shape=(None, 1024,),
act_type='relu')
chord_classifier = optimus.Affine(
name='chord_classifier',
input_shape=layer3.output.shape,
output_shape=(None, 6,),
act_type='sigmoid')
all_nodes = [layer0, layer1, layer2, layer3, chord_classifier]
# 1.1 Create Losses
chord_mse = optimus.MeanSquaredError(
name="chord_mse")
# 2. Define Edges
trainer_edges = optimus.ConnectionManager([
(input_data, layer0.input),
(layer0.output, layer1.input),
(layer1.output, layer2.input),
(layer2.output, layer3.input),
(layer3.output, chord_classifier.input),
(chord_classifier.output, chord_mse.prediction),
(target, chord_mse.target)])
update_manager = optimus.ConnectionManager([
# (learning_rate, layer0.weights),
# (learning_rate, layer0.bias),
# (learning_rate, layer1.weights),
# (learning_rate, layer1.bias),
# (learning_rate, layer2.weights),
# (learning_rate, layer2.bias),
(learning_rate, layer3.weights),
(learning_rate, layer3.bias),
(learning_rate, chord_classifier.weights),
(learning_rate, chord_classifier.bias)])
trainer = optimus.Graph(
name=GRAPH_NAME,
inputs=[input_data, target, learning_rate],
nodes=all_nodes,
connections=trainer_edges.connections,
outputs=[optimus.Graph.TOTAL_LOSS],
losses=[chord_mse],
updates=update_manager.connections)
for n in all_nodes:
optimus.random_init(n.weights, 0, 0.01)
optimus.random_init(n.bias, 0, 0.01)
if args.init_param_file:
param_values = dict(np.load(args.init_param_file))
keys = param_values.keys()
for key in keys:
if chord_classifier.name in key or layer3.name in key:
print "skipping %s" % key
del param_values[key]
trainer.param_values = param_values
posterior = optimus.Output(
name='posterior')
predictor_edges = optimus.ConnectionManager([
(input_data, layer0.input),
(layer0.output, layer1.input),
(layer1.output, layer2.input),
(layer2.output, layer3.input),
(layer3.output, chord_classifier.input),
(chord_classifier.output, posterior)])
predictor = optimus.Graph(
name=GRAPH_NAME,
inputs=[input_data],
nodes=all_nodes,
connections=predictor_edges.connections,
outputs=[posterior])
# 3. Create Data
print "Loading %s" % args.training_file
stash = biggie.Stash(args.training_file)
stream = D.create_uniform_chord_stream(
stash, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, working_size=10)
stream = S.minibatch(
FX.chord_index_to_tonnetz(stream, vocab_dim=VOCAB),
batch_size=BATCH_SIZE)
print "Starting '%s'" % args.trial_name
driver = optimus.Driver(
graph=trainer,
name=args.trial_name,
output_directory=args.model_directory)
hyperparams = {learning_rate.name: LEARNING_RATE}
predictor_file = path.join(driver.output_directory, args.predictor_file)
optimus.save(predictor, def_file=predictor_file)
driver.fit(stream, hyperparams=hyperparams, **DRIVER_ARGS)
def main(args):
# 1.1 Create Inputs
input_data = optimus.Input(name='cqt', shape=(None, 1, TIME_DIM, 252))
target = optimus.Input(name='target', shape=(None, VOCAB))
learning_rate = optimus.Input(name='learning_rate', shape=None)
# 1.2 Create Nodes
layer0 = optimus.Conv3D(name='layer0',
input_shape=input_data.shape,
weight_shape=(30, 1, 9, 19),
pool_shape=(1, 3),
act_type='relu')
layer1 = optimus.Conv3D(name='layer1',
input_shape=layer0.output.shape,
weight_shape=(50, None, 7, 15),
act_type='relu')
layer2 = optimus.Affine(name='layer2',
input_shape=layer1.output.shape,
output_shape=(
None,
1024,
),
act_type='relu')
layer3 = optimus.Affine(name='layer3',
input_shape=layer2.output.shape,
output_shape=(
None,
1024,
),
act_type='relu')
chord_estimator = optimus.Affine(name='chord_estimator',
input_shape=layer3.output.shape,
output_shape=(
None,
VOCAB,
),
act_type='relu')
all_nodes = [layer0, layer1, layer2, layer3, chord_estimator]
# 1.1 Create Losses
chord_mse = optimus.MeanSquaredError(name="chord_mse", weighted=True)
# 2. Define Edges
trainer_edges = optimus.ConnectionManager([
(input_data, layer0.input), (layer0.output, layer1.input),
(layer1.output, layer2.input), (layer2.output, layer3.input),
(layer3.output, chord_estimator.input),
(chord_estimator.output, chord_mse.prediction),
(target, chord_mse.target), (weights, chord_mse.weights)
])
update_manager = optimus.ConnectionManager([
(learning_rate, layer0.weights), (learning_rate, layer0.bias),
(learning_rate, layer1.weights), (learning_rate, layer1.bias),
(learning_rate, layer2.weights), (learning_rate, layer2.bias),
(learning_rate, layer3.weights), (learning_rate, layer3.bias),
(learning_rate, chord_estimator.weights),
(learning_rate, chord_estimator.bias)
])
trainer = optimus.Graph(
name=GRAPH_NAME,
inputs=[input_data, target, learning_rate, weights],
nodes=all_nodes,
connections=trainer_edges.connections,
outputs=[optimus.Graph.TOTAL_LOSS],
losses=[chord_mse],
updates=update_manager.connections,
momentum=None)
for n in all_nodes:
optimus.random_init(n.weights, 0, 0.01)
optimus.random_init(n.bias, 0, 0.01)
validator = optimus.Graph(name=GRAPH_NAME,
inputs=[input_data, target, weights],
nodes=all_nodes,
connections=trainer_edges.connections,
outputs=[optimus.Graph.TOTAL_LOSS],
losses=[chord_mse])
posterior = optimus.Output(name='posterior')
predictor_edges = optimus.ConnectionManager([
(input_data, layer0.input), (layer0.output, layer1.input),
(layer1.output, layer2.input), (layer2.output, layer3.input),
(layer3.output, chord_estimator.input),
(chord_estimator.output, posterior)
])
predictor = optimus.Graph(name=GRAPH_NAME,
inputs=[input_data],
nodes=all_nodes,
connections=predictor_edges.connections,
outputs=[posterior])
# 3. Create Data
print "Loading %s" % args.training_file
stash = biggie.Stash(args.training_file)
# partition_labels = json.load(
# open("/home/ejhumphrey/Dropbox/tmp/train0_v2_merged_partition.json"))
stream = D.create_uniform_chord_stream(stash,
TIME_DIM,
pitch_shift=False,
vocab_dim=VOCAB,
working_size=5)
stream = S.minibatch(FX.chord_index_to_tonnetz_distance(stream, VOCAB),
batch_size=BATCH_SIZE)
print "Starting '%s'" % args.trial_name
driver = optimus.Driver(graph=trainer,
name=args.trial_name,
output_directory=args.model_directory)
hyperparams = {learning_rate.name: LEARNING_RATE}
validator_file = path.join(driver.output_directory, args.validator_file)
optimus.save(validator, def_file=validator_file)
predictor_file = path.join(driver.output_directory, args.predictor_file)
optimus.save(predictor, def_file=predictor_file)
driver.fit(stream, hyperparams=hyperparams, **DRIVER_ARGS)
def main(args):
# 1.1 Create Inputs
input_data = optimus.Input(name='cqt', shape=(None, 1, TIME_DIM, 252))
target_tonnetz = optimus.Input(
name='target_tonnetz',
shape=(None, 12),
)
learning_rate = optimus.Input(name='learning_rate', shape=None)
# 1.2 Create Nodes
layer0 = optimus.Conv3D(name='layer0',
input_shape=input_data.shape,
weight_shape=(12, 1, 3, 19),
pool_shape=(1, 3),
act_type='relu')
layer1 = optimus.Conv3D(name='layer1',
input_shape=layer0.output.shape,
weight_shape=(16, None, 3, 15),
act_type='relu')
layer2 = optimus.Conv3D(name='layer2',
input_shape=layer1.output.shape,
weight_shape=(20, None, 1, 15),
act_type='relu')
layer3 = optimus.Affine(name='layer3',
input_shape=layer2.output.shape,
output_shape=(
None,
6,
),
act_type='tanh')
all_nodes = [layer0, layer1, layer2, layer3]
# 1.1 Create Losses
tonnetz_mse = optimus.MeanSquaredError(name="tonnetz_mse")
# 2. Define Edges
trainer_edges = optimus.ConnectionManager([
(input_data, layer0.input), (layer0.output, layer1.input),
(layer1.output, layer2.input), (layer2.output, layer3.input),
(layer3.output, tonnetz_mse.prediction),
(target_tonnetz, tonnetz_mse.target)
])
update_manager = optimus.ConnectionManager([
(learning_rate, layer0.weights), (learning_rate, layer0.bias),
(learning_rate, layer1.weights), (learning_rate, layer1.bias),
(learning_rate, layer2.weights), (learning_rate, layer2.bias),
(learning_rate, layer3.weights), (learning_rate, layer3.bias)
])
trainer = optimus.Graph(name=GRAPH_NAME,
inputs=[input_data, target_tonnetz, learning_rate],
nodes=all_nodes,
connections=trainer_edges.connections,
outputs=[optimus.Graph.TOTAL_LOSS],
losses=[tonnetz_mse],
updates=update_manager.connections)
optimus.random_init(layer0.weights)
optimus.random_init(layer1.weights)
optimus.random_init(layer2.weights)
optimus.random_init(layer3.weights)
validator = optimus.Graph(name=GRAPH_NAME,
inputs=[input_data, target_tonnetz],
nodes=all_nodes,
connections=trainer_edges.connections,
outputs=[optimus.Graph.TOTAL_LOSS],
losses=[tonnetz_mse])
tonnetz_out = optimus.Output(name='tonnetz')
predictor_edges = optimus.ConnectionManager([(input_data, layer0.input),
(layer0.output, layer1.input),
(layer1.output, layer2.input),
(layer2.output, layer3.input),
(layer3.output, tonnetz_out)])
predictor = optimus.Graph(name=GRAPH_NAME,
inputs=[input_data],
nodes=all_nodes,
connections=predictor_edges.connections,
outputs=[tonnetz_out])
# 3. Create Data
source = optimus.Queue(optimus.File(args.training_file),
transformers=[
T.chord_sample(input_data.shape[2]),
T.pitch_shift(8), T.map_to_tonnetz
],
**SOURCE_ARGS)
driver = optimus.Driver(graph=trainer,
name=args.trial_name,
output_directory=args.model_directory)
hyperparams = {learning_rate.name: LEARNING_RATE}
driver.fit(source, hyperparams=hyperparams, **DRIVER_ARGS)
validator_file = path.join(driver.output_directory, args.validator_file)
optimus.save(validator, def_file=validator_file)
predictor_file = path.join(driver.output_directory, args.predictor_file)
optimus.save(predictor, def_file=predictor_file)
