Pattern_Eval

Mix.install([
  {:music_prims, github: "bwanab/music_prims"},
  {:midifile, github: "bwanab/elixir-midifile", force: true},
  {:music_build, github: "bwanab/music_build"},
  {:better_weighted_random, "~> 0.1.0"}
])

Introduction

mThe point of this notebook is to investigate the creation of a bass playing algorithm. That’s a tall order so we’re going to constrain ourselves to blues for now. Simple 12 bar blues where the bass is just playing 8 note runs per measure. The approach will be to get a representative sample and analyze the notes played to obtain an algorithm to emulate that.

Create a probability table from the sample.

In this section, we’ll be using a midi file that contains 8 rounds of 12-bar blues bass played by me. Honestly, I’m not a great bass player, but having been pressed into service a number of times in my musical career, I’m not awful. Since I’m not a keyboard player, I played the bass on my analog electric bass into an audio file, then in the DAW (Reaper, in this case), using the Reatune plugin, I converted the audio to midi. After a bit of clean up and quantization I got a very constrained file. Constrained in the sense that it is 12 bar blues where each bar consists of exactly 8 eighth notes. This is a strict :I, :IV, :I, :I, :IV, :IV, :I, :I, :V, :IV, :I, :V, blues pattern.

What we’re going to do here is spilt this into the 8 12-bar lines, then further split these into a map of notes based on the chord degree. That is [:I, :IV, :V] are the keys and the notes are given as groups of 8. We’ll then count the frequency with which notes in each position for a given chord are seen and compute the probabilities of those chord/position pairs. Given that we ought to be able to reproduce a ‘decent’ bassline by computing the probability weighted note to play in every position.

We’ll see how that sounds then move on to two other approaches:

1. Next note probability based on the last note and possibly the guessed next note.
2. Connecting note that computes the last note for a given chord based on the next chord to come.

alias MusicBuild.Examples.PatternEvaluator
import MapEvents

First, we’ll read the midi file with our bass lines and split them into individual lines. We’re defining a ‘line’ as one 12-bar segment.

NOTE: The file pointed to by test_dir is needed It can be obtained here: https://github.com/bwanab/music_build/test/quantized_blues_bass.mid. Then edit the code to change the test_dir path to point to it.

test_dir = Path.expand("~/src/music_build/test")
seq = Midifile.read(Path.join(test_dir, "quantized_blues_bass.mid"))
channel_tracks = MapEvents.one_track_to_sonorities(seq, 0)
sonorities = channel_tracks[0].sonorities
chunks = Enum.chunk_every(sonorities, 12*8)

Now, we use the 12-bar chord pattern to break down the lines into chord groupings. That is, we are gathering all the notes as they were played for each of the 3 chords in the progression in the order that they were played. This means in each of the individual lists, we’ve got 8 notes that are the notes played in their respective positions of each run. This grouping allows us to understand the most likely note to be played in each note position. My prior belief is that the first note is most likely to be the root of the chord and the note is a ‘connecting’ note from one chord to the next. I have no prior about positions 2-7 (one based).

pattern = [:I, :IV, :I, :I, :IV, :IV, :I, :I, :V, :IV, :I, :V]
mapped = Enum.map(chunks, fn line -> PatternEvaluator.chunk_line(line, 8, pattern) end)
             |> PatternEvaluator.merge_maps_with_lists()

root_map = Map.new(Enum.map(Map.keys(mapped), fn k -> 
  note = Chord.note_from_roman_numeral(k, :A, 2, :major)
  {k, [note, MidiNote.to_midi(note)]} 
end))

Now, we compute the intervals of the notes from the chord roots.

interval_map = Map.new(Enum.map(mapped, fn {k, v} -> 
  [_n, root_note_number] = Map.get(root_map, k)
  {k, Enum.map(v, fn note_list ->
    Enum.map(note_list, fn note ->
      note_number = MidiNote.to_midi(note)
      note_number - root_note_number
    end)
  end)}
  end)
)

Here, we get the raw numerical frequency of each note at each position. Eyeballing the numbers, it looks obvious that the first note is overwhelmingly the root of the chord. The 2nd note is mostly the 4th

raw_frequency_table = Map.new(Enum.map(interval_map, fn {k, im} ->
  {k, Enum.map(0..7, fn i ->
    Enum.reduce(im, %{}, fn row, acc -> 
      value = Enum.at(row, i)
      Map.put(acc, value, Map.get(acc, value, 0) + 1) end)
    end)}
  end)
)

Let’s convert the frequency table to probabilities.

probabilities_table = Map.new(Enum.map(raw_frequency_table, fn {k, im} ->
    {k, Map.new(Enum.map(Enum.with_index(im), fn {row, ind} -> 
      row_count = Enum.sum(Map.values(row))
      {ind, Enum.map(row, fn {interval, count} -> 
        {interval, count / row_count}
        end)}
      end))}
  end)
)

Now, given the probabilities table we can find the most likely interval given the root chord and the note position:

new_interval = WeightedRandom.take_one(get_in(probabilities_table, [:I, 1]))

[%Note{duration: duration, velocity: velocity}, root_number] = Map.get(root_map, :I)
MidiNote.midi_to_note(root_number + new_interval, duration, velocity)

Let’s see what we can do:

base_lines = Enum.flat_map(0..7, fn _ ->
Enum.flat_map(pattern, fn rn -> 
  Enum.map(0..7, fn i ->
    [_, root_number] = Map.get(root_map, rn)
    interval = WeightedRandom.take_one(get_in(probabilities_table, [rn, i]))
    MidiNote.midi_to_note(root_number + interval, 0.5, 127)
  end)
  end)
end)

