10_RNNGenerative/人工智能作曲机_MIDIComposer.ipynb · 滴石/深度学习原理与PyTorch实战

加入 Gitee

与超过 1200万开发者一起发现、参与优秀开源项目，私有仓库也完全免费：）

文件

克隆/下载

人工智能作曲机_MIDIComposer.ipynb 73.43 KB

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 神经莫扎特——MIDI音乐的学习与生成\n",
    "\n",
    "在这节课中，我们学习了如何通过人工神经网络学习一个MIDI音乐，并记忆中音符时间序列中的模式，并生成一首音乐\n",
    "\n",
    "首先，我们要学习如何解析一个MIDI音乐，将它读如进来；其次，我们用处理后的MIDI序列数据训练一个LSTM网络，并让它预测下一个音符；\n",
    "\n",
    "最后，我们用训练好的LSTM生成MIDI音乐\n",
    "\n",
    "本程序改造自\n",
    "\n",
    "本文件是集智AI学园http://campus.swarma.org 出品的“火炬上的深度学习”第VI课的配套源代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入必须的依赖包\n",
    "\n",
    "# 与PyTorch相关的包\n",
    "import torch\n",
    "import torch.utils.data as DataSet\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "import torch.optim as optim\n",
    "\n",
    "\n",
    "# 导入midi音乐处理的包\n",
    "from mido import MidiFile, MidiTrack, Message\n",
    "\n",
    "# 导入计算与绘图必须的包\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一、导入MIDI文件，并处理成标准形式 \n",
    "\n",
    "首先，我们从MIDI文件中提取出消息（Message）序列，一个消息包括：音符（note）、速度（velocity）与时间（time，距离上一个音符的时间长度）\n",
    "\n",
    "其次，我们要将每一个消息进行编码，根据音符、速度、时间的取值范围，我们分别用长度为89、128与11的one-hot编码得到一个01向量。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 从硬盘读取MIDI文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'Time')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 从硬盘中读入MIDI音乐文件\n",
    "#mid = MidiFile('./music/allegroconspirito.mid') # a Mozart piece\n",
    "mid = MidiFile('./music/krebs.mid') # a Mozart piece\n",
    "\n",
    "notes = []\n",
    "\n",
    "time = float(0)\n",
    "prev = float(0)\n",
    "\n",
    "original = [] # original记载了原始message数据，以便后面的比较\n",
    "\n",
    "# 对MIDI文件中所有的消息进行循环\n",
    "for msg in mid:\n",
    "    # 时间的单位是秒，而不是帧\n",
    "    time += msg.time\n",
    "    \n",
    "    # 如果当前消息不是描述信息\n",
    "    if not msg.is_meta:\n",
    "        # 仅提炼第一个channel的音符\n",
    "        if msg.channel == 0:\n",
    "            # 如果当前音符为打开的\n",
    "            if msg.type == 'note_on':\n",
    "                # 获得消息中的信息（编码在字节中）\n",
    "                note = msg.bytes() \n",
    "                # 我们仅对音符信息感兴趣. 音符消息按如下形式记录 [type, note, velocity]\n",
    "                note = note[1:3] #操作完这一步后，note[0]存音符，note[1]存速度（力度）\n",
    "                # note[2]存据上一个message的时间间隔\n",
    "                note.append(time - prev)\n",
    "                prev = time\n",
    "                # 将音符添加到列表notes中\n",
    "                notes.append(note)\n",
    "                # 在原始列表中保留这些音符\n",
    "                original.append([i for i in note])\n",
    "\n",
    "# 绘制每一个分量的直方图，方便看出每一个量的取值范围\n",
    "plt.figure()\n",
    "plt.hist([i[0] for i in notes])\n",
    "plt.title('Note')\n",
    "plt.figure()\n",
    "plt.hist([i[1] for i in notes])\n",
    "plt.title('Velocity')\n",
    "plt.figure()\n",
    "plt.hist([i[2] for i in notes])\n",
    "plt.title('Time')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 将每一个Message进行编码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "原始的数据是形如(78, 0, 0.0108)这样的三元组\n",
    "\n",
    "编码后的数据格式为：(00...010..., 100..., 0100...)这样的三个one-hot向量，第一个向量长度89，第二个128，第三个11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note和velocity都可以看作是类型变量\n",
    "# time为float，我们按照区间将其也化成离散的类型变量\n",
    "# 首先，我们找到time变量的取值区间，并进行划分。由于大量msg的time为0，因此我们把0归为了一个特别的类\n",
    "intervals = 10\n",
    "values = np.array([i[2] for i in notes])\n",
    "max_t = np.amax(values) #区间中的最大值\n",
    "min_t = np.amin(values[values > 0]) #区间中的最小值\n",
    "interval = 1.0 * (max_t - min_t) / intervals\n",
    "\n",
    "# 接下来，我们将每一个message编码成三个one-hot向量，将这三个向量合并到一起就构成了slot向量\n",
    "dataset = []\n",
    "for note in notes:\n",
    "    slot = np.zeros(89 + 128 + 12)\n",
    "    \n",
    "    #由于note是介于24-112之间的，因此减24\n",
    "    ind1 = note[0]-24\n",
    "    ind2 = note[1]\n",
    "    # 由于message中有大量的time=0的情况，因此我们将0分为单独的一类，其他的都是按照区间划分\n",
    "    ind3 = int((note[2] - min_t) / interval + 1) if note[2] > 0 else 0\n",
    "    slot[ind1] = 1\n",
    "    slot[89 + ind2] = 1\n",
    "    slot[89 + 128 + ind3] = 1\n",
    "    # 将处理后得到的slot数组加入到dataset中\n",
    "    dataset.append(slot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.生成训练集和校验集，装进数据加载器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们将整个音符三元组（note，velocity，time）序列按照31位长度的滑动窗口切分成了len(dataset)-n_prev组\n",
    "\n",
    "每一组的前30位作为输入，最后一位作为输出形成了训练数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 生成训练集和校验集\n",
    "X = []\n",
    "Y = []\n",
    "# 首先，按照预测的模式，我们将原始数据生成一对一对的训练数据\n",
    "n_prev = 30 # 滑动窗口长度为30\n",
    "\n",
    "# 对数据中的所有数据进行循环\n",
    "for i in range(len(dataset)-n_prev):\n",
    "    # 往后取n_prev个note作为输入属性\n",
    "    x = dataset[i:i+n_prev]\n",
    "    # 将第n_prev+1个note（编码前）作为目标属性\n",
    "    y = notes[i+n_prev]\n",
    "    # 注意time要转化成类别的形式\n",
    "    ind3 = int((y[2] - min_t) / interval + 1) if y[2] > 0 else 0\n",
    "    y[2] = ind3\n",
    "    \n",
    "    # 将X和Y加入到数据集中\n",
    "    X.append(x)\n",
    "    Y.append(y)\n",
    "    \n",
    "# 将数据集中的前n_prev个音符作为种子，用于生成音乐的时候用\n",
    "seed = dataset[0:n_prev]\n",
    "\n",
    "# 对所有数据顺序打乱重排\n",
    "idx = np.random.permutation(range(len(X)))\n",
    "# 形成训练与校验数据集列表\n",
    "X = [X[i] for i in idx]\n",
    "Y = [Y[i] for i in idx]\n",
    "\n",
    "# 从中切分1/10的数据出来放入校验集\n",
    "validX = X[: len(X) // 10]\n",
    "X = X[len(X) // 10 :]\n",
    "validY = Y[: len(Y) // 10]\n",
    "Y = Y[len(Y) // 10 :]\n",
    "\n",
    "# 将列表再转化为dataset，并用dataloader来加载数据\n",
    "# dataloader是PyTorch开发采用的一套管理数据的方法。通常数据的存储放在dataset中，而对数据的调用则是通过data loader完成的\n",
    "# 同时，在进行预处理的时候，系统已经自动将数据打包成撮（batch），每次调用，我们都提取一整个撮出来（包含多条记录）\n",
    "# 从dataloader中吐出的每一个元素都是一个(x,y)元组，其中x为输入的张量，y为标签。x和y的第一个维度都是batch_size大小。\n",
    "\n",
    "batch_size = 30 #一撮包含30个数据记录，这个数字越大，系统在训练的时候，每一个周期处理的数据就越多，这样处理越快，但总的数据量会减少\n",
    "\n",
    "# 形成训练集\n",
    "train_ds = DataSet.TensorDataset(torch.FloatTensor(np.array(X, dtype = float)), torch.LongTensor(np.array(Y)))\n",
    "# 形成数据加载器\n",
    "train_loader = DataSet.DataLoader(train_ds, batch_size = batch_size, shuffle = True, num_workers=4)\n",
    "\n",
    "\n",
    "# 校验数据\n",
    "valid_ds = DataSet.TensorDataset(torch.FloatTensor(np.array(validX, dtype = float)), torch.LongTensor(np.array(validY)))\n",
    "valid_loader = DataSet.DataLoader(valid_ds, batch_size = batch_size, shuffle = True, num_workers=4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二、定义一个LSTM网络\n",
    "\n",
    "该网络特殊的地方在于它的输出，对于每一个样本，它会输出三个变量x,y,z，它们分别是一个归一化的概率向量\n",
    "\n",
    "分别用来预测类型化了的note、velocity和time\n",
    "\n",
    "在网络中我们对lstm的输出结果进行dropout的操作，所谓的dropout就是指在训练的截断，系统会随机删除掉一些神经元，\n",
    "，而在测试阶段则不会删掉神经元，这样使得模型给出正确的输出会更加困难，从避免了过拟合现象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class LSTMNetwork(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, out_size, n_layers=1):\n",
    "        super(LSTMNetwork, self).__init__()\n",
    "        self.n_layers = n_layers\n",
    "        \n",
    "        self.hidden_size = hidden_size\n",
    "        self.out_size = out_size\n",
    "        # 一层LSTM单元\n",
    "        self.lstm = nn.LSTM(input_size, hidden_size, n_layers, batch_first = True)\n",
    "        # 一个Dropout部件，以0.2的概率Dropout\n",
    "        self.dropout = nn.Dropout(0.2)\n",
    "        # 一个全链接层\n",
    "        self.fc = nn.Linear(hidden_size, out_size)\n",
    "        # 对数Softmax层\n",
    "        self.softmax = nn.LogSoftmax(dim = 1)\n",
    "\n",
    "    def forward(self, input, hidden=None):\n",
    "        # 神经网络的每一步运算\n",
    "\n",
    "        hhh1 = hidden[0] #读如隐含层的初始信息\n",
    "        \n",
    "        # 完成一步LSTM运算\n",
    "        # input的尺寸为：batch_size , time_step, input_size\n",
    "        output, hhh1 = self.lstm(input, hhh1) #input:batchsize*timestep*3\n",
    "        # 对神经元输出的结果进行dropout\n",
    "        output = self.dropout(output)\n",
    "        # 取出最后一个时刻的隐含层输出值\n",
    "        # output的尺寸为：batch_size, time_step, hidden_size\n",
    "        output = output[:, -1, ...]\n",
    "        # 此时，output的尺寸为：batch_size, hidden_size\n",
    "        # 喂入一个全链接层\n",
    "        out = self.fc(output)\n",
    "        # out的尺寸为：batch_size, output_size\n",
    "\n",
    "        # 将out的最后一个维度分割成三份x, y, z分别对应对note，velocity以及time的预测\n",
    "        \n",
    "        x = self.softmax(out[:, :89])\n",
    "        y = self.softmax(out[:, 89: 89 + 128])\n",
    "        z = self.softmax(out[:, 89 + 128:])\n",
    "        \n",
    "        # x的尺寸为batch_size, 89\n",
    "        # y的尺寸为batch_size, 128\n",
    "        # z的尺寸为batch_size, 11\n",
    "        # 返回x,y,z\n",
    "        return (x,y,z)\n",
    "\n",
    "    def initHidden(self, batch_size):\n",
    "        # 对隐含层单元变量全部初始化为0\n",
    "        # 注意尺寸是： layer_size, batch_size, hidden_size\n",
    "        out = []\n",
    "        hidden1=torch.zeros(1, batch_size, self.hidden_size)\n",
    "        cell1=torch.zeros(1, batch_size, self.hidden_size)\n",
    "        out.append((hidden1, cell1))\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def criterion(outputs, target):\n",
    "    # 为本模型自定义的损失函数，它由三部分组成，每部分都是一个交叉熵损失函数，\n",
    "    # 它们分别对应note、velocity和time的交叉熵\n",
    "    x, y, z = outputs\n",
    "    loss_f = nn.NLLLoss()\n",
    "    loss1 = loss_f(x, target[:, 0])\n",
    "    loss2 = loss_f(y, target[:, 1])\n",
    "    loss3 = loss_f(z, target[:, 2])\n",
    "    return loss1 + loss2 + loss3\n",
    "def rightness(predictions, labels):\n",
    "    \"\"\"计算预测错误率的函数，其中predictions是模型给出的一组预测结果，batch_size行num_classes列的矩阵，labels是数据之中的正确答案\"\"\"\n",
    "    pred = torch.max(predictions.data, 1)[1] # 对于任意一行（一个样本）的输出值的第1个维度，求最大，得到每一行的最大元素的下标\n",
    "    rights = pred.eq(labels.data).sum() #将下标与labels中包含的类别进行比较，并累计得到比较正确的数量\n",
    "    return rights, len(labels) #返回正确的数量和这一次一共比较了多少元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 开始训练一个LSTM。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第0轮, 训练Loss:9.09, 校验Loss:4.88, 校验准确度:0.36\n",
      "第1轮, 训练Loss:4.41, 校验Loss:4.30, 校验准确度:0.45\n",
      "第2轮, 训练Loss:4.27, 校验Loss:4.27, 校验准确度:0.55\n",
      "第3轮, 训练Loss:4.23, 校验Loss:4.11, 校验准确度:0.43\n",
      "第4轮, 训练Loss:4.12, 校验Loss:3.99, 校验准确度:0.57\n",
      "第5轮, 训练Loss:3.85, 校验Loss:3.63, 校验准确度:0.65\n",
      "第6轮, 训练Loss:3.49, 校验Loss:3.33, 校验准确度:0.65\n",
      "第7轮, 训练Loss:3.36, 校验Loss:3.24, 校验准确度:0.67\n",
      "第8轮, 训练Loss:3.28, 校验Loss:3.21, 校验准确度:0.68\n",
      "第9轮, 训练Loss:3.24, 校验Loss:3.21, 校验准确度:0.67\n",
      "第10轮, 训练Loss:3.18, 校验Loss:3.06, 校验准确度:0.70\n",
      "第11轮, 训练Loss:3.14, 校验Loss:3.08, 校验准确度:0.67\n",
      "第12轮, 训练Loss:3.12, 校验Loss:2.97, 校验准确度:0.73\n",
      "第13轮, 训练Loss:3.10, 校验Loss:3.03, 校验准确度:0.68\n",
      "第14轮, 训练Loss:3.05, 校验Loss:3.02, 校验准确度:0.70\n",
      "第15轮, 训练Loss:3.03, 校验Loss:3.03, 校验准确度:0.71\n",
      "第16轮, 训练Loss:3.02, 校验Loss:3.00, 校验准确度:0.70\n",
      "第17轮, 训练Loss:2.97, 校验Loss:2.93, 校验准确度:0.73\n",
      "第18轮, 训练Loss:2.96, 校验Loss:2.91, 校验准确度:0.72\n",
      "第19轮, 训练Loss:2.93, 校验Loss:2.93, 校验准确度:0.74\n",
      "第20轮, 训练Loss:2.89, 校验Loss:2.86, 校验准确度:0.73\n",
      "第21轮, 训练Loss:2.84, 校验Loss:2.74, 校验准确度:0.73\n",
      "第22轮, 训练Loss:2.78, 校验Loss:2.73, 校验准确度:0.73\n",
      "第23轮, 训练Loss:2.74, 校验Loss:2.65, 校验准确度:0.74\n",
      "第24轮, 训练Loss:2.68, 校验Loss:2.57, 校验准确度:0.73\n",
      "第25轮, 训练Loss:2.63, 校验Loss:2.57, 校验准确度:0.74\n",
      "第26轮, 训练Loss:2.59, 校验Loss:2.53, 校验准确度:0.76\n",
      "第27轮, 训练Loss:2.54, 校验Loss:2.49, 校验准确度:0.75\n",
      "第28轮, 训练Loss:2.49, 校验Loss:2.46, 校验准确度:0.76\n",
      "第29轮, 训练Loss:2.43, 校验Loss:2.37, 校验准确度:0.78\n",
      "第30轮, 训练Loss:2.41, 校验Loss:2.31, 校验准确度:0.79\n",
      "第31轮, 训练Loss:2.35, 校验Loss:2.31, 校验准确度:0.77\n",
      "第32轮, 训练Loss:2.31, 校验Loss:2.29, 校验准确度:0.77\n",
      "第33轮, 训练Loss:2.27, 校验Loss:2.28, 校验准确度:0.77\n",
      "第34轮, 训练Loss:2.25, 校验Loss:2.19, 校验准确度:0.78\n",
      "第35轮, 训练Loss:2.24, 校验Loss:2.28, 校验准确度:0.78\n",
      "第36轮, 训练Loss:2.20, 校验Loss:2.18, 校验准确度:0.78\n",
      "第37轮, 训练Loss:2.12, 校验Loss:2.12, 校验准确度:0.79\n",
      "第38轮, 训练Loss:2.11, 校验Loss:2.08, 校验准确度:0.79\n",
      "第39轮, 训练Loss:2.09, 校验Loss:2.18, 校验准确度:0.77\n",
      "第40轮, 训练Loss:2.06, 校验Loss:2.02, 校验准确度:0.79\n",
      "第41轮, 训练Loss:2.04, 校验Loss:2.07, 校验准确度:0.78\n",
      "第42轮, 训练Loss:1.99, 校验Loss:2.05, 校验准确度:0.79\n",
      "第43轮, 训练Loss:1.96, 校验Loss:2.04, 校验准确度:0.81\n",
      "第44轮, 训练Loss:1.94, 校验Loss:2.01, 校验准确度:0.79\n",
      "第45轮, 训练Loss:1.91, 校验Loss:1.97, 校验准确度:0.80\n",
      "第46轮, 训练Loss:1.87, 校验Loss:1.94, 校验准确度:0.79\n",
      "第47轮, 训练Loss:1.87, 校验Loss:1.94, 校验准确度:0.80\n",
      "第48轮, 训练Loss:1.84, 校验Loss:1.92, 校验准确度:0.80\n",
      "第49轮, 训练Loss:1.81, 校验Loss:1.89, 校验准确度:0.79\n",
      "第50轮, 训练Loss:1.78, 校验Loss:1.90, 校验准确度:0.80\n",
      "第51轮, 训练Loss:1.75, 校验Loss:1.87, 校验准确度:0.80\n",
      "第52轮, 训练Loss:1.72, 校验Loss:1.84, 校验准确度:0.82\n",
      "第53轮, 训练Loss:1.73, 校验Loss:1.87, 校验准确度:0.80\n",
      "第54轮, 训练Loss:1.71, 校验Loss:1.87, 校验准确度:0.80\n",
      "第55轮, 训练Loss:1.67, 校验Loss:1.83, 校验准确度:0.79\n",
      "第56轮, 训练Loss:1.62, 校验Loss:1.83, 校验准确度:0.81\n",
      "第57轮, 训练Loss:1.59, 校验Loss:1.78, 校验准确度:0.79\n",
      "第58轮, 训练Loss:1.58, 校验Loss:1.75, 校验准确度:0.79\n",
      "第59轮, 训练Loss:1.54, 校验Loss:1.78, 校验准确度:0.80\n",
      "第60轮, 训练Loss:1.55, 校验Loss:1.73, 校验准确度:0.80\n",
      "第61轮, 训练Loss:1.52, 校验Loss:1.69, 校验准确度:0.81\n",
      "第62轮, 训练Loss:1.47, 校验Loss:1.67, 校验准确度:0.80\n",
      "第63轮, 训练Loss:1.44, 校验Loss:1.64, 校验准确度:0.81\n",
      "第64轮, 训练Loss:1.41, 校验Loss:1.65, 校验准确度:0.82\n",
      "第65轮, 训练Loss:1.41, 校验Loss:1.62, 校验准确度:0.81\n",
      "第66轮, 训练Loss:1.39, 校验Loss:1.61, 校验准确度:0.82\n",
      "第67轮, 训练Loss:1.38, 校验Loss:1.61, 校验准确度:0.82\n",
      "第68轮, 训练Loss:1.37, 校验Loss:1.57, 校验准确度:0.82\n",
      "第69轮, 训练Loss:1.33, 校验Loss:1.65, 校验准确度:0.80\n",
      "第70轮, 训练Loss:1.31, 校验Loss:1.59, 校验准确度:0.82\n",
      "第71轮, 训练Loss:1.30, 校验Loss:1.55, 校验准确度:0.81\n",
      "第72轮, 训练Loss:1.29, 校验Loss:1.53, 校验准确度:0.81\n",
      "第73轮, 训练Loss:1.22, 校验Loss:1.47, 校验准确度:0.83\n",
      "第74轮, 训练Loss:1.26, 校验Loss:1.52, 校验准确度:0.82\n",
      "第75轮, 训练Loss:1.22, 校验Loss:1.47, 校验准确度:0.82\n",
      "第76轮, 训练Loss:1.20, 校验Loss:1.42, 校验准确度:0.83\n",
      "第77轮, 训练Loss:1.16, 校验Loss:1.47, 校验准确度:0.82\n",
      "第78轮, 训练Loss:1.17, 校验Loss:1.44, 校验准确度:0.82\n",
      "第79轮, 训练Loss:1.17, 校验Loss:1.48, 校验准确度:0.83\n",
      "第80轮, 训练Loss:1.14, 校验Loss:1.39, 校验准确度:0.82\n",
      "第81轮, 训练Loss:1.11, 校验Loss:1.43, 校验准确度:0.82\n",
      "第82轮, 训练Loss:1.07, 校验Loss:1.35, 校验准确度:0.83\n",
      "第83轮, 训练Loss:1.08, 校验Loss:1.36, 校验准确度:0.84\n",
      "第84轮, 训练Loss:1.04, 校验Loss:1.38, 校验准确度:0.83\n",
      "第85轮, 训练Loss:1.03, 校验Loss:1.34, 校验准确度:0.85\n",
      "第86轮, 训练Loss:1.03, 校验Loss:1.31, 校验准确度:0.84\n",
      "第87轮, 训练Loss:0.98, 校验Loss:1.30, 校验准确度:0.84\n",
      "第88轮, 训练Loss:0.95, 校验Loss:1.28, 校验准确度:0.84\n",
      "第89轮, 训练Loss:0.98, 校验Loss:1.20, 校验准确度:0.85\n",
      "第90轮, 训练Loss:0.99, 校验Loss:1.22, 校验准确度:0.84\n",
      "第91轮, 训练Loss:0.94, 校验Loss:1.25, 校验准确度:0.85\n",
      "第92轮, 训练Loss:0.94, 校验Loss:1.27, 校验准确度:0.85\n",
      "第93轮, 训练Loss:0.92, 校验Loss:1.25, 校验准确度:0.86\n",
      "第94轮, 训练Loss:0.91, 校验Loss:1.21, 校验准确度:0.86\n",
      "第95轮, 训练Loss:0.87, 校验Loss:1.25, 校验准确度:0.85\n",
      "第96轮, 训练Loss:0.87, 校验Loss:1.28, 校验准确度:0.84\n",
      "第97轮, 训练Loss:0.89, 校验Loss:1.17, 校验准确度:0.86\n",
      "第98轮, 训练Loss:0.83, 校验Loss:1.17, 校验准确度:0.87\n",
      "第99轮, 训练Loss:0.82, 校验Loss:1.22, 校验准确度:0.87\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 定义一个LSTM，其中输入输出层的单元个数取决于每个变量的类型取值范围\n",
    "lstm = LSTMNetwork(89 + 128 + 12, 128, 89 + 128 + 12)\n",
    "optimizer = optim.Adam(lstm.parameters(), lr=0.001)\n",
    "num_epochs = 100\n",
    "train_losses = []\n",
    "valid_losses = []\n",
    "records = []\n",
    "\n",
    "# 开始训练循环\n",
    "for epoch in range(num_epochs):\n",
    "    train_loss = []\n",
    "    # 开始遍历加载器中的数据\n",
    "    for batch, data in enumerate(train_loader):\n",
    "        # batch为数字，表示已经进行了第几个batch了\n",
    "        # data为一个二元组，分别存储了一条数据记录的输入和标签\n",
    "        # 每个数据的第一个维度都是batch_size = 30的数组\n",
    "        \n",
    "        lstm.train() # 标志LSTM当前处于训练阶段，Dropout开始起作用\n",
    "        init_hidden = lstm.initHidden(len(data[0])) # 初始化LSTM的隐单元变量\n",
    "        optimizer.zero_grad()\n",
    "#         print(data[0].size())\n",
    "#         print(data[1])\n",
    "#         print(data[1].size())\n",
    "        x, y = data[0].clone().detach().requires_grad_(True), data[1].clone().detach() # 从数据中提炼出输入和输出对\n",
    "        outputs = lstm(x, init_hidden) #喂入LSTM，产生输出outputs\n",
    "#         print(outputs[1].size())\n",
    "#         print(outputs[0].size())\n",
    "#         print(outputs[2].size())\n",
    "        \n",
    "        loss = criterion(outputs, y) #代入损失函数并产生loss\n",
    "#         print(loss.data.numpy())\n",
    "        train_loss.append(loss.data.numpy()) # 记录loss\n",
    "        loss.backward() #反向传播\n",
    "        optimizer.step() #梯度更新\n",
    "    if 0 == 0:\n",
    "        #在校验集上跑一遍，并计算在校验集上的分类准确率\n",
    "        valid_loss = []\n",
    "        lstm.eval() #将模型标志为测试状态，关闭dropout的作用\n",
    "        rights = []\n",
    "        # 遍历加载器加载进来的每一个元素\n",
    "        for batch, data in enumerate(valid_loader):\n",
    "            init_hidden = lstm.initHidden(len(data[0]))\n",
    "            #完成LSTM的计算\n",
    "            x, y = data[0].clone().detach().requires_grad_(True), data[1].clone().detach()\n",
    "            #x的尺寸：batch_size, length_sequence, input_size\n",
    "            #y的尺寸：batch_size, (data_dimension1=89+ data_dimension2=128+ data_dimension3=12)\n",
    "            outputs = lstm(x, init_hidden)\n",
    "            #outputs: (batch_size*89, batch_size*128, batch_size*11)\n",
    "            loss = criterion(outputs, y)\n",
    "            valid_loss.append(loss.data.numpy())\n",
    "            #计算每个指标的分类准确度\n",
    "            right1 = rightness(outputs[0], y[:, 0])\n",
    "            right2 = rightness(outputs[1], y[:, 1])\n",
    "            right3 = rightness(outputs[2], y[:, 2])\n",
    "            rights.append((right1[0] + right2[0] + right3[0]).numpy() * 1.0 / (right1[1] + right2[1] + right3[1]))\n",
    "        # 打印结果\n",
    "        print('第{}轮, 训练Loss:{:.2f}, 校验Loss:{:.2f}, 校验准确度:{:.2f}'.format(epoch, \n",
    "                                                                    np.mean(train_loss),\n",
    "                                                                    np.mean(valid_loss),\n",
    "                                                                    np.mean(rights)\n",
    "                                                                  ))\n",
    "        records.append([np.mean(train_loss), np.mean(valid_loss), np.mean(rights)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x124a27fd0>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制训练过程中的Loss曲线\n",
    "a = [i[0] for i in records]\n",
    "b = [i[1] for i in records]\n",
    "c = [i[2] * 10 for i in records]\n",
    "plt.plot(a, '-', label = 'Train Loss')\n",
    "plt.plot(b, '-', label = 'Validation Loss')\n",
    "plt.plot(c, '-', label = '10 * Accuracy')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 三、音乐生成\n",
    "\n",
    "我们运用训练好的LSTM来生成音符。首先把seed喂给LSTM并产生第n_prev + 1个msg，然后把这个msg加到输入数据的最后面，删除第一个元素\n",
    "\n",
    "这就又构成了一个标准的输入序列；然后再得到下一个msg，……，如此循环往复得到音符序列的生成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 生成3000步\n",
    "predict_steps = 3000\n",
    "\n",
    "# 初始时刻，将seed（一段种子音符，即我为开始读入的音乐文件）付给x\n",
    "x = seed\n",
    "# 将数据扩充为合适的形式\n",
    "x = np.expand_dims(x, axis = 0)\n",
    "# 现在的x的尺寸为：batch=1, time_step =30, data_dim = 229\n",
    "\n",
    "lstm.eval()\n",
    "initi = lstm.initHidden(1)\n",
    "predictions = []\n",
    "# 开始每一步的迭代\n",
    "for i in range(predict_steps):\n",
    "    # 根据前n_prev预测后面的一个音符\n",
    "    xx = torch.tensor(np.array(x, dtype = float),dtype = torch.float, requires_grad = True)\n",
    "    preds = lstm(xx, initi)\n",
    "    \n",
    "    # 返回预测的note，velocity，time的模型预测概率对数\n",
    "    a,b,c = preds\n",
    "    # a的尺寸为：batch=1*data_dim=89, b为1*128，c为1*11\n",
    "    \n",
    "    # 将概率对数转化为随机的选择\n",
    "    ind1 = torch.multinomial(a.view(-1).exp(), num_samples = 1) \n",
    "    ind2 = torch.multinomial(b.view(-1).exp(), num_samples = 1) \n",
    "    ind3 = torch.multinomial(c.view(-1).exp(), num_samples = 1) \n",
    "\n",
    "    ind1 = ind1.data.numpy()[0] # 0-89中的整数\n",
    "    ind2 = ind2.data.numpy()[0] # 0-128中的整数\n",
    "    ind3 = ind3.data.numpy()[0] # 0-11中的整数\n",
    "    \n",
    "    # 将选择转换为正确的音符等数值，注意time分为11类，第一类为0这个特殊的类，其余按照区间放回去\n",
    "    note = [ind1 + 24, ind2, 0 if ind3 ==0 else ind3 * interval + min_t]\n",
    "    \n",
    "    # 将预测的内容存储下来\n",
    "    predictions.append(note)\n",
    "    \n",
    "    # 将新的预测内容再次转变为输入数据准备喂给LSTM\n",
    "    slot = np.zeros(89 + 128 + 12, dtype = int)\n",
    "    slot[ind1] = 1\n",
    "    slot[89 + ind2] = 1\n",
    "    slot[89 + 128 + ind3] = 1\n",
    "    slot1 = np.expand_dims(slot, axis = 0)\n",
    "    slot1 = np.expand_dims(slot1, axis = 0)\n",
    "    \n",
    "    #slot1的数据格式为：batch=1*time=1*data_dim=229\n",
    "    \n",
    "    # x拼接上新的数据\n",
    "    x = np.concatenate((x, slot1), 1)\n",
    "    # 现在x的尺寸为: batch_size = 1 * time_step = 31 * data_dim =229\n",
    "    \n",
    "    # 滑动窗口往前平移一次\n",
    "    x = x[:, 1:, :]\n",
    "    # 现在x的尺寸为：batch_size = 1 * time_step = 30 * data_dim = 229\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将生成的序列转化为MIDI的消息，并保存MIDI音乐\n",
    "mid = MidiFile()\n",
    "track = MidiTrack()\n",
    "mid.tracks.append(track)\n",
    "\n",
    "for i, note in enumerate(predictions):\n",
    "    # 在note一开始插入一个147表示打开note_on\n",
    "    note = np.insert(note, 0, 147)\n",
    "    # 将整数转化为字节\n",
    "    bytes = note.astype(int)\n",
    "    # 创建一个message\n",
    "    msg = Message.from_bytes(bytes[0:3]) \n",
    "    # 0.001025为任意取值，可以调节音乐的速度。由于生成的time都是一系列的间隔时间，转化为msg后时间尺度过小，因此需要调节放大\n",
    "    time = int(note[3]/0.001025)\n",
    "    msg.time = time\n",
    "    # 将message添加到音轨中\n",
    "    track.append(msg)\n",
    "\n",
    "#保存文件\n",
    "mid.save('music/new_song.mid')\n",
    "###########################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}

一键复制编辑原始数据按行查看历史

提交于 2019-04-04 01:10 . 适应pytorch1.0.0版本修改

马建仓 AI 助手

尝试更多

代码解读

代码找茬

代码优化

https://gitee.com/psh686868/book_DeepLearning_in_PyTorch_Source.git

git@gitee.com:psh686868/book_DeepLearning_in_PyTorch_Source.git

psh686868

book_DeepLearning_in_PyTorch_Source

深度学习原理与PyTorch实战

master

滴石/深度学习原理与PyTorch实战

简介

发行版

贡献者

近期动态

滴石/深度学习原理与PyTorch实战 .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

滴石/深度学习原理与PyTorch实战