使用Python实现深度学习模型：智能音乐创作与生成

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))