pip install numpy pandas tensorflow keras music21

from music21 import converter, instrument, note, chord, stream

# Чтение MIDI-файлов
midi = converter.parse('path/to/midi/file.mid')

# Отображение партитуры MIDI-файла
midi.show('text')

# Извлечение нот и аккордов
notes = []
for element in midi.flat.notes:
    if isinstance(element, note.Note):
        notes.append(str(element.pitch))
    elif isinstance(element, chord.Chord):
        notes.append('.'.join(str(n) for n in element.normalOrder))

print(notes[:50])

import numpy as np
from keras.utils import np_utils

# Создание сопоставления заметок с целыми числами
pitchnames = sorted(set(item for item in notes))
note_to_int = dict((note, number) for number, note in enumerate(pitchnames))

# Подготовьте данные для обучения
sequence_length = 100
network_input = []
network_output = []

for i in range(0, len(notes) - sequence_length):
    seq_in = notes[i:i + sequence_length]
    seq_out = notes[i + sequence_length]
    network_input.append([note_to_int[char] for char in seq_in])
    network_output.append(note_to_int[seq_out])

n_patterns = len(network_input)

# Преобразуйте входные данные в формат, подходящий для слоя LSTM.
network_input = np.reshape(network_input, (n_patterns, sequence_length, 1))
network_input = network_input / float(len(pitchnames))
network_output = np_utils.to_categorical(network_output)

print(network_input.shape)
print(network_output.shape)

from keras.models import Sequential
from keras.layers import LSTM, Dropout, Dense, Activation
from keras.callbacks import ModelCheckpoint

def build_model(network_input, n_vocab):
    model = Sequential()
    model.add(LSTM(256, input_shape=(network_input.shape[1], network_input.shape[2]), return_sequences=True))
    model.add(Dropout(0.3))
    model.add(LSTM(256, return_sequences=True))
    model.add(Dropout(0.3))
    model.add(LSTM(256))
    model.add(Dropout(0.3))
    model.add(Dense(256))
    model.add(Dropout(0.3))
    model.add(Dense(n_vocab))
    model.add(Activation('softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
    return model

model = build_model(network_input, len(pitchnames))
model.summary()

# Установите контрольные точки, чтобы сохранить лучшие модели
filepath = "weights-improvement-{epoch:02d}-{loss:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]

# Модель обучения
model.fit(network_input, network_output, epochs=200, batch_size=64, callbacks=callbacks_list)

# генерировать музыку
def generate_notes(model, network_input, pitchnames, n_vocab):
    start = np.random.randint(0, len(network_input)-1)
    int_to_note = dict((number, note) for number, note in enumerate(pitchnames))
    pattern = network_input[start]
    prediction_output = []

    for note_index in range(500):
        prediction_input = np.reshape(pattern, (1, len(pattern), 1))
        prediction_input = prediction_input / float(n_vocab)
        prediction = model.predict(prediction_input, verbose=0)
        index = np.argmax(prediction)
        result = int_to_note[index]
        prediction_output.append(result)
        pattern = np.append(pattern, index)
        pattern = pattern[1:len(pattern)]

    return prediction_output

# Преобразование сгенерированных нот в MIDI-файлы
def create_midi(prediction_output):
    offset = 0
    output_notes = []

    for pattern in prediction_output:
        if ('.' in pattern) or pattern.isdigit():
            notes_in_chord = pattern.split('.')
            notes = []
            for current_note in notes_in_chord:
                new_note = note.Note(int(current_note))
                new_note.storedInstrument = instrument.Piano()
                notes.append(new_note)
            new_chord = chord.Chord(notes)
            new_chord.offset = offset
            output_notes.append(new_chord)
        else:
            new_note = note.Note(pattern)
            new_note.offset = offset
            new_note.storedInstrument = instrument.Piano()
            output_notes.append(new_note)

        offset += 0.5

    midi_stream = stream.Stream(output_notes)
    midi_stream.write('midi', fp='test_output.mid')

# Создание и сохранение музыки
prediction_output = generate_notes(model, network_input, pitchnames, len(pitchnames))
create_midi(prediction_output)

# Используйте предварительную модель обучение передаче стиля
from keras.applications import VGG19
from keras.models import Model

# Загрузите предварительно обученную модель VGG19.
vgg = VGG19(include_top=False, weights='imagenet')

# Определить модель переноса стиля
def build_style_transfer_model(content_image, style_image):
    content_layer = 'block5_conv2'
    style_layers = ['block1_conv1', 'block2_conv1', 'block3_conv1', 'block4_conv1', 'block5_conv1']

    content_model = Model(inputs=vgg.input, outputs=vgg.get_layer(content_layer).output)
    style_models = [Model(inputs=vgg.input, outputs=vgg.get_layer(layer).output) for layer in style_layers]

    return content_model, style_models

# Пример: перенос стиля
content_image = preprocess_image(cv2.imread('content_music.jpg'))
style_image = preprocess_image(cv2.imread('style_music.jpg'))
content_model, style_models = build_style_transfer_model(content_image, style_image)
print('Style Transfer Model Built')

# в реальном временигенерировать музыку
def real_time_music_generation(model, network_input, pitchnames, n_vocab):
    start = np.random.randint(0, len(network_input)-1)
    int_to_note = dict((number, note) for number, note in enumerate(pitchnames))
    pattern = network_input[start]
    prediction_output = []

    for note_index in range(500):
        prediction_input = np.reshape(pattern, (1, len(pattern), 1))
        prediction_input = prediction_input / float(n_vocab)
        prediction = model.predict(prediction_input, verbose=0)
        index = np.argmax(prediction)
        result = int_to_note[index]
        prediction_output.append(result)
        pattern = np.append(pattern, index)
        pattern = pattern[1:len(pattern)]

        # Воспроизведение сгенерированных заметок в реальном времени
        play_generated_music(result)

    return prediction_output

# Пример：в реальном временигенерировать музыку
real_time_music_generation(model, network_input, pitchnames, len(pitchnames))