def main(args): trainer, predictor = build_model() if args.init_param_file: print "Loading parameters: %s" % args.init_param_file trainer.load_param_values(args.init_param_file) optimus.random_init(trainer.params['layer3'].weights) optimus.random_init(trainer.params['layer3'].bias) # 3. Create Data print "Loading %s" % args.training_file stash = biggie.Stash(args.training_file) stream = D.create_stash_stream( stash, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, pool_size=25) if args.secondary_source: stash2 = biggie.Stash(args.secondary_source) stream2 = D.create_uniform_chord_stream( stash2, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, working_size=5) stream = S.mux([stream, stream2], [0.5, 0.5]) stream = S.minibatch(stream, batch_size=BATCH_SIZE) print "Starting '%s'" % args.trial_name driver = optimus.Driver( graph=trainer, name=args.trial_name, output_directory=args.model_directory) predictor_file = path.join(driver.output_directory, args.predictor_file) optimus.save(predictor, def_file=predictor_file) hyperparams = dict(learning_rate=LEARNING_RATE) driver.fit(stream, hyperparams=hyperparams, **DRIVER_ARGS)
def build_model(): x_in = optimus.Input(name="x", shape=(None, 2)) class_idx = optimus.Input(name="y", shape=(None,), dtype='int32') learning_rate = optimus.Input(name='learning_rate', shape=None) layer0 = optimus.Affine( name='layer0', input_shape=x_in.shape, output_shape=(None, 100), act_type='tanh') classifier = optimus.Softmax( name='classifier', input_shape=layer0.output.shape, n_out=2, act_type='linear') nll = optimus.NegativeLogLikelihood(name="nll") posterior = optimus.Output(name='posterior') trainer_edges = optimus.ConnectionManager([ (x_in, layer0.input), (layer0.output, classifier.input), (classifier.output, nll.likelihood), (class_idx, nll.target_idx)]) update_manager = optimus.ConnectionManager([ (learning_rate, layer0.weights), (learning_rate, layer0.bias), (learning_rate, classifier.weights), (learning_rate, classifier.bias)]) trainer = optimus.Graph( name='trainer', inputs=[x_in, class_idx, learning_rate], nodes=[layer0, classifier], connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[nll], updates=update_manager.connections) optimus.random_init(classifier.weights) predictor_edges = optimus.ConnectionManager([ (x_in, layer0.input), (layer0.output, classifier.input), (classifier.output, posterior)]) predictor = optimus.Graph( name='predictor', inputs=[x_in], nodes=[layer0, classifier], connections=predictor_edges.connections, outputs=[posterior]) driver = optimus.Driver(graph=trainer, name='test') return driver, predictor
def main(args): # 1.1 Create Inputs input_data = optimus.Input( name='cqt', shape=(None, 1, TIME_DIM, 252)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') is_chord = optimus.Input( name='is_chord', shape=(None,)) 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, 9, 19), pool_shape=(1, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 7, 15), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 6, 15), act_type='relu') layer3 = optimus.Affine( name='layer3', input_shape=layer2.output.shape, output_shape=(None, 512,), act_type='relu') chord_estimator = optimus.Affine( name='chord_estimator', input_shape=layer3.output.shape, output_shape=(None, VOCAB), act_type='sigmoid') all_nodes = [layer0, layer1, layer2, layer3, chord_estimator] # 1.1 Create Losses chord_mse = optimus.SparseMeanSquaredError( # chord_mse = optimus.SparseCrossEntropy( 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_estimator.input), (chord_estimator.output, chord_mse.prediction), (chord_idx, chord_mse.index), (is_chord, 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_estimator.weights), (learning_rate, chord_estimator.bias)]) print "Building trainer" trainer = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx, is_chord, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_mse], updates=update_manager.connections) optimus.random_init(chord_estimator.weights) print "Building validator" validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx, is_chord], 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)]) print "Building predictor" predictor = optimus.Graph( name=GRAPH_NAME, inputs=[input_data], nodes=all_nodes, connections=predictor_edges.connections, outputs=[posterior]) # 3. Create Data print "Opening Data" stash = biggie.Stash(args.training_file) stream = S.minibatch( D.create_contrastive_quality_stream(stash, TIME_DIM, vocab_dim=VOCAB), batch_size=50) driver = optimus.Driver( graph=trainer, name=args.trial_name, output_directory=args.model_directory) hyperparams = {learning_rate.name: LEARNING_RATE} print "...aaand we're off!" driver.fit(stream, 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, 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)
def classifier_init(nodes): for n in nodes: for p in n.params.values(): if 'classifier' in n.name and 'bias' in p.name: continue optimus.random_init(p)
def main(args): # 1.1 Create Inputs input_data = optimus.Input( name='cqt', shape=(None, 1, TIME_DIM, 252)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') 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, 9, 19), pool_shape=(1, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 7, 15), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 6, 15), act_type='relu') layer3 = optimus.Affine( name='layer3', input_shape=layer2.output.shape, output_shape=(None, 512,), act_type='relu') chord_classifier = optimus.Softmax( name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood( name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx)]) 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)]) print "Building trainer" trainer = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections) optimus.random_init(chord_classifier.weights) print "Building validator" validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll]) 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)]) print "Building predictor" predictor = optimus.Graph( name=GRAPH_NAME, inputs=[input_data], nodes=all_nodes, connections=predictor_edges.connections, outputs=[posterior]) # 3. Create Data print "Opening Data" stash = biggie.Stash(args.training_file) stream = S.minibatch( D.create_uniform_quality_stream(stash, TIME_DIM), batch_size=50, functions=[FX.pitch_shift(), FX.map_to_chord_index(VOCAB)]) driver = optimus.Driver( graph=trainer, name=args.trial_name, output_directory=args.model_directory) hyperparams = {learning_rate.name: LEARNING_RATE} print "...aaand we're off!" driver.fit(stream, 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, 252)) chord_idx = optimus.Input(name='chord_idx', shape=(None, ), dtype='int32') 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_classifier = optimus.Softmax(name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood(name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx) ]) 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, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections) for n in all_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) validator = optimus.Graph(name=GRAPH_NAME, inputs=[input_data, chord_idx], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll]) 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 stash = biggie.Stash(args.training_file) hyperparams = {learning_rate.name: LEARNING_RATE} valid_idx = [0] for q in range(1, 13): valid_idx.append(q) stream = S.minibatch(D.create_uniform_quality_stream( stash, TIME_DIM, vocab_dim=VOCAB, valid_idx=valid_idx), batch_size=BATCH_SIZE) driver = optimus.Driver(graph=trainer, name=args.trial_name + "_c%02d" % q, output_directory=args.model_directory) driver.fit(stream, hyperparams=hyperparams, max_iter=20000, **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)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') learning_rate = optimus.Input( name='learning_rate', shape=None) # 1.2 Create Nodes input_scalar = optimus.Normalize( name='input_scalar', mode='l2', scale_factor=50.0) 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') layer4 = optimus.Affine( name='bottleneck', input_shape=layer3.output.shape, output_shape=(None, 3,), act_type='linear') chord_classifier = optimus.Softmax( name='chord_classifier', input_shape=layer4.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [input_scalar, layer0, layer1, layer2, layer3, layer4, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood( name="chord_nll") # 2. Define Edges trainer_edges = optimus.ConnectionManager([ (input_data, input_scalar.input), (input_scalar.output, layer0.input), (layer0.output, layer1.input), (layer1.output, layer2.input), (layer2.output, layer3.input), (layer3.output, layer4.input), (layer4.output, chord_classifier.input), (chord_classifier.output, chord_nll.likelihood), (chord_idx, chord_nll.target_idx)]) 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, layer4.weights), (learning_rate, layer4.bias), (learning_rate, chord_classifier.weights), (learning_rate, chord_classifier.bias)]) trainer = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections) for n in all_nodes[1:]: optimus.random_init(n.weights) optimus.random_init(n.bias) 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') embedding = optimus.Output( name='embedding') predictor_edges = optimus.ConnectionManager([ (input_data, input_scalar.input), (input_scalar.output, layer0.input), (layer0.output, layer1.input), (layer1.output, layer2.input), (layer2.output, layer3.input), (layer3.output, layer4.input), (layer4.output, chord_classifier.input), (layer4.output, embedding), (chord_classifier.output, posterior)]) predictor = optimus.Graph( name=GRAPH_NAME, inputs=[input_data], nodes=all_nodes, connections=predictor_edges.connections, outputs=[posterior, embedding]) # 3. Create Data print "Loading %s" % args.training_file stash = biggie.Stash(args.training_file) stream = S.minibatch( D.create_uniform_chord_stream( stash, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, working_size=10), 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)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') 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_classifier = optimus.Softmax( name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood( name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx)]) 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, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections) for n in all_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll]) 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 stash = biggie.Stash(args.training_file) hyperparams = {learning_rate.name: LEARNING_RATE} valid_idx = [0] for q in range(1, 13): valid_idx.append(q) stream = S.minibatch( D.create_uniform_quality_stream(stash, TIME_DIM, vocab_dim=VOCAB, valid_idx=valid_idx), batch_size=BATCH_SIZE) driver = optimus.Driver( graph=trainer, name=args.trial_name + "_c%02d" % q, output_directory=args.model_directory) driver.fit( stream, hyperparams=hyperparams, max_iter=20000, **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 param_init(nodes, skip_biases=True): for n in nodes: for k, p in n.params.items(): if 'bias' in k and skip_biases: continue optimus.random_init(p, 0, 0.01)
def main(args): # 1.1 Create Inputs input_data = optimus.Input( name='cqt', shape=(None, 1, TIME_DIM, 252)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') learning_rate = optimus.Input( name='learning_rate', shape=None) limiter_weight = optimus.Input( name='limiter_weight', shape=None) likelihood_threshold = optimus.Input( name='likelihood_threshold', shape=None) # 1.2 Create Nodes layer0 = optimus.Conv3D( name='layer0', input_shape=input_data.shape, weight_shape=(12, 1, 9, 19), pool_shape=(1, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 7, 15), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 6, 15), act_type='relu') layer3 = optimus.Affine( name='layer3', input_shape=layer2.output.shape, output_shape=(None, 512,), act_type='relu') chord_classifier = optimus.Softmax( name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood( name="chord_nll") max_likelihood = optimus.Max( name="max_likelihood") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx), (chord_classifier.output, max_likelihood.input), (limiter_weight, max_likelihood.weight), (likelihood_threshold, max_likelihood.threshold)]) 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)]) print "Trainer" trainer = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx, learning_rate, limiter_weight, likelihood_threshold], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll, max_likelihood], updates=update_manager.connections) optimus.random_init(chord_classifier.weights) print "Validator" validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx, limiter_weight, likelihood_threshold], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll, max_likelihood]) 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)]) print "Predictor" predictor = optimus.Graph( name=GRAPH_NAME, inputs=[input_data], nodes=all_nodes, connections=predictor_edges.connections, outputs=[posterior]) # 3. Create Data stash = biggie.Stash(args.training_file) stream = S.minibatch( D.create_uniform_quality_stream(stash, TIME_DIM, vocab_dim=VOCAB), batch_size=50) driver = optimus.Driver( graph=trainer, name=args.trial_name, output_directory=args.model_directory) hyperparams = {learning_rate.name: LEARNING_RATE, likelihood_threshold.name: LIKELIHOOD_THRESHOLD, limiter_weight.name: LIMITER_WEIGHT} driver.fit(stream, 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 build_model(): # 1.1 Create Inputs input_data = optimus.Input( name='cqt', shape=(None, OCTAVE_DIM, TIME_DIM, PITCH_DIM)) fret_map = optimus.Input( name='fret_map', shape=(None, 6, 9)) 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, None, 5, 5), pool_shape=(2, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(64, None, 5, 7), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(128, None, 3, 6), act_type='relu') layer3 = optimus.Affine( name='layer3', input_shape=layer2.output.shape, output_shape=(None, 1024,), act_type='relu') strings = [] for n in range(6): strings.append( optimus.Affine( name='string_%d' % n, input_shape=layer3.output.shape, output_shape=(None, 9), act_type='sigmoid')) param_nodes = [layer0, layer1, layer2, layer3] + strings # 1.1 Create Loss stack = optimus.Stack('stack', axes=[1, 0, 2]) error = optimus.SquaredEuclidean(name='squared_error') loss = optimus.Mean(name='mse') # 2. Define Edges base_edges = [ (input_data, layer0.input), (layer0.output, layer1.input), (layer1.output, layer2.input), (layer2.output, layer3.input), (layer3.output, strings[0].input), (strings[0].output, stack.input_list), (layer3.output, strings[1].input), (strings[1].output, stack.input_list), (layer3.output, strings[2].input), (strings[2].output, stack.input_list), (layer3.output, strings[3].input), (strings[3].output, stack.input_list), (layer3.output, strings[4].input), (strings[4].output, stack.input_list), (layer3.output, strings[5].input), (strings[5].output, stack.input_list)] trainer_edges = optimus.ConnectionManager( base_edges + [ (stack.output, error.input_a), (fret_map, error.input_b), (error.output, loss.input)]) update_manager = optimus.ConnectionManager( map(lambda n: (learning_rate, n.weights), param_nodes) + map(lambda n: (learning_rate, n.bias), param_nodes)) trainer = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, fret_map, learning_rate], nodes=param_nodes + [stack, error, loss], connections=trainer_edges.connections, outputs=[loss.output], loss=loss.output, updates=update_manager.connections, verbose=True) for n in param_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) fret_posterior = optimus.Output( name='fret_posterior') predictor_edges = optimus.ConnectionManager( base_edges + [(stack.output, fret_posterior)]) predictor = optimus.Graph( name=GRAPH_NAME, inputs=[input_data], nodes=param_nodes + [stack], connections=predictor_edges.connections, outputs=[fret_posterior]) return trainer, predictor
def main(args): # 1.1 Create Inputs input_data = optimus.Input(name='cqt', shape=(None, 1, TIME_DIM, 252)) chord_idx = optimus.Input(name='chord_idx', shape=(None, ), dtype='int32') learning_rate = optimus.Input(name='learning_rate', shape=None) margin = optimus.Input(name='margin', shape=None) margin_weight = optimus.Input(name='margin_weight', shape=None) nll_weight = optimus.Input(name='nll_weight', shape=None) # 1.2 Create Nodes layer0 = optimus.Conv3D(name='layer0', input_shape=input_data.shape, weight_shape=(12, 1, 9, 19), pool_shape=(1, 3), act_type='relu') layer1 = optimus.Conv3D(name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 7, 15), act_type='relu') layer2 = optimus.Conv3D(name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 6, 15), act_type='relu') layer3 = optimus.Affine(name='layer3', input_shape=layer2.output.shape, output_shape=(None, 512), act_type='relu') chord_classifier = optimus.Softmax(name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses nll = optimus.NegativeLogLikelihood(name="nll", weighted=True) likelihood_margin = optimus.LikelihoodMargin(name="likelihood_margin", mode='l1', weighted=True) # likelihood_margin = optimus.NLLMargin( # name="likelihood_margin", # mode='l2', # 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_classifier.input), (chord_classifier.output, likelihood_margin.likelihood), (chord_idx, likelihood_margin.target_idx), (margin, likelihood_margin.margin), (margin_weight, likelihood_margin.weight), (chord_classifier.output, nll.likelihood), (chord_idx, nll.target_idx), (nll_weight, nll.weight) ]) 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, chord_idx, margin, learning_rate, margin_weight, nll_weight ], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[nll, likelihood_margin], updates=update_manager.connections) optimus.random_init(chord_classifier.weights) optimus.random_init(chord_classifier.bias) validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx, margin, margin_weight, nll_weight], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[nll, likelihood_margin]) 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 stash = biggie.Stash(args.training_file) stream = S.minibatch(D.create_uniform_quality_stream(stash, TIME_DIM, vocab_dim=VOCAB), batch_size=50) driver = optimus.Driver(graph=trainer, name=args.trial_name, output_directory=args.model_directory) hyperparams = { learning_rate.name: LEARNING_RATE, margin_weight.name: MARGIN_WEIGHT, nll_weight.name: NLL_WEIGHT, margin.name: MARGIN } driver.fit(stream, 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 pwrank(verbose=False): """Create a trainer and predictor graph for pairwise rank embeddings Returns ------- trainer : optimus.Graph Graph with in-place updates for back-propagating error. predictor : optimus.Graph Static graph for processing images. """ # 1.1 Create Inputs x_in = optimus.Input( name='x_in', shape=(None, 1, 28, 28)) x_same = optimus.Input( name='x_same', shape=x_in.shape) x_diff = optimus.Input( name='x_diff', shape=x_in.shape) learning_rate = optimus.Input( name='learning_rate', shape=None) margin_diff = optimus.Input( name='margin_diff', shape=None) margin_same = optimus.Input( name='margin_same', shape=None) # 1.2 Create Nodes layer0 = optimus.Conv3D( name='layer0', input_shape=x_in.shape, weight_shape=(15, 1, 9, 9), pool_shape=(2, 2), act_type='relu') layer1 = optimus.Affine( name='layer1', input_shape=layer0.output.shape, output_shape=(None, 512,), act_type='tanh') layer2 = optimus.Affine( name='layer2', input_shape=layer1.output.shape, output_shape=(None, 2), act_type='linear') param_nodes = [layer0, layer1, layer2] # Create two copies nodes_same = [l.clone(l.name + "_same") for l in param_nodes] nodes_diff = [l.clone(l.name + "_diff") for l in param_nodes] # 1.1 Create Losses cost_sim = optimus.Euclidean(name='cost_sim') cost_diff = optimus.Euclidean(name='cost_diff') criterion = optimus.ContrastiveMargin(name='contrastive') loss_nodes = [cost_sim, cost_diff, criterion] # 1.2 Define outputs z_out = optimus.Output(name='z_out') loss = optimus.Output(name='loss') # 2. Define Edges base_edges = [ (x_in, layer0.input), (layer0.output, layer1.input), (layer1.output, layer2.input), (layer2.output, z_out)] trainer_edges = optimus.ConnectionManager( base_edges + [ (x_same, nodes_same[0].input), (nodes_same[0].output, nodes_same[1].input), (nodes_same[1].output, nodes_same[2].input), (x_diff, nodes_diff[0].input), (nodes_diff[0].output, nodes_diff[1].input), (nodes_diff[1].output, nodes_diff[2].input), (layer2.output, cost_sim.input_a), (nodes_same[2].output, cost_sim.input_b), (layer2.output, cost_diff.input_a), (nodes_diff[2].output, cost_diff.input_b), (cost_sim.output, criterion.cost_sim), (cost_diff.output, criterion.cost_diff), (margin_same, criterion.margin_sim), (margin_diff, criterion.margin_diff), (criterion.output, loss)]) update_manager = optimus.ConnectionManager( list(map(lambda n: (learning_rate, n.weights), param_nodes)) + list(map(lambda n: (learning_rate, n.bias), param_nodes))) trainer = optimus.Graph( name='mnist_trainer', inputs=[x_in, x_same, x_diff, learning_rate, margin_same, margin_diff], nodes=param_nodes + nodes_same + nodes_diff + loss_nodes, connections=trainer_edges.connections, outputs=[loss, z_out], loss=loss, updates=update_manager.connections, verbose=verbose) for node in param_nodes: optimus.random_init(node.weights, mean=0.0, std=0.1) predictor_edges = optimus.ConnectionManager(base_edges) predictor = optimus.Graph( name='mnist_embedding', inputs=[x_in], nodes=param_nodes, connections=predictor_edges.connections, outputs=[z_out], verbose=verbose) return trainer, predictor
def build_model(): # 1.1 Create Inputs input_data = optimus.Input(name='cqt', shape=(None, OCTAVE_DIM, TIME_DIM, PITCH_DIM)) fret_map = optimus.Input(name='fret_map', shape=(None, 6, 9)) 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, None, 5, 5), pool_shape=(2, 3), act_type='relu') layer1 = optimus.Conv3D(name='layer1', input_shape=layer0.output.shape, weight_shape=(64, None, 5, 7), act_type='relu') layer2 = optimus.Conv3D(name='layer2', input_shape=layer1.output.shape, weight_shape=(128, None, 3, 6), act_type='relu') layer3 = optimus.Affine(name='layer3', input_shape=layer2.output.shape, output_shape=( None, 1024, ), act_type='relu') strings = [] for n in range(6): strings.append( optimus.Affine(name='string_%d' % n, input_shape=layer3.output.shape, output_shape=(None, 9), act_type='sigmoid')) param_nodes = [layer0, layer1, layer2, layer3] + strings # 1.1 Create Loss stack = optimus.Stack('stack', axes=[1, 0, 2]) error = optimus.SquaredEuclidean(name='squared_error') loss = optimus.Mean(name='mse') # 2. Define Edges base_edges = [(input_data, layer0.input), (layer0.output, layer1.input), (layer1.output, layer2.input), (layer2.output, layer3.input), (layer3.output, strings[0].input), (strings[0].output, stack.input_list), (layer3.output, strings[1].input), (strings[1].output, stack.input_list), (layer3.output, strings[2].input), (strings[2].output, stack.input_list), (layer3.output, strings[3].input), (strings[3].output, stack.input_list), (layer3.output, strings[4].input), (strings[4].output, stack.input_list), (layer3.output, strings[5].input), (strings[5].output, stack.input_list)] trainer_edges = optimus.ConnectionManager(base_edges + [( stack.output, error.input_a), (fret_map, error.input_b), (error.output, loss.input)]) update_manager = optimus.ConnectionManager( map(lambda n: (learning_rate, n.weights), param_nodes) + map(lambda n: (learning_rate, n.bias), param_nodes)) trainer = optimus.Graph(name=GRAPH_NAME, inputs=[input_data, fret_map, learning_rate], nodes=param_nodes + [stack, error, loss], connections=trainer_edges.connections, outputs=[loss.output], loss=loss.output, updates=update_manager.connections, verbose=True) for n in param_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) fret_posterior = optimus.Output(name='fret_posterior') predictor_edges = optimus.ConnectionManager(base_edges + [(stack.output, fret_posterior)]) predictor = optimus.Graph(name=GRAPH_NAME, inputs=[input_data], nodes=param_nodes + [stack], connections=predictor_edges.connections, outputs=[fret_posterior]) return trainer, predictor
def main(args): # 1.1 Create Inputs input_data = optimus.Input( name='cqt', shape=(None, 1, TIME_DIM, 252)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') learning_rate = optimus.Input( name='learning_rate', shape=None) margin = optimus.Input( name='margin', shape=None) margin_weight = optimus.Input( name='margin_weight', shape=None) nll_weight = optimus.Input( name='nll_weight', shape=None) # 1.2 Create Nodes layer0 = optimus.Conv3D( name='layer0', input_shape=input_data.shape, weight_shape=(12, 1, 9, 19), pool_shape=(1, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 7, 15), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 6, 15), act_type='relu') layer3 = optimus.Affine( name='layer3', input_shape=layer2.output.shape, output_shape=(None, 512), act_type='relu') chord_classifier = optimus.Softmax( name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses nll = optimus.NegativeLogLikelihood( name="nll", weighted=True) likelihood_margin = optimus.LikelihoodMargin( name="likelihood_margin", mode='l1', weighted=True) # likelihood_margin = optimus.NLLMargin( # name="likelihood_margin", # mode='l2', # 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_classifier.input), (chord_classifier.output, likelihood_margin.likelihood), (chord_idx, likelihood_margin.target_idx), (margin, likelihood_margin.margin), (margin_weight, likelihood_margin.weight), (chord_classifier.output, nll.likelihood), (chord_idx, nll.target_idx), (nll_weight, nll.weight)]) 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, chord_idx, margin, learning_rate, margin_weight, nll_weight], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[nll, likelihood_margin], updates=update_manager.connections) optimus.random_init(chord_classifier.weights) optimus.random_init(chord_classifier.bias) validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx, margin, margin_weight, nll_weight], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[nll, likelihood_margin]) 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 stash = biggie.Stash(args.training_file) stream = S.minibatch( D.create_uniform_quality_stream(stash, TIME_DIM, vocab_dim=VOCAB), batch_size=50) driver = optimus.Driver( graph=trainer, name=args.trial_name, output_directory=args.model_directory) hyperparams = {learning_rate.name: LEARNING_RATE, margin_weight.name: MARGIN_WEIGHT, nll_weight.name: NLL_WEIGHT, margin.name: MARGIN} driver.fit(stream, 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, 6, TIME_DIM, 40)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') 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, None, 5, 5), pool_shape=(2, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(64, None, 5, 7), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(128, None, 3, 6), act_type='relu') layer3 = optimus.Affine( name='layer3', input_shape=layer2.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_classifier = optimus.Softmax( name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood( name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx)]) 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, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections, momentum=None) for n in all_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) # trainer.load_param_values("/media/attic/dl4mir/chord_estimation/models/nll_chord_uniform_2big/synth_data_01/0/classifier-V157-synth_data_01-041750-2014-08-25_21h59m56s.npz") validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll]) 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=False, vocab_dim=VOCAB, working_size=10) stream = S.minibatch( FX.wrap_cqt(stream, length=40, stride=36), 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_chroma = optimus.Input( name='target_chroma', 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, 9, 19), pool_shape=(1, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 7, 15), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 6, 15), act_type='relu') layer3 = optimus.Affine( name='layer3', input_shape=layer2.output.shape, output_shape=(None, 512,), act_type='relu') layer4 = optimus.Affine( name='layer4', input_shape=layer3.output.shape, output_shape=(None, 12,), act_type='sigmoid') all_nodes = [layer0, layer1, layer2, layer3, layer4] # 1.1 Create Losses chroma_xentropy = optimus.CrossEntropy( name="chroma_xentropy") # 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, layer4.input), (layer4.output, chroma_xentropy.prediction), (target_chroma, chroma_xentropy.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, layer4.weights), (learning_rate, layer4.bias)]) trainer = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, target_chroma, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chroma_xentropy], updates=update_manager.connections) optimus.random_init(layer0.weights) optimus.random_init(layer1.weights) optimus.random_init(layer2.weights) optimus.random_init(layer3.weights) optimus.random_init(layer4.weights) validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, target_chroma], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chroma_xentropy]) chroma_out = optimus.Output( name='chroma') predictor_edges = optimus.ConnectionManager([ (input_data, layer0.input), (layer0.output, layer1.input), (layer1.output, layer2.input), (layer2.output, layer3.input), (layer3.output, layer4.input), (layer4.output, chroma_out)]) predictor = optimus.Graph( name=GRAPH_NAME, inputs=[input_data], nodes=all_nodes, connections=predictor_edges.connections, outputs=[chroma_out]) # 3. Create Data stash = biggie.Stash(args.training_file) stream = S.minibatch( D.uniform_quality_chroma_stream(stash, TIME_DIM), batch_size=50) driver = optimus.Driver( graph=trainer, name=args.trial_name, output_directory=args.model_directory) hyperparams = {learning_rate.name: LEARNING_RATE} driver.fit(stream, 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, 252)) target_chroma = optimus.Input( name='target_chroma', 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, 12, ), act_type='sigmoid') all_nodes = [layer0, layer1, layer2, layer3] # 1.1 Create Losses chroma_xentropy = optimus.CrossEntropy(name="chroma_xentropy") # 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, chroma_xentropy.prediction), (target_chroma, chroma_xentropy.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_chroma, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chroma_xentropy], 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_chroma], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chroma_xentropy]) chroma_out = optimus.Output(name='chroma') predictor_edges = optimus.ConnectionManager([(input_data, layer0.input), (layer0.output, layer1.input), (layer1.output, layer2.input), (layer2.output, layer3.input), (layer3.output, chroma_out)]) predictor = optimus.Graph(name=GRAPH_NAME, inputs=[input_data], nodes=all_nodes, connections=predictor_edges.connections, outputs=[chroma_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_chroma ], **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 wcqt_likelihood_wmoia(n_dim=VOCAB): input_data = optimus.Input( name='cqt', shape=(None, 6, TIME_DIM, 40)) target = optimus.Input( name='target', shape=(None, 1)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') 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, None, 5, 5), pool_shape=(2, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(64, None, 5, 7), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(128, None, 3, 6), 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, n_dim), act_type='sigmoid') param_nodes = [layer0, layer1, layer2, layer3, chord_estimator] # 1.1 Create Loss likelihoods = optimus.SelectIndex('select') dimshuffle = optimus.Dimshuffle('dimshuffle', (0, 'x')) error = optimus.SquaredEuclidean(name='squared_error') main_loss = optimus.Mean(name='mean_squared_error') loss_nodes1 = [likelihoods, dimshuffle, error, main_loss] negone = optimus.Gain(name='negate') negone.weight.value = -1.0 summer = optimus.Add(name='moia_sum') flatten = optimus.Sum('flatten', axis=1) dimshuffle2 = optimus.Dimshuffle('dimshuffle2', (0, 'x')) margin = optimus.RectifiedLinear(name='margin') weight = optimus.Multiply(name="margin_weight") margin_loss = optimus.Mean(name='margin_loss', axis=None) loss_nodes2 = [negone, summer, margin, flatten, dimshuffle2, margin_loss, weight] total_loss = optimus.Add("total_loss") # 2. Define Edges base_edges = [ (input_data, layer0.input), (layer0.output, layer1.input), (layer1.output, layer2.input), (layer2.output, layer3.input), (layer3.output, chord_estimator.input)] trainer_edges = optimus.ConnectionManager( base_edges + [ (chord_estimator.output, likelihoods.input), (chord_idx, likelihoods.index), (likelihoods.output, dimshuffle.input), (dimshuffle.output, error.input_a), (target, error.input_b), (error.output, main_loss.input), # Margin loss (dimshuffle.output, negone.input), (negone.output, summer.input_list), (chord_estimator.output, summer.input_list), (summer.output, margin.input), (margin.output, flatten.input), (flatten.output, dimshuffle2.input), (dimshuffle2.output, weight.input_a), (target, weight.input_b), (weight.output, margin_loss.input), (margin_loss.output, total_loss.input_list), (main_loss.output, total_loss.input_list)]) update_manager = optimus.ConnectionManager( map(lambda n: (learning_rate, n.weights), param_nodes) + map(lambda n: (learning_rate, n.bias), param_nodes)) all_nodes = param_nodes + loss_nodes1 + loss_nodes2 + [total_loss] trainer = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, target, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[total_loss.output], loss=total_loss.output, updates=update_manager.connections, verbose=True) for n in param_nodes: for p in n.params.values(): optimus.random_init(p) posterior = optimus.Output( name='posterior') predictor_edges = optimus.ConnectionManager( base_edges + [(chord_estimator.output, posterior)]) predictor = optimus.Graph( name=GRAPH_NAME, inputs=[input_data], nodes=param_nodes, connections=predictor_edges.connections, outputs=[posterior]) return trainer, predictor
def main(args): # 1.1 Create Inputs input_data = optimus.Input(name='cqt', shape=(None, OCTAVE_DIM, TIME_DIM, PITCH_DIM)) chord_idx = optimus.Input(name='chord_idx', shape=(None, ), dtype='int32') 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, None, 5, 5), pool_shape=(2, 3), act_type='relu') layer1 = optimus.Conv3D(name='layer1', input_shape=layer0.output.shape, weight_shape=(64, None, 5, 7), act_type='relu') layer2 = optimus.Conv3D(name='layer2', input_shape=layer1.output.shape, weight_shape=(128, None, 3, 6), act_type='relu') layer3 = optimus.Affine(name='layer3', input_shape=layer2.output.shape, output_shape=( None, 1024, ), act_type='relu') chord_classifier = optimus.Softmax(name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood(name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx) ]) 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, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections) for n in all_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) if args.init_param_file: print "Loading parameters: %s" % args.init_param_file trainer.load_param_values(args.init_param_file) 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=4) if args.secondary_source: stash2 = biggie.Stash(args.secondary_source) stream2 = D.create_uniform_chord_stream(stash2, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, working_size=5) stream = S.mux([stream, stream2], [0.5, 0.5]) stream = S.minibatch(stream, 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)) 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, 9, 19), pool_shape=(2, 3), act_type='relu') layer1 = optimus.Conv3D(name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 7, 15), pool_shape=(2, 1), act_type='relu') layer2 = optimus.Conv3D(name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 5, 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)) chord_idx = optimus.Input(name='chord_idx', shape=(None, ), dtype='int32') 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_classifier = optimus.Softmax(name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood(name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx) ]) 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, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections, momentum=None) for n in all_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) trainer.load_param_values( "/media/attic/dl4mir/chord_estimation/models/nll_chord_uniform_2big/synth_data_01/0/classifier-V157-synth_data_01-041750-2014-08-25_21h59m56s.npz" ) validator = optimus.Graph(name=GRAPH_NAME, inputs=[input_data, chord_idx], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll]) 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=False, vocab_dim=VOCAB, working_size=3) stream = S.minibatch(stream, 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)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') 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, 5, 19), pool_shape=(1, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 5, 15), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 2, 15), act_type='relu') layer3 = optimus.Affine( name='layer3', input_shape=layer2.output.shape, output_shape=(None, 512,), act_type='relu') chord_classifier = optimus.Softmax( name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood( name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx)]) 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, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections) optimus.random_init(chord_classifier.weights) validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll]) 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 source = optimus.Queue( optimus.File(args.training_file), transformers=[ T.chord_sample(input_data.shape[2]), T.pitch_shift(8), T.map_to_index(VOCAB)], **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, 6, TIME_DIM, 40)) 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, None, 5, 5), pool_shape=(2, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(64, None, 5, 7), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(128, None, 3, 6), 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='sigmoid') all_nodes = [layer0, layer1, layer2, layer3, chord_estimator] # 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_estimator.input), (chord_estimator.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_estimator.weights), (learning_rate, chord_estimator.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, 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], 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( FX.wrap_cqt(stream, length=40, stride=36), 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)) 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, 9, 19), pool_shape=(1, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 7, 15), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 6, 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, 252)) chord_idx = optimus.Input(name='chord_idx', shape=(None, ), dtype='int32') learning_rate = optimus.Input(name='learning_rate', shape=None) dropout = optimus.Input(name='dropout', 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') for n in [layer2, layer3]: n.enable_dropout() chord_classifier = optimus.Softmax(name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood(name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx), (dropout, layer2.dropout), (dropout, layer3.dropout) ]) 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, chord_idx, learning_rate, dropout], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections) for n in all_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) validator_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_nll.likelihood), (chord_idx, chord_nll.target_idx) ]) for n in [layer2, layer3]: n.disable_dropout() validator = optimus.Graph(name=GRAPH_NAME, inputs=[input_data, chord_idx], nodes=all_nodes, connections=validator_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll]) 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) s = D.create_uniform_chord_stream(stash, TIME_DIM, pitch_shift=6, vocab_dim=VOCAB, working_size=10) stream = S.minibatch(FX.drop_frames(FX.awgn(s, 0.05), 0.1), batch_size=BATCH_SIZE) driver = optimus.Driver(graph=trainer, name=args.trial_name, output_directory=args.model_directory) hyperparams = {learning_rate.name: LEARNING_RATE, dropout.name: DROPOUT} 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) print "Starting '%s'" % args.trial_name 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, PITCH_DIM)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') 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.Softmax( name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_mce = optimus.ClassificationError( name="chord_mce") # 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_mce.prediction), (chord_idx, chord_mce.target_idx)]) 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, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_mce], updates=update_manager.connections) for n in all_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) if args.init_param_file: trainer.load_param_values(args.init_param_file) 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) synth_stash = biggie.Stash(args.secondary_source) stream = D.muxed_uniform_chord_stream( stash, synth_stash, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, working_size=10) # stream = D.create_uniform_chord_stream( # stash, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, working_size=10) # if args.secondary_source: # print "Loading %s" % args.secondary_source # stash2 = biggie.Stash(args.secondary_source) # stream2 = D.create_uniform_chord_stream( # stash2, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, working_size=5) # stream = S.mux([stream, stream2], [0.5, 0.5]) stream = S.minibatch(stream, 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)) chord_idx = optimus.Input(name='chord_idx', shape=(None, ), dtype='int32') 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, 5, 19), pool_shape=(1, 3), act_type='relu') layer1 = optimus.Conv3D(name='layer1', input_shape=layer0.output.shape, weight_shape=(16, None, 5, 15), act_type='relu') layer2 = optimus.Conv3D(name='layer2', input_shape=layer1.output.shape, weight_shape=(20, None, 2, 15), act_type='relu') layer3 = optimus.Affine(name='layer3', input_shape=layer2.output.shape, output_shape=( None, 512, ), act_type='relu') chord_classifier = optimus.Softmax(name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood(name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx) ]) 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, chord_idx, learning_rate], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections) optimus.random_init(chord_classifier.weights) validator = optimus.Graph(name=GRAPH_NAME, inputs=[input_data, chord_idx], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll]) 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 source = optimus.Queue(optimus.File(args.training_file), transformers=[ T.chord_sample(input_data.shape[2]), T.pitch_shift(8), T.map_to_index(VOCAB) ], **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, 252)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') learning_rate = optimus.Input( name='learning_rate', shape=None) dropout = optimus.Input( name='dropout', 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') for n in [layer2, layer3]: n.enable_dropout() chord_classifier = optimus.Softmax( name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] # 1.1 Create Losses chord_nll = optimus.NegativeLogLikelihood( name="chord_nll") # 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_nll.likelihood), (chord_idx, chord_nll.target_idx), (dropout, layer2.dropout), (dropout, layer3.dropout)]) 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, chord_idx, learning_rate, dropout], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll], updates=update_manager.connections) for n in all_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) validator_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_nll.likelihood), (chord_idx, chord_nll.target_idx)]) for n in [layer2, layer3]: n.disable_dropout() validator = optimus.Graph( name=GRAPH_NAME, inputs=[input_data, chord_idx], nodes=all_nodes, connections=validator_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[chord_nll]) 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) s = D.create_uniform_chord_stream( stash, TIME_DIM, pitch_shift=6, vocab_dim=VOCAB, working_size=10) stream = S.minibatch( FX.drop_frames(FX.awgn(s, 0.05), 0.1), batch_size=BATCH_SIZE) driver = optimus.Driver( graph=trainer, name=args.trial_name, output_directory=args.model_directory) hyperparams = {learning_rate.name: LEARNING_RATE, dropout.name: DROPOUT} 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) print "Starting '%s'" % args.trial_name driver.fit(stream, hyperparams=hyperparams, **DRIVER_ARGS)
def main(args): # 1.1 Create Inputs input_data = optimus.Input( name='cqt', shape=(None, OCTAVE_DIM, TIME_DIM, PITCH_DIM)) chord_idx = optimus.Input( name='chord_idx', shape=(None,), dtype='int32') learning_rate = optimus.Input( name='learning_rate', shape=None) margin = optimus.Input( name='margin', shape=None) # 1.2 Create Nodes layer0 = optimus.Conv3D( name='layer0', input_shape=input_data.shape, weight_shape=(32, None, 5, 5), pool_shape=(2, 3), act_type='relu') layer1 = optimus.Conv3D( name='layer1', input_shape=layer0.output.shape, weight_shape=(64, None, 5, 7), act_type='relu') layer2 = optimus.Conv3D( name='layer2', input_shape=layer1.output.shape, weight_shape=(128, None, 3, 6), act_type='relu') layer3 = optimus.Affine( name='layer3', input_shape=layer2.output.shape, output_shape=(None, 1024,), act_type='relu') chord_estimator = optimus.Softmax( name='chord_estimator', input_shape=layer3.output.shape, output_shape=(None, VOCAB,), act_type='sigmoid') all_nodes = [layer0, layer1, layer2, layer3, chord_classifier] log = optimus.Log(name='log') neg = optimus.Gain(name='gain') neg.weight = np.array(-1) energy = optimus.SelectIndex(name='selector') loss = optimus.Mean(name='total_loss') # 1.1 Create Losses chord_margin = optimus.Margin( name="chord_margin", mode='max') # 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, log.input), (log.output, neg.input), (neg.output, energy.input), (chord_idx, energy.index), (energy.output, loss.input)]) 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, chord_idx, learning_rate, margin], nodes=all_nodes, connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], loss=[loss.output], updates=update_manager.connections) for n in all_nodes: optimus.random_init(n.weights) optimus.random_init(n.bias) if args.init_param_file: print "Loading parameters: %s" % args.init_param_file trainer.load_param_values(args.init_param_file) for n in all_nodes[-2:]: optimus.random_init(n.weights) optimus.random_init(n.bias) 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_stash_stream( stash, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, pool_size=25) if args.secondary_source: stash2 = biggie.Stash(args.secondary_source) stream2 = D.create_uniform_chord_stream( stash2, TIME_DIM, pitch_shift=0, vocab_dim=VOCAB, working_size=5) stream = S.mux([stream, stream2], [0.5, 0.5]) stream = S.minibatch(stream, 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, margin.name: MARGIN} predictor_file = path.join(driver.output_directory, args.predictor_file) optimus.save(predictor, def_file=predictor_file) driver.fit(stream, hyperparams=hyperparams, **DRIVER_ARGS)