I’ve been working on the algorithmic aspect of this music making enterprise for a while. What I’m doing is not strictly Deep Learning, and not just algorithmic music either. It’s more of a hybrid of the two. In this case, I took one of the 16 voice chorales made with the coconet deep learning model, and then serially modifying each of the four component chorales through a set of algorithms, sort of like the layers in a deep learning model, but really more of simple modifications based on information about the notes. I start out by evaluating all the simultaneous notes to find those that are not in the scale that the chorale is in. These are lengthened up to 5 times their original length. At a later step those steps get a gradual crescendo applied to them. Steps that only use the notes in the key, G minor, get a decrescendo. I arpeggiate it in another step. I then double the voices from 4 to eight. Finally it is sent through a function that shifts the octaves of some notes up. I’ve set that up so that I can specify the percent of notes to have their octaves increase, and then clump that percent of notes into strings of 33 and 45 notes at a time. The effect is sort of shimmering, as some of the notes are higher, but then they are also played at their normal octave at the same time. That’s a filter that I created today.

Here’s the python code for those interested in that sort of thing.

file_stub = 'chorale_HP80063.npy' # one of about a hundred artificial chorales that the model created

dirname = 'wake_up_chorales' # the original chorale is called Wake Up, Wake Up, You Sleepers by J.S. Bach.

chorale = np.load(os.path.join(dirname,file_stub)) + 30

chorale = s.expand_and_concatenate(chorale, expand_codes)

chorale = s.transpose_up_segment(chorale,root) # restore the original key of G minor

```
```masks = np.array([[16,18,2,6,3],[16,18,4,4,2],[16,20,1,4,3],[16,20,2,2,2]]) # arpeggiation mask

concat_chorale = np.empty((4,0),dtype=int)

concat_challenging_steps = np.empty((0,4),dtype=int)

previous_size = 0

for i in range(4): # for each of the four chorales stacked in a 16 voice array, take them one at a time.

sub_chorale = chorale[i*4:(i+1)*4,:]

scores = s.assign_scores_to_time_steps(sub_chorale, root, mode)

range_of_steps = s.find_challenging_time_steps(scores, sub_chorale)

range_in_tune = s.find_in_tune_time_steps(sub_chorale, range_of_steps)

sub_chorale, challenging_steps, in_tune_steps = \

s.expand_challenging_time_steps(sub_chorale, range_of_steps, range_in_tune, high = 6)

sub_chorale = s.arpeggiate(sub_chorale,s.shaded_mask((masks[i,0],masks[i,1]),masks[i,2],masks[i,3]),masks[i,4])

concat_chorale = np.concatenate((concat_chorale, sub_chorale),axis = 1) # add this chorale to the chain of chorales

challenging_steps += previous_size

previous_size += sub_chorale.shape[1]

concat_challenging_steps = np.concatenate((concat_challenging_steps,challenging_steps),axis=0)

`chorale = np.concatenate((concat_chorale,concat_chorale),axis = 0) # double the voices from 4 to 8.`

# 15% of the time increase the octave of a note, clump the changes in groups of 33 and 45

chorale = s.octave_shift(s.octave_shift(chorale, 0.15, 45), 0.15, 33)