File size: 7,974 Bytes
133ccd4
 
 
96007f4
8453f63
 
 
133ccd4
f24d883
133ccd4
 
 
de46ee3
133ccd4
 
22ee648
 
df03c6b
cef7dc5
e2f25e4
 
725cd35
ce5443a
 
 
 
 
 
 
 
 
 
 
e2f25e4
 
2ae94c0
94c6c13
2ae94c0
 
5d8506a
8453f63
ed77379
8453f63
 
 
 
 
 
5b360d1
6d56961
 
b9dc011
 
4186f2a
b9dc011
ed77379
b9dc011
ed77379
b9dc011
 
 
d34cdb3
b9dc011
ed77379
b9dc011
 
6d56961
 
 
 
8ef0b3c
5d8506a
 
8ef0b3c
4186f2a
 
 
8ef0b3c
8453f63
7622f7a
8453f63
 
7622f7a
2ffbebd
c80330f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a73b76e
 
c80330f
a73b76e
 
 
 
 
 
 
 
 
 
 
 
 
57db528
a73b76e
2ffbebd
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3dd0e68
2ffbebd
f6c94d2
 
96122eb
 
dd0af62
96122eb
 
 
0800621
e9fc459
c5ea46a
2ffbebd
6fd3683
5b68d53
516d23a
 
 
 
 
 
 
 
 
 
 
ef02e98
 
22ee648
 
 
 
 
516d23a
ef02e98
c80330f
8453f63
 
df03c6b
 
 
a8c784b
df03c6b
 
 
3dd0e68
19faf7a
3dd0e68
 
de46ee3
 
23c274d
 
 
 
de46ee3
23c274d
 
de46ee3
59c72b6
 
186f625
 
2ffbebd
186f625
a462022
186f625
ce5443a
186f625
4480160
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
import argparse
import glob
import os.path

import torch
import torch.nn.functional as F

import gradio as gr

import onnxruntime as rt
import tqdm

from midi_synthesizer import synthesis
import TMIDIX

import matplotlib.pyplot as plt

in_space = os.getenv("SYSTEM") == "spaces"
      
#=================================================================================================

@torch.no_grad()
def GenerateMIDI(idrums, iinstr, progress=gr.Progress()):

    if idrums:
        drums = 3074
    else:
        drums = 3073

    instruments_list = ["Piano", "Guitar", "Bass", "Violin", "Cello", "Harp", "Trumpet", "Sax", "Flute", 'Drums', "Choir", "Organ"]
    first_note_instrument_number = instruments_list.index(iinstr)

    start_tokens = [3087, drums, 3075+first_note_instrument_number]

    seq_len = 512
    max_seq_len = 2048
    temperature = 0.9
    verbose=False
    return_prime=False
    

    out = torch.FloatTensor([start_tokens])

    st = len(start_tokens)

    if verbose:
      print("Generating sequence of max length:", seq_len)

    progress(0, desc="Starting...")
    step = 0
    
    for i in progress.tqdm(range(seq_len)):

        try:
            x = out[:, -max_seq_len:]
    
            torch_in = x.tolist()[0]
    
            logits = torch.FloatTensor(session.run(None, {'input': [torch_in]})[0])[:, -1]

            probs = F.softmax(logits / temperature, dim=-1)
    
            sample = torch.multinomial(probs, 1)
    
            out = torch.cat((out, sample), dim=-1)

            if step % 16 == 0:
                print(step, '/', seq_len)

            step += 1
        
            if step >= seq_len:
                break
            
        except Exception as e:
            print('Error', e)
            break

    if return_prime:
      melody_chords_f = out[:, :]
    
    else:
      melody_chords_f = out[:, st:]

    melody_chords_f = melody_chords_f.tolist()[0]
    
    print('=' * 70)
    print('Sample INTs', melody_chords_f[:12])
    print('=' * 70)
    
    if len(melody_chords_f) != 0:
    
        song = melody_chords_f
        song_f = []
        time = 0
        dur = 0
        vel = 0
        pitch = 0
        channel = 0
    
        for ss in song:

            ss1 = int(ss)
    
            if ss1 > 0 and ss1 < 256:
            
              time += ss1 * 8
            
            if ss1 >= 256 and ss1 < 1280:
            
              dur = ((ss1-256) // 8) * 32
              vel = (((ss1-256) % 8)+1) * 15
            
            if ss1 >= 1280 and ss1 < 2816:
              channel = (ss1-1280) // 128
              pitch = (ss1-1280) % 128
            
              song_f.append(['note', int(time), int(dur), int(channel), int(pitch), int(vel) ])
        
    output_signature = 'Allegro Music Transformer'
    output_file_name = 'Allegro-Music-Transformer-Music-Composition'
    track_name='Project Los Angeles'
    list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0]
    number_of_ticks_per_quarter=500
    text_encoding='ISO-8859-1'
    
    output_header = [number_of_ticks_per_quarter, 
            [['track_name', 0, bytes(output_signature, text_encoding)]]]                                                    

    patch_list = [['patch_change', 0, 0, list_of_MIDI_patches[0]], 
                    ['patch_change', 0, 1, list_of_MIDI_patches[1]],
                    ['patch_change', 0, 2, list_of_MIDI_patches[2]],
                    ['patch_change', 0, 3, list_of_MIDI_patches[3]],
                    ['patch_change', 0, 4, list_of_MIDI_patches[4]],
                    ['patch_change', 0, 5, list_of_MIDI_patches[5]],
                    ['patch_change', 0, 6, list_of_MIDI_patches[6]],
                    ['patch_change', 0, 7, list_of_MIDI_patches[7]],
                    ['patch_change', 0, 8, list_of_MIDI_patches[8]],
                    ['patch_change', 0, 9, list_of_MIDI_patches[9]],
                    ['patch_change', 0, 10, list_of_MIDI_patches[10]],
                    ['patch_change', 0, 11, list_of_MIDI_patches[11]],
                    ['patch_change', 0, 12, list_of_MIDI_patches[12]],
                    ['patch_change', 0, 13, list_of_MIDI_patches[13]],
                    ['patch_change', 0, 14, list_of_MIDI_patches[14]],
                    ['patch_change', 0, 15, list_of_MIDI_patches[15]],
                    ['track_name', 0, bytes(track_name, text_encoding)]]

    output = output_header + [patch_list + song_f]

    midi_data = TMIDIX.score2midi(output, text_encoding)
    
    with open(f"Allegro-Music-Transformer-Music-Composition.mid", 'wb') as f:
        f.write(midi_data)

    output1 = []
    itrack = 1
    
    opus =  TMIDIX.score2opus(output)
          
    while itrack < len(opus):
        for event in opus[itrack]:
            if (event[0] == 'note_on') or (event[0] == 'note_off'): 
                output1.append(event)
        itrack += 1
        
    audio = synthesis([500, output1], 'SGM-v2.01-YamahaGrand-Guit-Bass-v2.7.sf2')
    
    x = []
    y =[]
    c = []
    
    colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']
    
    for s in song_f:
      x.append(s[1] / 1000)
      y.append(s[4])
      c.append(colors[s[3]])

    plt.figure(figsize=(14,5))
    ax=plt.axes(title='Allegro Music Transformer')
    ax.set_facecolor('black')
    
    plt.scatter(x,y, c=c)
    plt.xlabel("Time")
    plt.ylabel("Pitch")

    yield [500, output1], plt, "Allegro-Music-Transformer-Music-Composition.mid", (44100, audio)
        
