Lars_Ulrich_Challenge.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "alone-satisfaction",
   "metadata": {},
   "source": [
    "# Lars Ulrich Challenge (ver. 1.0)\n",
    "\n",
    "## \"Music comes from the heart!\" ---LU\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": "markdown",
   "id": "floppy-framing",
   "metadata": {},
   "source": [
    "# Setup Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acoustic-precipitation",
   "metadata": {},
   "source": [
    "## Clone repo and install dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "presidential-mediterranean",
   "metadata": {},
   "outputs": [],
   "source": [
    "!git clone https://github.com/Tegridy-Code/Lars-Ulrich-Challenge\n",
    "    \n",
    "!pip install torch\n",
    "!pip install tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "professional-irrigation",
   "metadata": {},
   "source": [
    "## Import all needed modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "diverse-enhancement",
   "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 auto\n",
    "\n",
    "os.chdir('Lars-Ulrich-Challenge')\n",
    "\n",
    "print('Loading TMIDIX module...')\n",
    "import TMIDIX\n",
    "print('Loading GPT2RGA module...')\n",
    "from GPT2RGA import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "increasing-heading",
   "metadata": {},
   "source": [
    "# Algorithmic Drums Matching"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "charming-newfoundland",
   "metadata": {},
   "source": [
    "## Load Clean MIDI Pitches-Drums Database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "threatened-spirituality",
   "metadata": {},
   "outputs": [],
   "source": [
    "notes, drums = TMIDIX.Tegridy_Any_Pickle_File_Reader('clean_midi_PDM')\n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "broad-columbia",
   "metadata": {},
   "source": [
    "## Generate Drums from the Database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "macro-emission",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Lars Ulrich Challenge Algorithmic Drums Generator')\n",
    "print('Project Los Angeles')\n",
    "print('Tegridy Code 2021')\n",
    "\n",
    "source_MIDI_file = 'Nothing Else Matters.mid'\n",
    "pass_through_MIDI = True # Pass-through or not all MIDI events\n",
    "\n",
    "# print('Loading MIDI file...')\n",
    "mel_crd_f = []\n",
    "\n",
    "score = TMIDIX.midi2score(open(source_MIDI_file, 'rb').read())\n",
    "\n",
    "all_events_matrix = []\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:\n",
    "            events_matrix.append(event)\n",
    "            \n",
    "        if event[0] == 'note' and event[3] == 9:\n",
    "            pass\n",
    "        else:\n",
    "            all_events_matrix.append(event)\n",
    "        \n",
    "    itrack += 1\n",
    "    \n",
    "# print('Grouping by start time. This will take a while...')\n",
    "values = set(map(lambda x:x[1], events_matrix)) # Non-multithreaded function version just in case\n",
    "\n",
    "groups = [[y for y in events_matrix if y[1]==x] for x in values] # Grouping notes into chords while discarting bad notes...\n",
    "\n",
    "mel_crd = []    \n",
    "\n",
    "# print('Sorting events...')\n",
    "for items in groups:\n",
    "\n",
    "    items.sort(reverse=True, key=lambda x: x[4]) # Sorting events by pitch\n",
    "\n",
    "    mel_crd.append(items) # Creating final chords list\n",
    "\n",
    "mel_crd.sort(reverse=False, key=lambda x: x[0][1])\n",
    "\n",
    "mel_crd_f.extend(mel_crd)\n",
    "\n",
    "src_pitches = []\n",
    "\n",
    "for m in mel_crd_f:\n",
    "    src = [y[4] for y in m]\n",
    "    src_pitches.append(src)\n",
    "    \n",
    "final_song = []\n",
    "\n",
    "drums_map = []\n",
    "\n",
    "for i in tqdm(range(len(src_pitches))):\n",
    "    try:\n",
    "        idx = notes.index(src_pitches[i])\n",
    "    except:\n",
    "        idx = -1\n",
    "        # print('not in list')\n",
    "        pass\n",
    "    final_song.extend(mel_crd_f[i])\n",
    "    \n",
    "    if idx != -1:\n",
    "        for d in drums[idx]:\n",
    "            # if d < 40:\n",
    "            drum = [['note', mel_crd_f[i][0][1], mel_crd_f[i][0][2], 9, d, 100 ]]\n",
    "            final_song.extend(drum)\n",
    "            drums_map.extend(drum)\n",
    "            \n",
    "        idx = -1\n",
    "\n",
    "if pass_through_MIDI:\n",
    "    \n",
    "    output =  all_events_matrix + drums_map\n",
    "    \n",
    "    output.sort(key=lambda x: x[1])\n",
    "    \n",
    "    midi_data = TMIDIX.score2midi([score[0], output,\n",
    "                                    [['track_name', 0, bytes('Project Los Angeles', 'utf-8')]],\n",
    "                                    [['track_name', 0, bytes('Lars Ulrich Challenge', 'utf-8')]]])\n",
    "\n",
    "    detailed_MIDI_stats = TMIDIX.score2stats([score[0], output,\n",
    "                                                [['track_name', 0, bytes('Project Los Angeles', 'utf-8')]],\n",
    "                                                [['track_name', 0, bytes('Lars Ulrich Challenge', 'utf-8')]]])\n",
    "\n",
    "    with open('./LUC-Algorithmic-Composition' + '.mid', 'wb') as midi_file:\n",
    "        midi_file.write(midi_data)\n",
    "        midi_file.close()\n",
    "    \n",
    "    print('Done! Enjoy! :)')\n",
    "    \n",
    "    print(detailed_MIDI_stats)\n",
    "    \n",
    "else:             \n",
    "    TMIDIX.Tegridy_SONG_to_MIDI_Converter(final_song, \n",
    "                                          output_file_name='./LUC-Algorithmic-Composition',\n",
    "                                          output_signature = 'Project Los Angeles', \n",
    "                                          track_name = 'Lars Ulrich Challenge',\n",
    "                                          number_of_ticks_per_quarter=score[0],\n",
    "                                          list_of_MIDI_patches = [0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 0, 0, 0, 0, 0, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "broken-mystery",
   "metadata": {},
   "source": [
    "# Artificial Intelligence Drums Matching"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "changed-convenience",
   "metadata": {},
   "source": [
    "## Unzip the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "innovative-divide",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('=' * 70)\n",
    "print('Unzipping the model...Please wait...')\n",
    "print('=' * 70)\n",
    "\n",
    "!cat Clean-MIDI-Transformer-Model.zip* > Clean-MIDI-Transformer-Model.zip\n",
    "print('=' * 70)\n",
    "\n",
    "!unzip -j Clean-MIDI-Transformer-Model.zip\n",
    "print('=' * 70)\n",
    "\n",
    "print('Done! Enjoy! :)')\n",
    "print('=' * 70)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "architectural-nicaragua",
   "metadata": {},
   "source": [
    "## Load Clean MIDI Transformer Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aboriginal-invite",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Load/Reload the model\n",
    "full_path_to_model_checkpoint = 'Clean-MIDI-Transformer-Model.pth'\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",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "looking-affiliation",
   "metadata": {},
   "source": [
    "## Generate Drums from the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "plain-correspondence",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Lars Ulrich Challenge Model Generator')\n",
    "print('Project Los Angeles')\n",
    "print('Tegridy Code 2021')\n",
    "\n",
    "source_MIDI_file = 'Nothing Else Matters.mid' # soutce MIDI file\n",
    "memory_tokens = 64 # recommended 32-64\n",
    "pass_through_MIDI = True # Pass-through or not all MIDI events\n",
    "\n",
    "# print('Loading MIDI file...')\n",
    "\n",
    "mel_crd_f = []\n",
    "score = TMIDIX.midi2score(open(source_MIDI_file, 'rb').read())\n",
    "\n",
    "all_events_matrix = []\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",
    "        if event[0] == 'note' and event[3] == 9:\n",
    "            pass\n",
    "        else:\n",
    "            all_events_matrix.append(event)\n",
    "        \n",
    "    itrack += 1\n",
    "    \n",
    "# print('Grouping by start time. This will take a while...')\n",
    "values = set(map(lambda x:x[1], events_matrix)) # Non-multithreaded function version just in case\n",
    "\n",
    "groups = [[y for y in events_matrix if y[1]==x] for x in values] # Grouping notes into chords while discarting bad notes...\n",
    "\n",
    "mel_crd = []    \n",
    "\n",
    "# print('Sorting events...')\n",
    "for items in groups:\n",
    "\n",
    "    items.sort(reverse=True, key=lambda x: x[4]) # Sorting events by pitch\n",
    "\n",
    "    mel_crd.append(items) # Creating final chords list\n",
    "\n",
    "mel_crd.sort(reverse=False, key=lambda x: x[0][1])\n",
    "\n",
    "mel_crd_f.extend(mel_crd)\n",
    "\n",
    "src_pitches = []\n",
    "\n",
    "for m in mel_crd_f:\n",
    "    src = [y[4] for y in m]\n",
    "    src_pitches.append(src)\n",
    "    \n",
    "final_song = []\n",
    "out = [0]\n",
    "\n",
    "# print('Generating drums...')\n",
    "drums_map = []\n",
    "\n",
    "for i in tqdm(range(len(src_pitches))):\n",
    "#for i in tqdm([0]):\n",
    "    \n",
    "    \n",
    "    final_song.extend(mel_crd_f[i])\n",
    "    if memory_tokens > 0:\n",
    "        number_of_tokens_to_generate = memory_tokens+32\n",
    "        data = out[-memory_tokens:] + [388] + src_pitches[i] + [128]\n",
    "    else:\n",
    "        number_of_tokens_to_generate = 32\n",
    "        data = [388] + src_pitches[i] + [128]\n",
    "        \n",
    "    rand_seq = model.generate(torch.Tensor(data), target_seq_length=number_of_tokens_to_generate, stop_token=128)\n",
    "    out = rand_seq[0].cpu().numpy().tolist()\n",
    "    out_cc = out[out.index(128, len(data)-1)+1:]\n",
    "\n",
    "    for d in out_cc:\n",
    "        drum = [['note', mel_crd_f[i][0][1], mel_crd_f[i][0][2], 9, d, 100 ]]\n",
    "        final_song.extend(drum)\n",
    "        drums_map.extend(drum)\n",
    "        \n",
    "print('Writing MIDI...')\n",
    "\n",
    "if pass_through_MIDI:\n",
    "    \n",
    "    output =  all_events_matrix + drums_map\n",
    "    \n",
    "    output.sort(key=lambda x: x[1])\n",
    "    \n",
    "    midi_data = TMIDIX.score2midi([score[0], output,\n",
    "                                    [['track_name', 0, bytes('Project Los Angeles', 'utf-8')]],\n",
    "                                    [['track_name', 0, bytes('Lars Ulrich Challenge', 'utf-8')]]])\n",
    "\n",
    "    detailed_MIDI_stats = TMIDIX.score2stats([score[0], output,\n",
    "                                                [['track_name', 0, bytes('Project Los Angeles', 'utf-8')]],\n",
    "                                                [['track_name', 0, bytes('Lars Ulrich Challenge', 'utf-8')]]])\n",
    "    \n",
    "    with open('./LUC-Artificial-Intelligence-Composition' + '.mid', 'wb') as midi_file:\n",
    "        midi_file.write(midi_data)\n",
    "        midi_file.close()\n",
    "    \n",
    "    print('Done! Enjoy! :)')\n",
    "    \n",
    "    print(detailed_MIDI_stats)\n",
    "    \n",
    "else:    \n",
    "    TMIDIX.Tegridy_SONG_to_MIDI_Converter(final_song, \n",
    "                                          output_file_name='./LUC-Artificial-Intelligence-Composition',\n",
    "                                          output_signature = 'Project Los Angeles',\n",
    "                                          track_name = 'Lars Ulrich Challenge',\n",
    "                                          number_of_ticks_per_quarter=score[0],\n",
    "                                          list_of_MIDI_patches = [0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 0, 0, 0, 0, 0, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hawaiian-italic",
   "metadata": {},
   "source": [
    "# Congrats! You did it! :)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}