pred.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from processing.preprocess import save_spectrogram\n",
    "from dotenv import load_dotenv\n",
    "import os\n",
    "import warnings\n",
    "import torch\n",
    "import numpy as np\n",
    "from pytube import YouTube\n",
    "from moviepy.editor import *\n",
    "\n",
    "sys.path.insert(0, './model')\n",
    "sys.path.insert(0, './processing')\n",
    "from encoder_only_transformer import OnsetsFrames\n",
    "from encoder_only_transformer import VelocityModel\n",
    "from pred_to_midi import folder_to_midi\n",
    "from pred_to_midi import create_frames_velocity_dict\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Prediction():\n",
    "    # init\n",
    "    def __init__(self, of_model, vel_model, of_path, vel_path, output_folder, device = 'cuda'):\n",
    "        # Load in the model\n",
    "        self.device = device\n",
    "        self.of_model = of_model\n",
    "        self.vel_model = vel_model\n",
    "        self.of_path = of_path\n",
    "        self.vel_path = vel_path\n",
    "\n",
    "        self.of_model.load_state_dict(torch.load(self.of_path, map_location=torch.device(device)), strict=False)\n",
    "        self.vel_model.load_state_dict(torch.load(self.vel_path, map_location=torch.device(device)), strict=False)\n",
    "\n",
    "        # Set up directories\n",
    "        self.output_folder = output_folder\n",
    "\n",
    "    def intersect_frames_onsets(self, frames, onsets):\n",
    "        ''' \n",
    "            Modify the frames array such that it only contains notes \n",
    "            if it contains an onset\n",
    "        '''\n",
    "        frames_new = np.zeros(frames.shape)\n",
    "\n",
    "        \n",
    "        for i in range(len(frames)):\n",
    "            # Go through every note:\n",
    "            record_current = False\n",
    "\n",
    "            for j in range(len(frames[0])):\n",
    "                \n",
    "                is_played = (frames[i][j] == 1)\n",
    "                is_true_onset = (onsets[i][j] == 1)\n",
    "                if j == 0: is_onset = is_played\n",
    "                else: is_onset = is_played and frames[i][j-1] == 0\n",
    "                \n",
    "                if is_played:\n",
    "                    \n",
    "                    if is_true_onset:\n",
    "                        frames_new[i][j] = 1\n",
    "                        j_last = j # Reset the onset time\n",
    "                        record_current = True\n",
    "\n",
    "                    else:\n",
    "                        if record_current:\n",
    "                            frames_new[i][j] = 1\n",
    "                        else:\n",
    "                            continue\n",
    "\n",
    "                else:\n",
    "                    record_current = False\n",
    "\n",
    "        return frames_new\n",
    "\n",
    "    def prepare(self, input_file, song_name):\n",
    "        '''\n",
    "        Generates the 20s spectrograms of the given input .wav file,\n",
    "        and outputs it in the output_folder in:\n",
    "            output_folder/output_name/raw/\n",
    "        '''\n",
    "        output_dir = os.path.join(self.output_folder, song_name)\n",
    "        save_spectrogram(input_file, output_dir, \"raw____\") # extra characters are a workaround for a poorly implemented save_spectrogram function\n",
    "\n",
    "    def prepare_for_model(self, data):\n",
    "        '''\n",
    "        Turns a numpy array into a tensor\n",
    "        '''\n",
    "        data = torch.from_numpy(data)\n",
    "        data = data.unsqueeze(0)\n",
    "        data = data.transpose(1,2)\n",
    "        return data\n",
    "\n",
    "    def prepare_after_model(self, data, tolerance = 0):\n",
    "        '''\n",
    "        Turns a tensor into a numpy array and normalizes logits to 0 and 1\n",
    "        '''\n",
    "        data = data.squeeze(0)\n",
    "        data = data.transpose(0,1)\n",
    "        data = data.detach().numpy()\n",
    "        for i in range(len(data)):\n",
    "            for j in range(len(data[i])):\n",
    "                if data[i][j] > tolerance:\n",
    "                    data[i][j] = 1\n",
    "                else:\n",
    "                    data[i][j] = 0\n",
    "        return data\n",
    "\n",
    "    def run_model(self, song_name):\n",
    "        '''\n",
    "        Runs the model on every numpy file in the folder\n",
    "            \n",
    "            output_folder/song_name/raw/\n",
    "\n",
    "        and outputs the predictions in\n",
    "\n",
    "            output_folder/song_name/frames\n",
    "            output_folder/song_name/onsets\n",
    "            output_folder/song_name/velocities\n",
    "\n",
    "        model_type can be:\n",
    "            \"onsets\"\n",
    "            \"frames\"\n",
    "            \"offsets\"\n",
    "            \"velocities\"\n",
    "        '''\n",
    "\n",
    "        # Create the folder if not already created\n",
    "        output_dir_frames = os.path.join(self.output_folder, song_name, \"frames\")\n",
    "        if not os.path.isdir(output_dir_frames):\n",
    "            os.makedirs(output_dir_frames)\n",
    "\n",
    "        output_dir_onsets = os.path.join(self.output_folder, song_name, \"onsets\")\n",
    "        if not os.path.isdir(output_dir_onsets):\n",
    "            os.makedirs(output_dir_onsets)\n",
    "\n",
    "        output_dir_velocities = os.path.join(self.output_folder, song_name, \"velocities\")\n",
    "        if not os.path.isdir(output_dir_velocities):\n",
    "            os.makedirs(output_dir_velocities)\n",
    "\n",
    "        # Load in the dataset\n",
    "        raw_path = os.path.join(self.output_folder, song_name, \"raw\")\n",
    "        spectrogram_list = os.listdir(raw_path)\n",
    "        spectrogram_list = sorted(spectrogram_list, key=lambda x: float(x.split('_')[1].split('.')[0]))\n",
    "\n",
    "        # Iterate through everything in the loader\n",
    "        for spec in spectrogram_list:\n",
    "            if spec.endswith(\"20.npy\"):\n",
    "                # Load data and turn into right shape\n",
    "                data = self.prepare_for_model(np.load(os.path.join(raw_path, spec)))\n",
    "                # Prediction\n",
    "                onsets, frames = self.of_model(data)\n",
    "                velocities = self.vel_model(data)\n",
    "\n",
    "                onsets = self.prepare_after_model(onsets, tolerance = - 3)\n",
    "                frames = self.prepare_after_model(frames)\n",
    "\n",
    "                frames = self.intersect_frames_onsets(frames, onsets)\n",
    "                velocities = velocities.squeeze(0)\n",
    "                velocities = velocities.transpose(0,1)\n",
    "                velocities = velocities.detach().numpy()\n",
    "                velocities = velocities * onsets\n",
    "                \n",
    "                # Save the output\n",
    "                np.save(os.path.join(output_dir_frames, spec), frames)\n",
    "                np.save(os.path.join(output_dir_onsets, spec), onsets)\n",
    "                np.save(os.path.join(output_dir_velocities, spec), velocities)\n",
    "\n",
    "    def wav_to_wav(self, input_file, song_name):\n",
    "        self.prepare(input_file, song_name)\n",
    "\n",
    "        self.run_model(song_name)\n",
    "\n",
    "        frames_folder = os.path.join(self.output_folder, song_name, \"frames\")\n",
    "        velocity_folder = os.path.join(self.output_folder, song_name, \"velocities\")\n",
    "        folder_to_midi(frames_folder, velocity_folder, os.path.join(self.output_folder,song_name,song_name+\"_synthesized.midi\"))\n",
    "        \n",
    "\n",
    "    def pred_youtube_to_wav(self, youtube_url, song_name):\n",
    "        '''\n",
    "        Downloads the youtube video and converts it to a .wav file.\n",
    "        Then makes a prediction on the .wav file.\n",
    "\n",
    "        Credit for Downloading Code: https://stackoverflow.com/questions/27473526/download-only-audio-from-youtube-video-using-youtube-dl-in-python-script\n",
    "        ''' \n",
    "        # Download the video as .wav and save it\n",
    "        yt = YouTube(youtube_url)\n",
    "        video = yt.streams.filter(only_audio=True).first()\n",
    "        out_file = video.download(output_path=\".\")\n",
    "\n",
    "        # Make directory if doesn't exist\n",
    "        output_dir = os.path.join(self.output_folder, song_name)\n",
    "        if not os.path.isdir(output_dir):\n",
    "            os.makedirs(output_dir)\n",
    "\n",
    "        new_file = os.path.join(output_dir, song_name+\".wav\")\n",
    "        os.rename(out_file, new_file)\n",
    "\n",
    "        # Make predictions\n",
    "        self.wav_to_wav(new_file, song_name)\n",
    "    \n",
    "    def pred_mp4_to_wav(self, input_mp4, song_name, start=\"00:00:00\", end=-1):\n",
    "        '''\n",
    "        Converts a mp4 file to a wav file.\n",
    "        Then makes a prediction on the .wav file\n",
    "\n",
    "        Defaults to starting at t='00:00:00' and ending at t=MAX\n",
    "        where time is in 'hh:mm:ss' format\n",
    "        '''\n",
    "\n",
    "        # # Convert mp4 to wav\n",
    "        wav_file = os.path.join(self.output_folder, song_name, song_name+\".wav\")\n",
    "        output_dir = os.path.join(self.output_folder, song_name)\n",
    "        if not os.path.isdir(output_dir):\n",
    "            os.makedirs(output_dir)\n",
    "\n",
    "        videoclip = VideoFileClip(input_mp4)\n",
    "        \n",
    "        if end == -1:\n",
    "            end = videoclip.duration\n",
    "\n",
    "        videoclip = videoclip.subclip(start, end)\n",
    "        audioclip = videoclip.audio\n",
    "        audioclip.write_audiofile(wav_file)\n",
    "        # Trim the audioclip\n",
    "\n",
    "\n",
    "        audioclip.close()\n",
    "        videoclip.close()\n",
    "\n",
    "        # return\n",
    "        self.wav_to_wav(wav_file, song_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = 'cpu'\n",
    "of_model = OnsetsFrames(229, 512, 16, 512, 8, bias2=True, dropout=0.1)\n",
    "vel_model = VelocityModel(229, 512, 16, 512, 8)\n",
    "of_path = 'fr_2.pt'\n",
    "vel_path = 'vel.pt'\n",
    "output_folder = os.environ.get('testname')\n",
    "\n",
    "# Create a Prediction class\n",
    "chopin = Prediction(of_model, vel_model, of_path, vel_path, output_folder, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "chopin.pred_youtube_to_wav(\"https://www.youtube.com/watch?v=GmK9zg4-fuE\", \"clean\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "chunk:  16%|█▌        | 319/2049 [00:00<00:00, 3187.50it/s, now=None]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MoviePy - Writing audio in test_data/demo3/demo3.wav\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                      \n",
      "\u001b[A"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MoviePy - Done.\n"
     ]
    }
   ],
   "source": [
    "chopin.pred_mp4_to_wav(\"demo2.mp4\", \"demo3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f63e48a3970>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2160x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = np.load(\"test_data/rickroll2/frames/offset_40.0_duration_20.npy\")\n",
    "plt.figure(figsize=(30,10))\n",
    "plt.imshow(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "d7677d11f1bd61d3b32a24a8c23a7d74b9c39e45b33704a1489595ea04a1f9dc"
  },
  "kernelspec": {
   "display_name": "Python 3.8.12 64-bit ('midi-shark': conda)",
   "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.8.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}