aiexperiments-ai-duet/server/third_party/magenta/music/melodies_lib.py
2016-11-11 15:34:34 -05:00

849 lines
33 KiB
Python

# Copyright 2016 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utility functions for working with melodies.
Use extract_melodies to extract monophonic melodies from a QuantizedSequence
object.
Use MonophonicMelody.to_sequence to write a melody to a NoteSequence proto. Then
use midi_io.sequence_proto_to_midi_file to write that NoteSequence to a midi
file.
Use MelodyEncoderDecoder.squash_and_encode to convert a MonophonicMelody object
to a tf.train.SequenceExample of inputs and labels. These SequenceExamples are
fed into the model during training and evaluation.
During melody generation, use MelodyEncoderDecoder.get_inputs_batch to convert
a list of melodies into an inputs batch which can be fed into the model to
predict what the next note should be for each melody. Then use
MelodyEncoderDecoder.extend_event_sequences to extend each of those melodies
with an event sampled from the softmax output by the model.
"""
import abc
# internal imports
import numpy as np
from six.moves import range # pylint: disable=redefined-builtin
from magenta.music import constants
from magenta.music import events_lib
from magenta.pipelines import statistics
from magenta.protobuf import music_pb2
NUM_SPECIAL_MELODY_EVENTS = constants.NUM_SPECIAL_MELODY_EVENTS
MELODY_NOTE_OFF = constants.MELODY_NOTE_OFF
MELODY_NO_EVENT = constants.MELODY_NO_EVENT
MIN_MELODY_EVENT = constants.MIN_MELODY_EVENT
MAX_MELODY_EVENT = constants.MAX_MELODY_EVENT
MIN_MIDI_PITCH = constants.MIN_MIDI_PITCH
MAX_MIDI_PITCH = constants.MAX_MIDI_PITCH
NOTES_PER_OCTAVE = constants.NOTES_PER_OCTAVE
DEFAULT_STEPS_PER_BAR = constants.DEFAULT_STEPS_PER_BAR
DEFAULT_STEPS_PER_QUARTER = constants.DEFAULT_STEPS_PER_QUARTER
STANDARD_PPQ = constants.STANDARD_PPQ
NOTE_KEYS = constants.NOTE_KEYS
class PolyphonicMelodyException(Exception):
pass
class BadNoteException(Exception):
pass
class MonophonicMelody(events_lib.SimpleEventSequence):
"""Stores a quantized stream of monophonic melody events.
MonophonicMelody is an intermediate representation that all melody models
can use. QuantizedSequence to MonophonicMelody code will do work to align
notes and extract monophonic melodies. Model-specific code then needs to
convert MonophonicMelody to SequenceExample protos for TensorFlow.
MonophonicMelody implements an iterable object. Simply iterate to retrieve
the melody events.
MonophonicMelody events are integers in range [-2, 127] (inclusive),
where negative values are the special event events: MELODY_NOTE_OFF, and
MELODY_NO_EVENT. Non-negative values [0, 127] are note-on events for that
midi pitch. A note starts at a non-negative value (that is the pitch), and is
held through subsequent NO_MELODY_EVENT events until either another non-
negative value is reached (even if the pitch is the same as the previous
note), or a MELODY_NOTE_OFF event is reached. A MELODY_NOTE_OFF starts at
least one step of silence, which continues through MELODY_NO_EVENT events
until the next non-negative value.
MELODY_NO_EVENT values are treated as default filler. Notes must be inserted
in ascending order by start time. Note end times will be truncated if the next
note overlaps.
Any sustained notes are implicitly turned off at the end of a melody.
Melodies can start at any non-negative time, and are shifted left so that
the bar containing the first note-on event is the first bar.
Attributes:
start_step: The offset of the first step of the melody relative to the
beginning of the source sequence. Will always be the first step of a
bar.
end_step: The offset to the beginning of the bar following the last step
of the melody relative the beginning of the source sequence. Will always
be the first step of a bar.
steps_per_quarter: Number of steps in in a quarter note.
steps_per_bar: Number of steps in a bar (measure) of music.
"""
def __init__(self):
"""Construct an empty MonophonicMelody."""
super(MonophonicMelody, self).__init__(pad_event=MELODY_NO_EVENT)
def __deepcopy__(self, unused_memo=None):
new_copy = type(self)()
new_copy.from_event_list(list(self._events),
self.start_step,
self.steps_per_bar,
self.steps_per_quarter)
return new_copy
def __eq__(self, other):
if not isinstance(other, MonophonicMelody):
return False
else:
return super(MonophonicMelody, self).__eq__(other)
def _add_note(self, pitch, start_step, end_step):
"""Adds the given note to the `events` list.
`start_step` is set to the given pitch. `end_step` is set to NOTE_OFF.
Everything after `start_step` in `events` is deleted before the note is
added. `events`'s length will be changed so that the last event has index
`end_step`.
Args:
pitch: Midi pitch. An integer between 0 and 127 inclusive.
start_step: A non-negative integer step that the note begins on.
end_step: An integer step that the note ends on. The note is considered to
end at the onset of the end step. `end_step` must be greater than
`start_step`.
Raises:
BadNoteException: If `start_step` does not precede `end_step`.
"""
if start_step >= end_step:
raise BadNoteException(
'Start step does not precede end step: start=%d, end=%d' %
(start_step, end_step))
self.set_length(end_step + 1)
self._events[start_step] = pitch
self._events[end_step] = MELODY_NOTE_OFF
for i in range(start_step + 1, end_step):
self._events[i] = MELODY_NO_EVENT
def _get_last_on_off_events(self):
"""Returns indexes of the most recent pitch and NOTE_OFF events.
Returns:
A tuple (start_step, end_step) of the last note's on and off event
indices.
Raises:
ValueError: If `events` contains no NOTE_OFF or pitch events.
"""
last_off = len(self)
for i in range(len(self) - 1, -1, -1):
if self._events[i] == MELODY_NOTE_OFF:
last_off = i
if self._events[i] >= MIN_MIDI_PITCH:
return (i, last_off)
raise ValueError('No events in the stream')
def get_note_histogram(self):
"""Gets a histogram of the note occurrences in a melody.
Returns:
A list of 12 ints, one for each note value (C at index 0 through B at
index 11). Each int is the total number of times that note occurred in
the melody.
"""
np_melody = np.array(self._events, dtype=int)
return np.bincount(np_melody[np_melody >= MIN_MIDI_PITCH] %
NOTES_PER_OCTAVE,
minlength=NOTES_PER_OCTAVE)
def get_major_key_histogram(self):
"""Gets a histogram of the how many notes fit into each key.
Returns:
A list of 12 ints, one for each Major key (C Major at index 0 through
B Major at index 11). Each int is the total number of notes that could
fit into that key.
"""
note_histogram = self.get_note_histogram()
key_histogram = np.zeros(NOTES_PER_OCTAVE)
for note, count in enumerate(note_histogram):
key_histogram[NOTE_KEYS[note]] += count
return key_histogram
def get_major_key(self):
"""Finds the major key that this melody most likely belongs to.
If multiple keys match equally, the key with the lowest index is returned,
where the indexes of the keys are C Major = 0 through B Major = 11.
Returns:
An int for the most likely key (C Major = 0 through B Major = 11)
"""
key_histogram = self.get_major_key_histogram()
return key_histogram.argmax()
def append_event(self, event):
"""Appends the event to the end of the melody and increments the end step.
An implicit NOTE_OFF at the end of the melody will not be respected by this
modification.
Args:
event: The integer MonophonicMelody event to append to the end.
Raises:
ValueError: If `event` is not in the proper range.
"""
if not MIN_MELODY_EVENT <= event <= MAX_MELODY_EVENT:
raise ValueError('Event out of range: %d' % event)
super(MonophonicMelody, self).append_event(event)
def from_quantized_sequence(self,
quantized_sequence,
start_step=0,
track=0,
gap_bars=1,
ignore_polyphonic_notes=False,
pad_end=False):
"""Populate self with a melody from the given QuantizedSequence object.
A monophonic melody is extracted from the given `track` starting at time
step `start_step`. `track` and `start_step` can be used to drive extraction
of multiple melodies from the same QuantizedSequence. The end step of the
extracted melody will be stored in `self._end_step`.
0 velocity notes are ignored. The melody extraction is ended when there are
no held notes for a time stretch of `gap_bars` in bars (measures) of music.
The number of time steps per bar is computed from the time signature in
`quantized_sequence`.
`ignore_polyphonic_notes` determines what happens when polyphonic (multiple
notes start at the same time) data is encountered. If
`ignore_polyphonic_notes` is true, the highest pitch is used in the melody
when multiple notes start at the same time. If false, an exception is
raised.
Args:
quantized_sequence: A sequences_lib.QuantizedSequence instance.
start_step: Start searching for a melody at this time step.
track: Search for a melody in this track number.
gap_bars: If this many bars or more follow a NOTE_OFF event, the melody
is ended.
ignore_polyphonic_notes: If True, the highest pitch is used in the melody
when multiple notes start at the same time. If False,
PolyphonicMelodyException will be raised if multiple notes start at
the same time.
pad_end: If True, the end of the melody will be padded with NO_EVENTs so
that it will end at a bar boundary.
Raises:
NonIntegerStepsPerBarException: If `quantized_sequence`'s bar length
(derived from its time signature) is not an integer number of time
steps.
PolyphonicMelodyException: If any of the notes start on the same step
and `ignore_polyphonic_notes` is False.
"""
self._reset()
offset = None
steps_per_bar_float = quantized_sequence.steps_per_bar()
if steps_per_bar_float % 1 != 0:
raise events_lib.NonIntegerStepsPerBarException(
'There are %f timesteps per bar. Time signature: %d/%d' %
(steps_per_bar_float, quantized_sequence.time_signature.numerator,
quantized_sequence.time_signature.denominator))
self._steps_per_bar = steps_per_bar = int(steps_per_bar_float)
self._steps_per_quarter = quantized_sequence.steps_per_quarter
# Sort track by note start times, and secondarily by pitch descending.
notes = sorted(quantized_sequence.tracks[track],
key=lambda note: (note.start, -note.pitch))
for note in notes:
if note.start < start_step:
continue
# Ignore 0 velocity notes.
if not note.velocity:
continue
if offset is None:
offset = note.start - note.start % steps_per_bar
start_index = note.start - offset
end_index = note.end - offset
if not self._events:
# If there are no events, we don't need to check for polyphony.
self._add_note(note.pitch, start_index, end_index)
continue
# If start_step comes before or lands on an already added note's start
# step, we cannot add it. In that case either discard the melody or keep
# the highest pitch.
last_on, last_off = self._get_last_on_off_events()
on_distance = start_index - last_on
off_distance = start_index - last_off
if on_distance == 0:
if ignore_polyphonic_notes:
# Keep highest note.
# Notes are sorted by pitch descending, so if a note is already at
# this position its the highest pitch.
continue
else:
self._reset()
raise PolyphonicMelodyException()
elif on_distance < 0:
raise PolyphonicMelodyException(
'Unexpected note. Not in ascending order.')
# If a gap of `gap` or more steps is found, end the melody.
if len(self) and off_distance >= gap_bars * steps_per_bar:
break
# Add the note-on and off events to the melody.
self._add_note(note.pitch, start_index, end_index)
if not self._events:
# If no notes were added, don't set `start_step` and `end_step`.
return
self._start_step = offset
# Strip final MELODY_NOTE_OFF event.
if self._events[-1] == MELODY_NOTE_OFF:
del self._events[-1]
length = len(self)
# Optionally round up `end_step` to a multiple of `steps_per_bar`.
if pad_end:
length += -len(self) % steps_per_bar
self.set_length(length)
def from_event_list(self, events, start_step=0,
steps_per_bar=DEFAULT_STEPS_PER_BAR,
steps_per_quarter=DEFAULT_STEPS_PER_QUARTER):
"""Initialies with a list of event values and sets attributes appropriately.
Args:
events: List of MonophonicMelody events to set melody to.
start_step: The integer starting step offset.
steps_per_bar: The number of steps in a bar.
steps_per_quarter: The number of steps in a quarter note.
Raises:
ValueError: If `events` contains an event that is not in the proper range.
"""
for event in events:
if not MIN_MELODY_EVENT <= event <= MAX_MELODY_EVENT:
raise ValueError('Melody event out of range: %d' % event)
super(MonophonicMelody, self).from_event_list(
events, start_step=start_step, steps_per_bar=steps_per_bar,
steps_per_quarter=steps_per_quarter)
def to_sequence(self,
velocity=100,
instrument=0,
sequence_start_time=0.0,
qpm=120.0):
"""Converts the MonophonicMelody to NoteSequence proto.
The end of the melody is treated as a NOTE_OFF event for any sustained
notes.
Args:
velocity: Midi velocity to give each note. Between 1 and 127 (inclusive).
instrument: Midi instrument to give each note.
sequence_start_time: A time in seconds (float) that the first note in the
sequence will land on.
qpm: Quarter notes per minute (float).
Returns:
A NoteSequence proto encoding the given melody.
"""
seconds_per_step = 60.0 / qpm / self.steps_per_quarter
sequence = music_pb2.NoteSequence()
sequence.tempos.add().qpm = qpm
sequence.ticks_per_quarter = STANDARD_PPQ
sequence_start_time += self.start_step * seconds_per_step
current_sequence_note = None
for step, note in enumerate(self):
if MIN_MIDI_PITCH <= note <= MAX_MIDI_PITCH:
# End any sustained notes.
if current_sequence_note is not None:
current_sequence_note.end_time = (
step * seconds_per_step + sequence_start_time)
# Add a note.
current_sequence_note = sequence.notes.add()
current_sequence_note.start_time = (
step * seconds_per_step + sequence_start_time)
current_sequence_note.pitch = note
current_sequence_note.velocity = velocity
current_sequence_note.instrument = instrument
elif note == MELODY_NOTE_OFF:
# End any sustained notes.
if current_sequence_note is not None:
current_sequence_note.end_time = (
step * seconds_per_step + sequence_start_time)
current_sequence_note = None
# End any sustained notes.
if current_sequence_note is not None:
current_sequence_note.end_time = (
len(self) * seconds_per_step + sequence_start_time)
if sequence.notes:
sequence.total_time = sequence.notes[-1].end_time
return sequence
def transpose(self, transpose_amount, min_note=0, max_note=128):
"""Transpose notes in this MonophonicMelody.
All notes are transposed the specified amount. Additionally, all notes
are octave shifted to lie within the [min_note, max_note) range.
Args:
transpose_amount: The number of half steps to transpose this
MonophonicMelody. Positive values transpose up. Negative values
transpose down.
min_note: Minimum pitch (inclusive) that the resulting notes will take on.
max_note: Maximum pitch (exclusive) that the resulting notes will take on.
"""
for i in range(len(self)):
# Transpose MIDI pitches. Special events below MIN_MIDI_PITCH are not
# changed.
if self._events[i] >= MIN_MIDI_PITCH:
self._events[i] += transpose_amount
if self._events[i] < min_note:
self._events[i] = (
min_note + (self._events[i] - min_note) % NOTES_PER_OCTAVE)
elif self._events[i] >= max_note:
self._events[i] = (max_note - NOTES_PER_OCTAVE +
(self._events[i] - max_note) % NOTES_PER_OCTAVE)
def squash(self, min_note, max_note, transpose_to_key):
"""Transpose and octave shift the notes in this MonophonicMelody.
The key center of this melody is computed with a heuristic, and the notes
are transposed to be in the given key. The melody is also octave shifted
to be centered in the given range. Additionally, all notes are octave
shifted to lie within a given range.
Args:
min_note: Minimum pitch (inclusive) that the resulting notes will take on.
max_note: Maximum pitch (exclusive) that the resulting notes will take on.
transpose_to_key: The melody is transposed to be in this key. 0 = C Major.
Returns:
How much notes are transposed by.
"""
melody_key = self.get_major_key()
key_diff = transpose_to_key - melody_key
midi_notes = [note for note in self._events
if MIN_MIDI_PITCH <= note <= MAX_MIDI_PITCH]
if not midi_notes:
return 0
melody_min_note = min(midi_notes)
melody_max_note = max(midi_notes)
melody_center = (melody_min_note + melody_max_note) / 2
target_center = (min_note + max_note - 1) / 2
center_diff = target_center - (melody_center + key_diff)
transpose_amount = (
key_diff +
NOTES_PER_OCTAVE * int(round(center_diff / float(NOTES_PER_OCTAVE))))
self.transpose(transpose_amount, min_note, max_note)
return transpose_amount
def set_length(self, steps, from_left=False):
"""Sets the length of the melody to the specified number of steps.
If the melody is not long enough, ends any sustained notes and adds NO_EVENT
steps for padding. If it is too long, it will be truncated to the requested
length.
Args:
steps: How many steps long the melody should be.
from_left: Whether to add/remove from the left instead of right.
"""
old_len = len(self)
super(MonophonicMelody, self).set_length(steps, from_left=from_left)
if steps > old_len and not from_left:
# When extending the melody on the right, we end any sustained notes.
for i in reversed(range(old_len)):
if self._events[i] == MELODY_NOTE_OFF:
break
elif self._events[i] != MELODY_NO_EVENT:
self._events[old_len] = MELODY_NOTE_OFF
break
def extract_melodies(quantized_sequence,
min_bars=7,
max_steps_truncate=None,
max_steps_discard=None,
gap_bars=1.0,
min_unique_pitches=5,
ignore_polyphonic_notes=True,
pad_end=False):
"""Extracts a list of melodies from the given QuantizedSequence object.
This function will search through `quantized_sequence` for monophonic
melodies in every track at every time step.
Once a note-on event in a track is encountered, a melody begins.
Gaps of silence in each track will be splitting points that divide the
track into separate melodies. The minimum size of these gaps are given
in `gap_bars`. The size of a bar (measure) of music in time steps is
computed from the time signature stored in `quantized_sequence`.
The melody is then checked for validity. The melody is only used if it is
at least `min_bars` bars long, and has at least `min_unique_pitches` unique
notes (preventing melodies that only repeat a few notes, such as those found
in some accompaniment tracks, from being used).
After scanning each instrument track in the QuantizedSequence, a list of all
extracted MonophonicMelody objects is returned.
Args:
quantized_sequence: A sequences_lib.QuantizedSequence object.
min_bars: Minimum length of melodies in number of bars. Shorter melodies are
discarded.
max_steps_truncate: Maximum number of steps in extracted melodies. If
defined, longer melodies are truncated to this threshold. If pad_end is
also True, melodies will be truncated to the end of the last bar below
this threshold.
max_steps_discard: Maximum number of steps in extracted melodies. If
defined, longer melodies are discarded.
gap_bars: A melody comes to an end when this number of bars (measures) of
silence is encountered.
min_unique_pitches: Minimum number of unique notes with octave equivalence.
Melodies with too few unique notes are discarded.
ignore_polyphonic_notes: If True, melodies will be extracted from
`quantized_sequence` tracks that contain polyphony (notes start at
the same time). If False, tracks with polyphony will be ignored.
pad_end: If True, the end of the melody will be padded with NO_EVENTs so
that it will end at a bar boundary.
Returns:
melodies: A python list of MonophonicMelody instances.
stats: A dictionary mapping string names to `statistics.Statistic` objects.
Raises:
NonIntegerStepsPerBarException: If `quantized_sequence`'s bar length
(derived from its time signature) is not an integer number of time
steps.
"""
# TODO(danabo): Convert `ignore_polyphonic_notes` into a float which controls
# the degree of polyphony that is acceptable.
melodies = []
stats = dict([(stat_name, statistics.Counter(stat_name)) for stat_name in
['polyphonic_tracks_discarded',
'melodies_discarded_too_short',
'melodies_discarded_too_few_pitches',
'melodies_discarded_too_long',
'melodies_truncated']])
# Create a histogram measuring melody lengths (in bars not steps).
# Capture melodies that are very small, in the range of the filter lower
# bound `min_bars`, and large. The bucket intervals grow approximately
# exponentially.
stats['melody_lengths_in_bars'] = statistics.Histogram(
'melody_lengths_in_bars',
[0, 1, 10, 20, 30, 40, 50, 100, 200, 500, min_bars // 2, min_bars,
min_bars + 1, min_bars - 1])
for track in quantized_sequence.tracks:
start = 0
# Quantize the track into a MonophonicMelody object.
# If any notes start at the same time, only one is kept.
while 1:
melody = MonophonicMelody()
try:
melody.from_quantized_sequence(
quantized_sequence,
track=track,
start_step=start,
gap_bars=gap_bars,
ignore_polyphonic_notes=ignore_polyphonic_notes,
pad_end=pad_end)
except PolyphonicMelodyException:
stats['polyphonic_tracks_discarded'].increment()
break # Look for monophonic melodies in other tracks.
except events_lib.NonIntegerStepsPerBarException:
raise
start = melody.end_step
if not melody:
break
# Require a certain melody length.
stats['melody_lengths_in_bars'].increment(
len(melody) // melody.steps_per_bar)
if len(melody) - 1 < melody.steps_per_bar * min_bars:
stats['melodies_discarded_too_short'].increment()
continue
# Discard melodies that are too long.
if max_steps_discard is not None and len(melody) > max_steps_discard:
stats['melodies_discarded_too_long'].increment()
continue
# Truncate melodies that are too long.
if max_steps_truncate is not None and len(melody) > max_steps_truncate:
truncated_length = max_steps_truncate
if pad_end:
truncated_length -= max_steps_truncate % melody.steps_per_bar
melody.set_length(truncated_length)
stats['melodies_truncated'].increment()
# Require a certain number of unique pitches.
note_histogram = melody.get_note_histogram()
unique_pitches = np.count_nonzero(note_histogram)
if unique_pitches < min_unique_pitches:
stats['melodies_discarded_too_few_pitches'].increment()
continue
# TODO(danabo)
# Add filter for rhythmic diversity.
melodies.append(melody)
return melodies, stats.values()
class MelodyEncoderDecoder(events_lib.EventsEncoderDecoder):
"""An abstract class for translating between melodies and model data.
When building your dataset, the `encode` method takes in a melody and
returns a SequenceExample of inputs and labels. These SequenceExamples are
fed into the model during training and evaluation.
During melody generation, the `get_inputs_batch` method takes in a list of
the current melodies and returns an inputs batch which is fed into the
model to predict what the next note should be for each melody.
The `extend_event_sequences` method takes in the list of melodies and the
softmax returned by the model and extends each melody by one step by sampling
from the softmax probabilities. This loop (`get_inputs_batch` -> inputs batch
is fed through the model to get a softmax -> `extend_event_sequences`) is
repeated until the generated melodies have reached the desired length.
Attributes:
min_note: The minimum midi pitch the encoded melodies can have.
max_note: The maximum midi pitch (exclusive) the encoded melodies can have.
transpose_to_key: The key that encoded melodies will be transposed into.
Properties:
input_size: The length of the list returned by self.melody_to_input.
num_classes: The range of ints that can be returned by
self.melody_to_label.
"""
__metaclass__ = abc.ABCMeta
def __init__(self, min_note=48, max_note=84, transpose_to_key=0):
"""Initializes a MelodyEncoderDecoder object.
You can change `min_note` and `max_note` to increase/decrease the melody
range. Since melodies are transposed into this range to be run through
the model and then transposed back into their original range after the
melodies have been extended, the location of the range is somewhat
arbitrary, but the size of the range determines the possible size of the
generated melodies range. `transpose_to_key` should be set to the key
that if melodies were transposed into that key, they would best sit
between `min_note` and `max_note` with having as few notes outside that
range. The same `min_note`, `max_note`, and `transpose_to_key` values
should be used when creating your dataset, training your model,
and generating melodies from it. If you change `min_note`, `max_note`,
or `transpose_to_key`, you will have to recreate your dataset and retrain
your model before you can accurately generate melodies from it.
Args:
min_note: The minimum midi pitch the encoded melodies can have.
max_note: The maximum midi pitch (exclusive) the encoded melodies can
have.
transpose_to_key: The key that encoded melodies will be transposed into.
Raises:
ValueError: If `min_note` or `max_note` are outside the midi range, or
if the [`min_note`, `max_note`) range is less than an octave. A range
of at least an octave is required to be able to octave shift notes
into that range while preserving their scale value.
"""
if min_note < MIN_MIDI_PITCH:
raise ValueError('min_note must be >= 0. min_note is %d.' % min_note)
if max_note > MAX_MIDI_PITCH + 1:
raise ValueError('max_note must be <= 128. max_note is %d.' % max_note)
if max_note - min_note < NOTES_PER_OCTAVE:
raise ValueError('max_note - min_note must be >= 12. min_note is %d. '
'max_note is %d. max_note - min_note is %d.' %
(min_note, max_note, max_note - min_note))
if transpose_to_key < 0 or transpose_to_key > NOTES_PER_OCTAVE - 1:
raise ValueError('transpose_to_key must be >= 0 and <= 11. '
'transpose_to_key is %d.' % transpose_to_key)
self._min_note = min_note
self._max_note = max_note
self._transpose_to_key = transpose_to_key
@property
def min_note(self):
"""The minimum midi pitch the encoded melodies can have.
Returns:
An integer, the minimum midi pitch the encoded melodies can have.
"""
return self._min_note
@property
def max_note(self):
"""The maximum midi pitch (exclusive) the encoded melodies can have.
Returns:
An integer, the maximum midi pitch (exclusive) the encoded melodies can
have.
"""
return self._max_note
@property
def transpose_to_key(self):
"""The key that encoded melodies will be transposed into.
Returns:
An integer in the range [0, 12), the key that encoded melodies will be
transposed into.
"""
return self._transpose_to_key
@property
def no_event_label(self):
"""The class label that represents a NO_EVENT MonophonicMelody event.
Returns:
An int, the class label that represents a NO_EVENT.
"""
melody = MonophonicMelody()
melody.from_event_list([MELODY_NO_EVENT])
return self.events_to_label(melody, 0)
@abc.abstractmethod
def events_to_input(self, events, position):
"""Returns the input vector for the melody event at the given position.
Args:
events: A MonophonicMelody object.
position: An integer event position in the melody.
Returns:
An input vector, a self.input_size length list of floats.
"""
pass
@abc.abstractmethod
def events_to_label(self, events, position):
"""Returns the label for the melody event at the given position.
Args:
events: A MonophonicMelody object.
position: An integer event position in the melody.
Returns:
A label, an integer in the range [0, self.num_classes).
"""
pass
@abc.abstractmethod
def class_index_to_event(self, class_index, events):
"""Returns the melody event for the given class index.
This is the reverse process of the self.events_to_label method.
Args:
class_index: An integer in the range [0, self.num_classes).
events: A MonophonicMelody object.
Returns:
An integer melody event value.
"""
pass
def squash_and_encode(self, melody):
"""Returns a SequenceExample for the given melody after squashing.
Args:
melody: A MonophonicMelody object.
Returns:
A tf.train.SequenceExample containing inputs and labels.
"""
melody.squash(self._min_note, self._max_note, self._transpose_to_key)
return self._encode(melody)
class OneHotEncoderDecoder(MelodyEncoderDecoder):
"""A MelodyEncoderDecoder that produces a one-hot encoding for the input."""
def __init__(self, min_note, max_note, transpose_to_key):
super(OneHotEncoderDecoder, self).__init__(min_note, max_note,
transpose_to_key)
self._input_size = (self.max_note - self.min_note +
NUM_SPECIAL_MELODY_EVENTS)
self._num_classes = (self.max_note - self.min_note +
NUM_SPECIAL_MELODY_EVENTS)
@property
def input_size(self):
return self._input_size
@property
def num_classes(self):
return self._num_classes
def events_to_input(self, events, position):
input_ = [0.0] * self._input_size
index = (events[position] + NUM_SPECIAL_MELODY_EVENTS
if events[position] < 0
else events[position] - self.min_note + NUM_SPECIAL_MELODY_EVENTS)
input_[index] = 1.0
return input_
def events_to_label(self, events, position):
return (events[position] + NUM_SPECIAL_MELODY_EVENTS
if events[position] < 0
else events[position] - self.min_note + NUM_SPECIAL_MELODY_EVENTS)
def class_index_to_event(self, class_index, events):
return (class_index - NUM_SPECIAL_MELODY_EVENTS
if class_index < NUM_SPECIAL_MELODY_EVENTS
else class_index + self.min_note - NUM_SPECIAL_MELODY_EVENTS)