pattern

NOTE: this cell is generating a file in local storage pointed at by test_dir. Ensure this is a writable location and where it is wanted.

MusicBuild.Examples.CleanUpMidiFile.write_midi_file([base_lines], 
  Path.join(test_dir, "generated_blues_bass.mid"))

Now, you can load the generated midi file into a midi player and ideally specify that it is being played as a bass instrument (even though it doesn’t really matter).

Build the pattern/position probabilities table

Next steps

Interesting. I loaded this midi file into the same project that the original bass line had come from. It didn’t sound awful - kind of like the bass player equivalent of Ginger Baker playing drums for Cream - it works, but it’s really weird. There are two more angles I want to attack this problem with. Let’s take stock:

1. The approach so far which is figuring out for the given pattern and note position a note that represents the probability weighted best note based on frequencies for that pattern and position.
2. Modify the previous with a notion of most likely next note given the position. This could also be a bit of lookahead to determine the most likely next note and make it an internal pattern connecting note as opposed to 3 below.
3. Determine the best ‘connecting’ note. That is, the note that is the last note in a given pattern. This would involve looking behind to the last note played and looking ahead to the next note to be played to determine what should come in between.

Identify pattern frequencies and work with those.

all_patterns = Enum.flat_map(interval_map, fn {_k, v} -> v end)

uniq_patterns = Enum.uniq(all_patterns)

pattern_freqs = Enum.map(Enum.group_by(all_patterns, fn x -> x end), fn {pattern, group} ->
  {pattern, length(group)}
  end) |> Enum.sort(fn {_g1, p1},{_g2, p2} -> p1 > p2 end)

{pat, _} = Enum.at(pattern_freqs, 0)

Enum.shuffle(pat)

So, here all we’re doing is taking one measure’s pattern, in this case the most repeated one, and shuffling it for each new chord. Strangely enough, it actually doesn’t sound bad.

notes = Enum.flat_map(pattern, fn rn ->
  [_, root_number] = Map.get(root_map, rn)
  Enum.map(Enum.shuffle(pat), fn interval ->
    MidiNote.midi_to_note(root_number + interval, 0.5, 127)    
  end)
end)

MusicBuild.Examples.CleanUpMidiFile.write_midi_file([notes], 
  Path.join(test_dir, "generated_test_bass.mid"))

Next, we’ll take the random weighted pattern and shuffle it for each measure.

defmodule TestPat do

  def do_one_pattern(pat, roman_numeral, root_map) do
      [_, root_number] = Map.get(root_map, roman_numeral)
      Enum.map(Enum.shuffle(pat), fn interval ->
        MidiNote.midi_to_note(root_number + interval, 0.5, 127)    
      end)
  end

  @doc """
  inputs: pattern is a group of roman numerals like [:I, :IV, :ii, ...]
          pattern_freqs is a frequency table of the bass lines from the sample midi file
          root_map is a map of the notes associated with the pattern roman numerals
  """
  def do_pattern(pattern, pattern_freqs, root_map) do
    Enum.flat_map(pattern, fn roman_numeral -> 
      do_one_pattern(WeightedRandom.take_one(pattern_freqs), roman_numeral, root_map)  
    end)
  end
end

TestPat.do_one_pattern(pat, :I, root_map)

r_notes = TestPat.do_pattern(pattern, pattern_freqs, root_map)

MusicBuild.Examples.CleanUpMidiFile.write_midi_file([r_notes], 
  Path.join(test_dir, "generated_randomized_test_bass.mid"))

Well, this kind of sounds like one would imagine a bad random bass player who knew how to stay in key would sound - not too good.

Explore next note

all_intervals = Enum.flat_map(interval_map, fn {_k, v} -> List.flatten(v) end)

prev_next = Enum.map(Enum.chunk_every(all_intervals, 3, 1), fn l ->
  cond do
    length(l) == 3 -> 
      [prev, val, next] = l
      {{prev, next}, val}
    true -> 
      IO.inspect(l)
      [prev, val] = l
      {{prev, 0}, val}
  end
  
  end)

prev_next_map = Map.new(Enum.reduce(prev_next, %{}, fn {k, v}, acc ->
  Map.put(acc, k, [v|Map.get(acc, k, [])])
end)
|> Enum.map(fn {k, v} -> 
  {k, Enum.reduce(v, %{}, fn value, acc ->
    Map.put(acc, value, Map.get(acc, value, 0) + 1) end)}
  end))

pattern

base_lines_2 = Enum.flat_map(0..7, fn _ ->
Enum.flat_map(pattern, fn rn -> 
  Enum.map(0..7, fn pos ->
    [_, root_number] = Map.get(root_map, rn)
    prev = WeightedRandom.take_one(get_in(probabilities_table, [rn, Integer.mod(pos - 1, 8)]))
    next = WeightedRandom.take_one(get_in(probabilities_table, [rn, Integer.mod(pos + 1, 8)]))
    # default to the root if no prev/next pair is found
    interval = WeightedRandom.take_one(Map.get(prev_next_map, {prev, next}, %{0 => 1}))
    MidiNote.midi_to_note(root_number + interval, 0.5, 127)
  end)
  end)
end)

MusicBuild.Examples.CleanUpMidiFile.write_midi_file([base_lines_2], 
  Path.join(test_dir, "generated_prev_next_blues_bass.mid"))

That isn’t bad at all. We’ve got a winner if I don’t think of anything else.