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='relu') layer1 = optimus.Affine(name='layer1', input_shape=layer0.output.shape, output_shape=(None, 100), act_type='relu') classifier = optimus.Softmax(name='classifier', input_shape=layer1.output.shape, n_out=N_CLASSES, act_type='linear') nll = optimus.NegativeLogLikelihood(name="nll") posterior = optimus.Output(name='posterior') trainer_edges = optimus.ConnectionManager([ (x_in, layer0.input), (layer0.output, layer1.input), (layer1.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, layer1.weights), (learning_rate, layer1.bias), (learning_rate, classifier.weights), (learning_rate, classifier.bias) ]) trainer = optimus.Graph(name='trainer', inputs=[x_in, class_idx, learning_rate], nodes=[layer0, layer1, classifier], connections=trainer_edges.connections, outputs=[optimus.Graph.TOTAL_LOSS], losses=[nll], updates=update_manager.connections) optimus.random_init(layer0.weights) optimus.random_init(layer1.weights) optimus.random_init(classifier.weights) predictor_edges = optimus.ConnectionManager([ (x_in, layer0.input), (layer0.output, layer1.input), (layer1.output, classifier.input), (classifier.output, posterior) ]) predictor = optimus.Graph(name='predictor', inputs=[x_in], nodes=[layer0, layer1, 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') 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.Affine(name='chord_classifier', input_shape=layer3.output.shape, output_shape=(None, VOCAB), act_type='sigmoid') 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, 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') chord_classifier = optimus.Softmax(name='chord_classifier', input_shape=layer3.output.shape, n_out=VOCAB, act_type='linear') all_nodes = [ input_scalar, 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, input_scalar.input), (input_scalar.output, 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[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') 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, 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 = 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=(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, 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=10, valid_idx=range(60) + [156]) 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)) 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, 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) 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)