def _del(args): if len(args) != 1: raise CommandError, "del requires a model name as an argument" models = HPChordLabeler.list_models() model_name = args[0] if model_name not in models: print >>sys.stderr, "No model %s" % model_name model = _load_model(model_name) print "Deleting %s" % model_name model.delete()
def main(): usage = "%prog [options] <model_name> <in-file>" description = "Trains a chord labeling model using the given "\ "input data. The data file may be a stored SequenceIndex file, or "\ "any other type of bulk data file." parser = OptionParser(usage=usage, description=description) parser.add_option( '-p', '--partitions', dest="partitions", action="store", type="int", help= "train a number of partitions of the given data. Trains a model on the complement of each partition, so it can be tested on the partition. The models will be named <NAME>n, where <NAME> is the model name and n the partition number." ) parser.add_option( '--opts', dest="training_opts", action="append", help= "options to pass to the model trainer. Type '--opts help' for a list of options for a particular model type." ) # File input options parser.add_option( "--filetype", "--ft", dest="filetype", action="store", help= "select the file type for the input file. Same filetypes as jazzparser", default='bulk-db') parser.add_option( "--file-options", "--fopt", dest="file_options", action="store", help= "options for the input file. Type '--fopt help', using '--ft <type>' to select file type, for a list of available options." ) # Logging output parser.add_option( '--log', dest="log", action="store", help= "file to output training logs to. Specify a base filename; <modelname>.log will be added to the end" ) options, arguments = parse_args_with_config(parser) grammar = Grammar() # Handle any training options that were given on the command line if options.training_opts is None: training_opts = {} elif "help" in [opt.lower() for opt in options.training_opts]: print options_help_text(HPChordLabeler.TRAINING_OPTIONS, intro="Training options:") sys.exit(0) else: training_opts = ModuleOption.process_option_string( options.training_opts) if len(arguments) < 2: print >> sys.stderr, "You must specify a model name and an input data file as arguments" sys.exit(1) filename = os.path.abspath(arguments[1]) model_name = arguments[0] # Load the sequence data # Only allow bulk types input_data = command_line_input(filename=filename, filetype=options.filetype, options=options.file_options, allowed_types=get_input_type_names( single=False, bulk=True)) # Only partition the chord data, not the MIDI data if options.partitions is not None and not \ (isinstance(input_data, MidiTaggerTrainingBulkInput) and \ input_data.chords is not None): print >>sys.stderr, "Can only partition chord data and no chord data "\ "was supplied" sys.exit(1) if options.partitions: # The input includes chord training data parts = input_data.chords.get_partitions(options.partitions)[1] models = [("%s%d" % (model_name,num),chord_data) \ for num,chord_data in enumerate(parts)] else: models = [(model_name, None)] for part_name, chord_data in models: if options.log is not None: # Prepare a logger logfile = "%s%s.log" % (options.log, part_name) print "Logging output to file %s" % logfile logger = create_logger(filename=logfile) else: logger = None # Create a fresh model with this name model = HPChordLabeler.train(input_data, part_name, logger=logger, options=training_opts, chord_data=chord_data) print "Trained model %s" % (part_name)
def _list(args): # List the available models for the given model type models = HPChordLabeler.list_models() print "Available models:" print ", ".join(list(sorted(models)))
def _load_model(name): # Load the model from its file return HPChordLabeler.load_model(name)
def main(): usage = "%prog [options] <model_name> <in-file>" description = "Loads a chord labeling model and uses it to assign chord "\ "labels to the given MIDI file." parser = OptionParser(usage=usage, description=description) # File input options parser.add_option( "--filetype", "--ft", dest="filetype", action="store", help= "select the file type for the input file. Same filetypes as jazzparser", default='segmidi') parser.add_option( "--file-options", "--fopt", dest="file_options", action="store", help= "options for the input file. Type '--fopt help', using '--ft <type>' to select file type, for a list of available options." ) # Labeling options parser.add_option( "--labeler-options", "--lopt", dest="labeler_options", action="append", help= "options for the labeler. Type '--lopt help' for a list of available options." ) parser.add_option( "--no-key", "--nk", dest="no_key", action="store_true", help="merge together labels with the same key (same as --lopt nokey)") # Output options parser.add_option( "--single", "-1", dest="single", action="store_true", help= "show only one chord per time segment (same as --lopt n=1, but formats the output in a simpler way)" ) parser.add_option( '-r', '--realize', dest="realize", action="store", help="realize the chord sequence as a midi file, overlaid on the input" ) parser.add_option( '--chords-only', dest="chords_only", action="store_true", help= "only realize the chords: don't overlay on the input midi (only works with -r)" ) options, arguments = parse_args_with_config(parser) if options.labeler_options is not None and "help" in options.labeler_options: print options_help_text(HPChordLabeler.LABELING_OPTIONS, intro="Options for HP chord labeler") sys.exit(0) if len(arguments) < 2: print >>sys.stderr, "You must specify a model name and an input "\ "(MIDI) data file as arguments" sys.exit(1) filename = os.path.abspath(arguments[1]) model_name = arguments[0] # Process the labeler options lopt_dict = ModuleOption.process_option_string(options.labeler_options) if options.single: # No point in getting more than one label, since we only display one lopt_dict['n'] = 1 if options.no_key: # Just set the nokey option lopt_dict['nokey'] = True # Check they're valid before doing anything else HPChordLabeler.process_labeling_options(lopt_dict) input_data = command_line_input(filename, filetype=options.filetype, options=options.file_options, allowed_types=['segmidi', 'bulk-segmidi']) bulk = not is_bulk_type(type(input_data)) if bulk: input_data = [input_data] for i, data in enumerate(input_data): input_stream = data.stream print "Read midi data in %d segments" % len(data) # Load the model model = HPChordLabeler.load_model(model_name) # Perform labeling labels = model.label(data, options=lopt_dict) # Try labeling as it will be passed to the tagger labs = model.label_lattice(data, options=lopt_dict) if options.single: # Special output for single label output print ", ".join(["%s" % timelabs[0][0] for timelabs in labels]) else: # Print out the labels for each timestep for time, timelabs in enumerate(labels): print "%d: %s" % (time, ", ".join([ "%s (%.2e)" % (label, prob) for (label, prob) in timelabs ])) if options.realize is not None: # Get the single best chord label for each time best_labels = [timelabs[0][0] for timelabs in labels] # Realize as a midi file print "Realizing output chord sequence" real = ChordSequenceRealizer(best_labels, model.chord_vocab, resolution=input_stream.resolution, chord_length=data.time_unit, text_events=True) if options.chords_only: # Don't overlay stream = real.generate(offset=data.tick_offset) else: stream = real.generate(overlay=input_stream, offset=data.tick_offset) if bulk: filename = "%s-%d" % (options.realize, i) else: filename = options.realize write_midifile(stream, filename)
def main(): usage = "%prog [options] <model_name> <in-file>" description = "Trains a chord labeling model using the given "\ "input data. The data file may be a stored SequenceIndex file, or "\ "any other type of bulk data file." parser = OptionParser(usage=usage, description=description) parser.add_option('-p', '--partitions', dest="partitions", action="store", type="int", help="train a number of partitions of the given data. Trains a model on the complement of each partition, so it can be tested on the partition. The models will be named <NAME>n, where <NAME> is the model name and n the partition number.") parser.add_option('--opts', dest="training_opts", action="append", help="options to pass to the model trainer. Type '--opts help' for a list of options for a particular model type.") # File input options parser.add_option("--filetype", "--ft", dest="filetype", action="store", help="select the file type for the input file. Same filetypes as jazzparser", default='bulk-db') parser.add_option("--file-options", "--fopt", dest="file_options", action="store", help="options for the input file. Type '--fopt help', using '--ft <type>' to select file type, for a list of available options.") # Logging output parser.add_option('--log', dest="log", action="store", help="file to output training logs to. Specify a base filename; <modelname>.log will be added to the end") options, arguments = parse_args_with_config(parser) grammar = Grammar() # Handle any training options that were given on the command line if options.training_opts is None: training_opts = {} elif "help" in [opt.lower() for opt in options.training_opts]: print options_help_text(HPChordLabeler.TRAINING_OPTIONS, intro="Training options:") sys.exit(0) else: training_opts = ModuleOption.process_option_string(options.training_opts) if len(arguments) < 2: print >>sys.stderr, "You must specify a model name and an input data file as arguments" sys.exit(1) filename = os.path.abspath(arguments[1]) model_name = arguments[0] # Load the sequence data # Only allow bulk types input_data = command_line_input(filename=filename, filetype=options.filetype, options=options.file_options, allowed_types=get_input_type_names(single=False, bulk=True)) # Only partition the chord data, not the MIDI data if options.partitions is not None and not \ (isinstance(input_data, MidiTaggerTrainingBulkInput) and \ input_data.chords is not None): print >>sys.stderr, "Can only partition chord data and no chord data "\ "was supplied" sys.exit(1) if options.partitions: # The input includes chord training data parts = input_data.chords.get_partitions(options.partitions)[1] models = [("%s%d" % (model_name,num),chord_data) \ for num,chord_data in enumerate(parts)] else: models = [(model_name,None)] for part_name,chord_data in models: if options.log is not None: # Prepare a logger logfile = "%s%s.log" % (options.log, part_name) print "Logging output to file %s" % logfile logger = create_logger(filename=logfile) else: logger = None # Create a fresh model with this name model = HPChordLabeler.train(input_data, part_name, logger=logger, options=training_opts, chord_data=chord_data) print "Trained model %s" % (part_name)
def main(): usage = "%prog [options] <model_name> <in-file>" description = "Loads a chord labeling model and uses it to assign chord "\ "labels to the given MIDI file." parser = OptionParser(usage=usage, description=description) # File input options parser.add_option("--filetype", "--ft", dest="filetype", action="store", help="select the file type for the input file. Same filetypes as jazzparser", default='segmidi') parser.add_option("--file-options", "--fopt", dest="file_options", action="store", help="options for the input file. Type '--fopt help', using '--ft <type>' to select file type, for a list of available options.") # Labeling options parser.add_option("--labeler-options", "--lopt", dest="labeler_options", action="append", help="options for the labeler. Type '--lopt help' for a list of available options.") parser.add_option("--no-key", "--nk", dest="no_key", action="store_true", help="merge together labels with the same key (same as --lopt nokey)") # Output options parser.add_option("--single", "-1", dest="single", action="store_true", help="show only one chord per time segment (same as --lopt n=1, but formats the output in a simpler way)") parser.add_option('-r', '--realize', dest="realize", action="store", help="realize the chord sequence as a midi file, overlaid on the input") parser.add_option('--chords-only', dest="chords_only", action="store_true", help="only realize the chords: don't overlay on the input midi (only works with -r)") options, arguments = parse_args_with_config(parser) if options.labeler_options is not None and "help" in options.labeler_options: print options_help_text(HPChordLabeler.LABELING_OPTIONS, intro="Options for HP chord labeler") sys.exit(0) if len(arguments) < 2: print >>sys.stderr, "You must specify a model name and an input "\ "(MIDI) data file as arguments" sys.exit(1) filename = os.path.abspath(arguments[1]) model_name = arguments[0] # Process the labeler options lopt_dict = ModuleOption.process_option_string(options.labeler_options) if options.single: # No point in getting more than one label, since we only display one lopt_dict['n'] = 1 if options.no_key: # Just set the nokey option lopt_dict['nokey'] = True # Check they're valid before doing anything else HPChordLabeler.process_labeling_options(lopt_dict) input_data = command_line_input(filename, filetype=options.filetype, options=options.file_options, allowed_types=['segmidi','bulk-segmidi']) bulk = not is_bulk_type(type(input_data)) if bulk: input_data = [input_data] for i,data in enumerate(input_data): input_stream = data.stream print "Read midi data in %d segments" % len(data) # Load the model model = HPChordLabeler.load_model(model_name) # Perform labeling labels = model.label(data, options=lopt_dict) # Try labeling as it will be passed to the tagger labs = model.label_lattice(data, options=lopt_dict) if options.single: # Special output for single label output print ", ".join(["%s" % timelabs[0][0] for timelabs in labels]) else: # Print out the labels for each timestep for time,timelabs in enumerate(labels): print "%d: %s" % (time, ", ".join(["%s (%.2e)" % (label,prob) for (label,prob) in timelabs])) if options.realize is not None: # Get the single best chord label for each time best_labels = [timelabs[0][0] for timelabs in labels] # Realize as a midi file print "Realizing output chord sequence" real = ChordSequenceRealizer(best_labels, model.chord_vocab, resolution=input_stream.resolution, chord_length=data.time_unit, text_events=True) if options.chords_only: # Don't overlay stream = real.generate(offset=data.tick_offset) else: stream = real.generate(overlay=input_stream, offset=data.tick_offset) if bulk: filename = "%s-%d" % (options.realize, i) else: filename = options.realize write_midifile(stream, filename)
# Work out how many results to print out if options.print_results == -1: print_up_to = None else: print_up_to = options.print_results # Process the labeler options lopt_dict = ModuleOption.process_option_string(options.labeler_options) # No point in getting more than one label, since we'll only use one lopt_dict['viterbi'] = True lopt_dict['nokey'] = True # Load the chord labeling model model_name = arguments[1] model = HPChordLabeler.load_model(model_name) ranks = [] num_ranked = 0 for midi_file in input_data: # Skip any inputs that don't have a gold sequence associated with them # We won't know what the correct answer is if options.gold_only and midi_file.gold is None: continue print "######################" print "Processing %s" % midi_file.name # Try to get a correct answer from the PR file if midi_file.gold is None: print "No correct answer specified in input file"