Rock-Piano.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "463e6fd9",
   "metadata": {},
   "source": [
    "# Rock Piano (ver. 3.0)\n",
    "\n",
    "## \"When all is one and one is all, that's what it is to be a rock and not to roll.\" ---Led Zeppelin, \"Stairway To Heaven\"\n",
    " \n",
    "***\n",
    " \n",
    "### Powered by tegridy-tools TMIDIX Optimus Processors: https://github.com/Tegridy-Code/tegridy-tools\n",
    " \n",
    "***\n",
    " \n",
    "### Credit for GPT2-RGA code used in this colab goes out @ Sashmark97 https://github.com/Sashmark97/midigen and @ Damon Gwinn https://github.com/gwinndr/MusicTransformer-Pytorch\n",
    " \n",
    "***\n",
    " \n",
    "### WARNING: This complete implementation is a functioning model of the Artificial Intelligence. Please excercise great humility, care, and respect. https://www.nscai.gov/\n",
    " \n",
    "***\n",
    " \n",
    "#### Project Los Angeles\n",
    " \n",
    "#### Tegridy Code 2021\n",
    " \n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a093d5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4863cb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Install all dependencies (run only once per session)\n",
    "    \n",
    "!git clone https://github.com/asigalov61/Rock-Piano    \n",
    "    \n",
    "!pip install tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8e31cd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Loading needed modules. Please wait...')\n",
    "import os\n",
    "from datetime import datetime\n",
    "import secrets\n",
    "import copy\n",
    "import tqdm\n",
    "from tqdm import tqdm\n",
    "\n",
    "#os.chdir('Rock-Piano')\n",
    "\n",
    "print('Loading TMIDIX module...')\n",
    "import TMIDIX\n",
    "print('Loading GPT2RGA module...')\n",
    "from GPT2RGA import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "588af228",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Unzip the Model and the Training Data\n",
    "\n",
    "print('Unzipping...')\n",
    "print('=' * 70)\n",
    "!unzip -j 'Training-Data/Rock-Piano-Training-Data.zip'\n",
    "\n",
    "!cat Model/Rock-Piano-Trained-Model.zip* > Rock-Piano-Trained-Model.zip\n",
    "print('=' * 70)\n",
    "\n",
    "!unzip -j Rock-Piano-Trained-Model.zip\n",
    "print('=' * 70)\n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce331ec9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Load/Reload the model\n",
    "full_path_to_model_checkpoint = \"Rock-Piano-Trained-Model.pth\" #@param {type:\"string\"}\n",
    "\n",
    "print('Loading the model...')\n",
    "config = GPTConfig(VOCAB_SIZE, \n",
    "                   max_seq,\n",
    "                   dim_feedforward=dim_feedforward,\n",
    "                   n_layer=6, \n",
    "                   n_head=8, \n",
    "                   n_embd=512,\n",
    "                   enable_rpr=True,\n",
    "                   er_len=max_seq)\n",
    "\n",
    "model = GPT(config).to(get_device())\n",
    "\n",
    "model.load_state_dict(torch.load(full_path_to_model_checkpoint))\n",
    "model.eval()\n",
    "\n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab1259f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the Training Data for priming the model\n",
    "\n",
    "# Re-running this code will owerwrite the continuation code below\n",
    "\n",
    "# Re-run this to prime from Training Data at any time\n",
    "\n",
    "inputs = []\n",
    "\n",
    "song_ints = []\n",
    "\n",
    "data = TMIDIX.Tegridy_Any_Pickle_File_Reader('Rock-Piano-Training-Data')\n",
    "\n",
    "\n",
    "pe = data[0]\n",
    "for d in tqdm(data):\n",
    "    song_ints.extend([d[3], int(abs(d[1] - pe[1]) / 10), d[4], int(d[2] / 10), 500])\n",
    "    pe = d\n",
    "    \n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07aa3a0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this code to prime with your own custom MIDI\n",
    "\n",
    "# MIDI MUST HAVE ONLY PIANO-DRUMS instruments or it may not continue the composition properly\n",
    "\n",
    "print('Loading your custom MIDI...')\n",
    "\n",
    "data = TMIDIX.Optimus_MIDI_TXT_Processor('Rock-Piano-Continuation-Seed-1.mid', \n",
    "                                         MIDI_channel=16, \n",
    "                                         musenet_encoding=True, \n",
    "                                         perfect_timings=True)\n",
    "\n",
    "\n",
    "pe = data[2][0]\n",
    "for d in tqdm(data[2]):\n",
    "    inputs.extend([d[3], int(abs(d[1] - pe[1]) / 10), d[4], int(d[2] / 10), 500])\n",
    "    pe = d\n",
    " \n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce761d95",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Generate Music\n",
    "\n",
    "number_of_tokens_to_generate = 1024 #@param {type:\"slider\", min:8, max:1024, step:8}\n",
    "use_random_primer = False #@param {type:\"boolean\"}\n",
    "number_of_ticks_per_quarter = 500 #@param {type:\"slider\", min:50, max:1000, step:50}\n",
    "dataset_time_denominator = 10\n",
    "melody_conditioned_encoding = False\n",
    "encoding_has_MIDI_channels = False \n",
    "encoding_has_velocities = False\n",
    "simulate_velocity = True #@param {type:\"boolean\"}\n",
    "save_only_first_composition = True\n",
    "\n",
    "fname = 'Rock-Piano-Composition'\n",
    "\n",
    "print('Rock Piano Model Generator')\n",
    "\n",
    "output_signature = 'Rock Piano'\n",
    "song_name = 'RGA Composition'\n",
    "\n",
    "if use_random_primer:\n",
    "    sequence = [random.randint(10, 500) for i in range(64)]\n",
    "    idx = secrets.randbelow(len(sequence))\n",
    "    rand_seq = model.generate(torch.Tensor(sequence[idx:idx+120]), target_seq_length=number_of_tokens_to_generate)\n",
    "    out = rand_seq[0].cpu().numpy().tolist()\n",
    "\n",
    "else:\n",
    "    out = []\n",
    "  \n",
    "    try:\n",
    "        if len(inputs) > 0:\n",
    "          rand_seq = model.generate(torch.Tensor(inputs[-128:]), target_seq_length=number_of_tokens_to_generate)\n",
    "          out = rand_seq[0].cpu().numpy().tolist()\n",
    "        else:\n",
    "          idx = secrets.randbelow(len(song_ints))\n",
    "          rand_seq = model.generate(torch.Tensor(song_ints[idx:idx+120]), target_seq_length=number_of_tokens_to_generate)\n",
    "          out = rand_seq[0].cpu().numpy().tolist()\n",
    "  \n",
    "    except:\n",
    "        print('=' * 50)\n",
    "        print('Error! Try random priming instead!')\n",
    "        print('Shutting down...')\n",
    "        print('=' * 50)\n",
    "\n",
    "if len(out) != 0:\n",
    "    song = []\n",
    "    sng = []\n",
    "    for o in out:\n",
    "        if o != 500:\n",
    "          sng.append(o)\n",
    "        else:\n",
    "          if len(sng) == 4:\n",
    "            song.append(sng)\n",
    "          sng = []\n",
    "\n",
    "    char_offset = 0\n",
    "    song_f = []\n",
    "    time = 0\n",
    "    for s in song:\n",
    "    \n",
    "        song_f.append(['note', (abs(time)) * 10, (s[3]-char_offset) * 10, s[0]-char_offset, s[2]-char_offset, s[2]-char_offset])\n",
    "        time += (s[1] - char_offset)\n",
    "    \n",
    "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
    "                                                        output_signature = output_signature,  \n",
    "                                                        output_file_name = fname, \n",
    "                                                        track_name=song_name, \n",
    "                                                        number_of_ticks_per_quarter=number_of_ticks_per_quarter)\n",
    "\n",
    "    print('Done!')\n",
    "\n",
    "    #print('Downloading your composition now...')\n",
    "    #from google.colab import files\n",
    "    #files.download(fname + '.mid')\n",
    "\n",
    "    print('=' * 70)\n",
    "    print('Detailed MIDI stats:')\n",
    "    for key, value in detailed_stats.items():\n",
    "        print('=' * 70)\n",
    "        print(key, '|', value)\n",
    "\n",
    "    print('=' * 70)\n",
    "\n",
    "else:\n",
    "  print('Models output is empty! Check the code...')\n",
    "  print('Shutting down...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c37ced16",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Auto-Regressive Generator\n",
    "\n",
    "#@markdown NOTE: You much generate a seed composition first or it is not going to start\n",
    "\n",
    "number_of_cycles_to_run = 10 #@param {type:\"slider\", min:1, max:50, step:1}\n",
    "number_of_prime_tokens = 128 #@param {type:\"slider\", min:64, max:256, step:64}\n",
    "\n",
    "print('=' * 70)\n",
    "print('Rock Piano Auto-Regressive Model Generator')\n",
    "print('=' * 70)\n",
    "print('Starting up...')\n",
    "print('=' * 70)\n",
    "print('Prime length:', len(out))\n",
    "print('Prime tokens:', number_of_prime_tokens)\n",
    "print('Prime input sequence', out[-8:])\n",
    "\n",
    "if len(out) != 0:\n",
    "  print('=' * 70)\n",
    "  out_all = []\n",
    "  out_all.append(out)\n",
    "  for i in tqdm(range(number_of_cycles_to_run)):\n",
    "      rand_seq1 = model.generate(torch.Tensor(out[-number_of_prime_tokens:]), target_seq_length=1024)\n",
    "      out1 = rand_seq1[0].cpu().numpy().tolist()\n",
    "      out_all.append(out1[number_of_prime_tokens:])\n",
    "      out = out1[number_of_prime_tokens:]\n",
    "      \n",
    "      print(chr(10))\n",
    "      print('=' * 70)\n",
    "      print('Block number:', i+1)\n",
    "      print('Composition length so far:', (i+1) * 1024, 'tokens')\n",
    "      print('=' * 70)\n",
    "\n",
    "  print('Done!' * 70)\n",
    "  print('Total blocks:', i+1)\n",
    "  print('Final omposition length:', (i+1) * 1024, 'tokens')\n",
    "  print('=' * 70)\n",
    "  \n",
    "  out2 = []\n",
    "  for o in out_all:\n",
    "    out2.extend(o)\n",
    "\n",
    "  if len(out2) != 0:\n",
    "    song = []\n",
    "    sng = []\n",
    "    for o in out2:\n",
    "      if o != 500:\n",
    "        sng.append(o)\n",
    "      else:\n",
    "        if len(sng) == 4:\n",
    "          song.append(sng)\n",
    "        sng = []\n",
    "\n",
    "    char_offset = 0\n",
    "    song_f = []\n",
    "    time = 0\n",
    "    for s in song:\n",
    "      \n",
    "        song_f.append(['note', (abs(time)) * 10, (s[3]-char_offset) * 10, s[0]-char_offset, s[2]-char_offset, s[2]-char_offset])\n",
    "        time += (s[1] - char_offset)\n",
    "        \n",
    "    song_name = 'Auto-Regressive RGA Composition'\n",
    "\n",
    "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
    "                                                          output_signature = output_signature,  \n",
    "                                                          output_file_name = fname, \n",
    "                                                          track_name=song_name, \n",
    "                                                          number_of_ticks_per_quarter=number_of_ticks_per_quarter)\n",
    "\n",
    "    print('Done!')\n",
    "\n",
    "    #print('Downloading your composition now...')\n",
    "    #from google.colab import files\n",
    "    #files.download(fname + '.mid')\n",
    "\n",
    "    print('=' * 70)\n",
    "    print('Detailed MIDI stats:')\n",
    "    for key, value in detailed_stats.items():\n",
    "          print('=' * 70)\n",
    "          print(key, '|', value)\n",
    "\n",
    "    print('=' * 70)\n",
    "\n",
    "else:\n",
    "  print('=' * 70)\n",
    "  print('INPUT ERROR !!!')\n",
    "  print('Prime sequence is empty...')\n",
    "  print('Please generate prime sequence and retry')\n",
    "\n",
    "print('=' * 70)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04fd51b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rather crude Piano-conditioned Drums generator\n",
    "\n",
    "print('Rock Piano Model Generator')\n",
    "print('Project Los Angeles')\n",
    "print('Tegridy Code 2021')\n",
    "\n",
    "source_MIDI_file = 'Rock-Piano-Continuation-Seed-1.mid' # soutce MIDI file\n",
    "\n",
    "fname = 'Rock-Piano-Composition'\n",
    "output_signature = 'Rock Piano'\n",
    "song_name = 'RGA Composition'\n",
    "\n",
    "#===================================\n",
    "\n",
    "def split_list(test_list):\n",
    "  \n",
    "    # using list comprehension + zip() + slicing + enumerate()\n",
    "    # Split list into lists by particular value\n",
    "    size = len(test_list)\n",
    "    idx_list = [idx + 1 for idx, val in\n",
    "                enumerate(test_list) if val == 500]\n",
    "\n",
    "\n",
    "    res = [test_list[i: j] for i, j in\n",
    "            zip([0] + idx_list, idx_list + \n",
    "            ([size] if idx_list[-1] != size else []))]\n",
    "  \n",
    "    # print result\n",
    "    # print(\"The list after splitting by a value : \" + str(res))\n",
    "    \n",
    "    return res\n",
    "\n",
    "#====================================\n",
    "\n",
    "# print('Loading MIDI file...')\n",
    "\n",
    "mel_crd_f = []\n",
    "score = TMIDIX.midi2ms_score(open(source_MIDI_file, 'rb').read())\n",
    "\n",
    "events_matrix = []\n",
    "itrack = 1\n",
    "\n",
    "while itrack < len(score):\n",
    "    for event in score[itrack]:\n",
    "        \n",
    "        if event[0] == 'note' and event[3] != 9: # reading all notes events except for the drums\n",
    "            events_matrix.append(event)\n",
    "        \n",
    "    itrack += 1\n",
    "\n",
    "#====================================\n",
    "\n",
    "events_matrix.sort()\n",
    "\n",
    "ints_f = []\n",
    "pe = events_matrix[0]\n",
    "for mm in events_matrix:\n",
    "    ints_f.append([mm[3], min(499, int(abs(mm[1]-pe[1]) / 10 )), mm[4], min(499, int(mm[2] / 10)) ])\n",
    "    pe = mm\n",
    "\n",
    "#====================================\n",
    "\n",
    "SONG = []\n",
    "\n",
    "for i in tqdm(range(len(ints_f))):\n",
    "    rand_seq1 = model.generate(torch.Tensor(ints_f[i]+[500, 9, 0]), target_seq_length=10)\n",
    "    out = rand_seq1[0].cpu().numpy().tolist()\n",
    "    SONG.extend([out[:5]])\n",
    "    SONG.extend([out[5:]])\n",
    "        \n",
    "#===================================    \n",
    "\n",
    "song_f = []\n",
    "time = SONG[0][1]\n",
    "for s in SONG:\n",
    "    song_f.append(['note', time, s[3] * 10, s[0], s[2], 90])\n",
    "    time += (s[1] * 10) \n",
    "\n",
    "ev_mat = []\n",
    "ztime = events_matrix[0][1]    \n",
    "for e in events_matrix:\n",
    "    ee = copy.deepcopy(e)\n",
    "    ee[1] = e[1] - ztime\n",
    "    ev_mat.append(ee)\n",
    "    \n",
    "SONG_f = ev_mat + [y for y in song_f if y[3] == 9]\n",
    "\n",
    "SONG_f.sort()\n",
    "        \n",
    "detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(SONG_f,\n",
    "                                                      output_signature = output_signature,  \n",
    "                                                      output_file_name = fname, \n",
    "                                                      track_name=song_name, \n",
    "                                                      number_of_ticks_per_quarter=500)\n",
    "\n",
    "print('Done!')\n",
    "\n",
    "detailed_stats"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16f5f1fb",
   "metadata": {},
   "source": [
    "# Congrats! :) You did it! :)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}