#=================================================================================================

if __name__ == "__main__":

    parser = argparse.ArgumentParser()
    parser.add_argument("--share", action="store_true", default=False, help="share gradio app")
    parser.add_argument("--port", type=int, default=7860, help="gradio server port")
    opt = parser.parse_args()

    print('Loading model...')
    session = rt.InferenceSession('Allegro_Music_Transformer_Small_Trained_Model_56000_steps_0.9399_loss_0.7374_acc.onnx', providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
    print('Done!')
    
    app = gr.Blocks()
    with app:
        gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Allegro Music Transformer</h1>")
        gr.Markdown("![Visitors](https://api.visitorbadge.io/api/visitors?path=asigalov61.Allegro-Music-Transformer&style=flat)\n\n"
                    "Full-attention multi-instrumental music transformer featuring asymmetrical encoding with octo-velocity, and chords counters tokens, optimized for speed and performance\n\n"
                    "Check out [Allegro Music Transformer](https://github.com/asigalov61/Allegro-Music-Transformer) on GitHub!\n\n"
                    "[Open In Colab]"
                    "(https://colab.research.google.com/github/asigalov61/Allegro-Music-Transformer/blob/main/Allegro_Music_Transformer_Composer.ipynb)"
                    " for faster execution and endless generation"
                        )
        input_drums = gr.Checkbox(label="Drums Controls", value = True, info="Drums present or not")
        input_instrument = gr.Radio(["Piano", "Guitar", "Bass", "Violin", "Cello", "Harp", "Trumpet", "Sax", "Flute", "Choir", "Organ"], value="Guitar", label="Lead Instrument Controls", info="Desired lead instrument")       
        run_btn = gr.Button("generate", variant="primary")

        output_midi_seq = gr.Variable()
        output_audio = gr.Audio(label="output audio", format="mp3", elem_id="midi_audio")
        output_plot = gr.Plot(label="output plot")
        output_midi = gr.File(label="output midi", file_types=[".mid"])
        run_event = run_btn.click(GenerateMIDI, [input_drums, input_instrument], [output_midi_seq, output_plot, output_midi, output_audio])
        
        app.queue(concurrency_count=1).launch(server_port=opt.port, share=opt.share, inbrowser=True)