pycomposer 0.0.2

Description

pycomposer is Python library for Algorithmic Composition or Automatic Composition by Reinforcement Learning such as Q-Learning and Recurrent Temporal Restricted Boltzmann Machine(RTRBM). Q-Learning and RTRBM in this library allows you to extract the melody information about a MIDI tracks and these models can learn and inference patterns of the melody. And This library has wrapper class for converting melody data inferenced by Q-Learning and RTRBM into MIDI file.

Documentation

Full documentation is available on https://code.accel-brain.com/Algorithmic-Composition/ . This document contains information on functionally reusability, functional scalability and functional extensibility.

Installation

Install using pip:

pip install pycomposer

Demonstration

Import Python modules.

import numpy as np
from pycomposer.composition_controler import CompositionControler
from pycomposer.inferablepitch.rtrbm_inferer import RTRBMInferer
from pycomposer.midi_vectorlizer import MidiVectorlizer

Extract and convert MIDI file into pd.DataFrame.

midi_vectorlizer = MidiVectorlizer()
tone_df = midi_vectorlizer.extract("path/to/your/midi/file.mid")

Instantiate Q-Learning and setup hyper-parameters. r_dict is the dict of reward values. The key of r_dict is to the value what the frequency ratio is to Q-Value.

# Reward value.
r_dict = {
    (1, 1): 5.0,
    (15, 16): 0.0,
    (8, 9): 0.0,
    (5, 6): 0.5,
    (4, 5): 0.5,
    (2, 1): 5.0,
    (32, 45): 0.0,
    (2, 3): 5.0,
    (5, 8): 0.5,
    (3, 5): 0.5,
    (9, 16): 0.0,
    (8, 15): 0.0,
    (1, 2): 5.0
}

# The object of Q-Learning.
inferable_consonance = QConsonance()
# ε-Greedy rate.
inferable_consonance.epsilon_greedy_rate = 0.9
# Alpha value.
inferable_consonance.alpha_value = 0.6
# Gamma value.
inferable_consonance.gamma_value = 0.7
# Initialize.
inferable_consonance.initialize(r_dict=r_dict, tone_df=tone_df)
# Searching and learning.
for pitch in tone_df.pitch.values.tolist():
    # The parameter of `limit` is Number of learning.
    inferable_consonance.learn(state_key=pitch, limit=200)

Instantiate RTRBM and setup hyper-parameters.

inferable_pitch = RTRBMInferer(
    learning_rate=0.00001,         # Learning rate.
    hidden_n=100,                  # The number of units in hidden layer.
    hidden_binary_flag=True,       # The activation is binary or not.
    inferancing_training_count=1,  # Training count in inferancing.
    r_batch_size=200               # The batch size in inferancing.
)
inferable_pitch.learn(
    tone_df=tone_df,               # Learned data.
    training_count=1,              # Training count in learning.
    batch_size=200                 # The batch size in learning.
)

Instantiate CompositionControler as follow.

# The conctorler of `inferable_consonance` and `inferable_pitch`
composition_controler = CompositionControler(
    resolution=960,
    initial_tempo=120
)

Create chord progression. The parameter of octave is octave (-1 - 9). The options of first_chord are I, II, III, IV, V, VI, and VII. total_measure_n is the length of measure.

chord_list = composition_controler.create_chord_list(
    octave=5,
    first_chord="IV",
    total_measure_n=40
)

Compose chord progression.

composition_controler.compose_chord(
    chord_list,                      # The list of `np.ndarray` that contains the string of Diatonic code.
    metronome_time=100,              # Metronome time.
    start_measure_n=0,               # The timing of the beginning of the measure.
    measure_n=8,                     # The number of measures.
    beat_n=8,                        # The number of beats.
    chord_instrument_num=34,         # MIDI program number (instrument index), in [0, 127].
    chord_velocity_range=(90, 95)    # The tuple of chord velocity in MIDI.
)

And compose melody.

composition_controler.compose_melody(
    inferable_pitch,
    inferable_consonance,
    chord_list,
    total_measure_n=40,
    measure_n=8,
    start_measure_n=0,
    beat_n=8,
    metronome_time=100,
    melody_instrument_num=0,            # MIDI program number (instrument index), in [0, 127].
    melody_velocity_range=(120, 127)    # The tuple of melody velocity in MIDI.
)

The form of tuple chord_velocity_range and melody_velocity_range is (low velocity, high veloicty). The value of velocity is determined by np.random.randint.

Finally, convert these inferenced data into MIDI file.

composition_controler.save("your/composed/midi/file.mid")

Author

• chimera0(RUM)

Author URI

• http://accel-brain.com/

License

• GNU General Public License v2.0