Как я научил искусственный интеллект создавать барабанные партии

Я увлекаюсь музыкой и программированием, и решил объединить свои два хобби. У меня возникла идея создать нейронную сеть, способную генерировать барабанные партии в формате MIDI. Это могло бы значительно упростить процесс сочинения музыки. Позвольте рассказать, что я смог создать.

1. Подготовка данных и обучение модели

Для начала, я использовал MIDI-файлы с барабанными партиями в качестве данных. Их можно скачать тут. Вместо работы с отдельными нотами, я сфокусировался на паттернах — готовых ритмических рисунках, которые могут повторяться.

Чтобы работать с MIDI-файлами, я использовал библиотеку mido.

И так начнем!

1. Получаем ноты с velocity(сила удара по барабану) и time(длительность), это важно, потому что барабанная партия должна напоминать игру живого человека.

def get_notes_from_midi(filename):     notes = []     midi = MidiFile(filename)      for track in midi.tracks:         for message in track:             if message.type == 'note_on' or message.type == 'note_off':                 type = message.type                 note = message.note                 velocity = message.velocity                 time = message.time                 notes.append((type, note, velocity, time))      return notes

2. Создаем уникальный словарь паттернов.

def create_unique_id_dict(dataset):     note_dict = {}     unique_set = []     sequence_id = 0     time = 0      for i in range(len(dataset)-1):         item = dataset[i]         time += item[3]          unique_set.append(item)          if time >= 1900:             sequence_id += 1             note_dict[sequence_id] = unique_set             unique_set = []             time = 0             continue      return note_dict  def reindex_dict(note_dict):     unique_dict = {}     i = 1     for key, value in note_dict.items():         if value not in unique_dict.values():             unique_dict[i] = value             i += 1     return unique_dict 

3. Далее надо заменить наши ноты на индексы из словаря.

def replace_notes_with_ids(notes, note_dict):     id_notes = []     for note in notes:         for key, value in note_dict.items():             if note in value:                 id_notes.append(key)                 break     return id_notes

4. Создаем еще одни словарь из того что получилось.

def create_dict(notes):     unique_notes = list(set(notes))     return {note: index for index, note in enumerate(unique_notes)}

5. Теперь подготавливаем данные для нейронной сети.

def prepare_sequences(notes, note_dict):     sequence_length = 64     sequence_input = []     sequence_output = []      # Создание словаря индексов для нот     index_dict = {note: index for index, note in enumerate(note_dict)}      for i in range(len(notes) - sequence_length):         sequence_in = notes[i: i + sequence_length]         sequence_out = notes[i + sequence_length]          sequence_input.append([index_dict[note] for note in sequence_in])          if sequence_out in index_dict:             sequence_output.append(index_dict[sequence_out])      x = np.reshape(sequence_input, (len(sequence_input), sequence_length, 1))     y = to_categorical(sequence_output, num_classes=len(note_dict))      return x, y

6. Создаем нейронную сеть.

   Для создания и работы с нейросетью я использовал библиотеку keras

def create_network(input_dim, num_features):     model = tf.keras.Sequential()     model.add(layers.LSTM(128, input_shape=(None, input_dim)))     model.add(layers.Dense(64, activation='relu'))     model.add(layers.Dense(64, activation='relu'))     model.add(layers.Dense(num_features, activation='sigmoid'))     model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])     return model   def train(model, input_data, output_data, epochs=20, batch_size=64, name='data'):     model.fit(input_data, output_data, epochs=epochs, batch_size=batch_size)     model.save('models/' + name + '.keras')

7. И пробуем ее обучить. Вот весь код целиком.

data_name = 'funk' notes = get_notes_from_midi('data/'+data_name+'.mid') note_dict = reindex_dict(create_unique_id_dict(notes))  digital_note = replace_notes_with_ids(notes, note_dict) digital_dict = create_dict(digital_note)  x,y = prepare_sequences(digital_note, digital_dict)  num_features = len(set(digital_dict)) input_dim = 1   model = create_network(input_dim, num_features) train(model, x, y, epochs=50, batch_size=64, name=data_name)

2. Создание барабанной партии

1. Создадим функцию, которая будет генерировать на основе обученной модели новую барабанную партию.

def gen(count, digital_dict, note_dict, x, data_name):     model = load_model('models/'+data_name+'.keras')     digital_dict = {value: key for key, value in digital_dict.items()}     new_digital_notes = []     new_notes = []      for i in range(count):         prediction_output = predict(model, x)         digital_notes = get_notes(prediction_output, digital_dict)         new_digital_notes.append(digital_notes)       for notes in new_digital_notes:         for id in notes:             new_notes.append(note_dict[id])       print(new_notes)      create_midi_file(new_notes, 'out/'+data_name+'.mid')

2. Далее нам потребуются функция для предсказания ноты и сохранения нот в MIDI формат. А также функция для извлечения ноты из цифрового формата в формат для MIDI.

def predict(model, x):     start = np.random.randint(0, len(x) - 1)     pattern = x[start]     prediction_output = []      for note_index in range(64):         prediction_input = np.reshape(pattern, (1, len(pattern), 1))         prediction = model.predict(prediction_input)         predicted_note = np.argmax(prediction)         prediction_output.append(predicted_note)          pattern = np.append(pattern, predicted_note)         pattern = pattern[1:len(pattern)]      return prediction_output   def get_notes(prediction_output, dict):     notes = []     for id in prediction_output:         notes.append(dict[id])      return notes   def create_midi_file(notes, output_filename, ticks_per_beat=960, tempo=500000):     midi = MidiFile(ticks_per_beat=ticks_per_beat)     track = MidiTrack()     midi.tracks.append(track)     tempo = mido.bpm2tempo(120)      track.append(MetaMessage('set_tempo', tempo=tempo))      for items in notes:         for note in items:             track.append(Message(note[0], note=note[1], velocity=note[2], time=note[3]))      midi.save(output_filename)

3. Пробуем создать новую барабанную партию. Вот весь код.

data_name = 'funk' notes = get_notes_from_midi('data/'+data_name+'.mid') note_dict = reindex_dict(create_unique_id_dict(notes))  digital_note = replace_notes_with_ids(notes, note_dict) digital_dict = create_dict(digital_note)  x, y = prepare_sequences(digital_note, digital_dict)  gen(1, digital_dict, note_dict, x, data_name)

3. Итоги

В общем я реализовал свою идею. Вкратце, она заключается в передаче нейронной сети не нот, а паттернов ритмических рисунков, которые всегда повторяются в музыке. Таким образом, в этих паттернах сохраняется сила ударов по барабану и длительность нот. Это даст на выходе барабанную партию, которая будет звучать, как если бы ее играл живой человек.

Кому интересно, вот проект на гите.

Если хотите посмотреть как он работает в живую, вот ссылка.

P.S. Не судите строго, это мой первый пост. Я с удовольствием жду конструктивной критики в комментариях.