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"
