Intelligent_VIRTUOSO.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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"
    },
    "colab": {
      "name": "Intelligent-VIRTUOSO.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/asigalov61/Intelligent-VIRTUOSO/blob/main/Intelligent_VIRTUOSO.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QA0W-VK1JVQl"
      },
      "source": [
        "# Intelligent VIRTUOSO (ver. 1.3)\n",
        "\n",
        "## \"Music never allows falsehoods for even the deaf hear flat notes!\" ---IV\n",
        "\n",
        "***\n",
        "\n",
        "## Chordified GPT2-based Symbolic Music Artificial Intelligence Model Creator/Trainer.\n",
        "\n",
        "### Multi-Instrumental, with special TMIDI Processors\n",
        "\n",
        "***\n",
        "\n",
        "Credit for char-based GPT2 implementation used in this colab goes out to Andrej Karpathy: https://github.com/karpathy/minGPT\n",
        "\n",
        "***\n",
        "\n",
        "WARNING: This complete implementation is a functioning model of the Artificial Intelligence. Please excercise great humility, care, and respect.\n",
        "\n",
        "***\n",
        "\n",
        "#### Project Los Angeles\n",
        "\n",
        "#### Tegridy Code 2020\n",
        "\n",
        "***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eftzIVKrqR5S"
      },
      "source": [
        "# Setup Environment, clone needed repos, and install all required dependencies"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HsUtsJGNz6f2",
        "cellView": "form"
      },
      "source": [
        "#@title Install all dependencies (run only once per session)\n",
        "!git clone https://github.com/asigalov61/minGPT\n",
        "!git clone https://github.com/asigalov61/tegridy-tools\n",
        "!apt install fluidsynth #Pip does not work for some reason. Only apt works\n",
        "!pip install midi2audio"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pf8B3p6QySmE",
        "cellView": "form"
      },
      "source": [
        "#@title Import all needed modules\n",
        "\n",
        "print('Loading needed modules. Please wait...')\n",
        "import os\n",
        "if not os.path.exists('/content/Dataset'):\n",
        "    os.makedirs('/content/Dataset')\n",
        "\n",
        "os.chdir('/content/minGPT')\n",
        "# make deterministic\n",
        "from mingpt.utils import set_seed\n",
        "set_seed(42)\n",
        "\n",
        "import tqdm.auto\n",
        "import pickle\n",
        "import numpy as np\n",
        "import torchvision\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch import optim\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import Dataset\n",
        "\n",
        "import keras\n",
        "from keras.utils import to_categorical\n",
        "\n",
        "import time\n",
        "import math\n",
        "import datetime\n",
        "from datetime import datetime\n",
        "\n",
        "from mingpt.model import GPT, GPTConfig\n",
        "from mingpt.trainer import Trainer, TrainerConfig\n",
        "from mingpt.utils import sample\n",
        "\n",
        "os.chdir('/content/tegridy-tools/tegridy-tools')\n",
        "import TMIDI\n",
        "import MIDI\n",
        "\n",
        "import tqdm.auto\n",
        "\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "from midi2audio import FluidSynth\n",
        "from IPython.display import display, Javascript, HTML, Audio\n",
        "\n",
        "from google.colab import output, drive\n",
        "\n",
        "dtype = torch.float\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "# Assume that we are on a CUDA machine, then this should print a CUDA device:\n",
        "print('Available Processing Device is:', device)\n",
        "os.chdir('/content/')\n",
        "print('Loading complete. Enjoy! :)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N2Pv5eNRqiyr"
      },
      "source": [
        "# Upload/download and process MIDI dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "IwIULHmDgg4T"
      },
      "source": [
        "#@title (OPTION 1) Download processed TXT dataset\r\n",
        "#@markdown Based upon special Tegridy Piano MIDI dataset below\r\n",
        "\r\n",
        "#@markdown Specifically, this TXT dataset is based the Deep Relaxation Melodies from the MIDI dataset\r\n",
        "\r\n",
        "#@markdown Works best stand-alone/as-is for the optimal results\r\n",
        "%cd /content/\r\n",
        "!wget 'https://github.com/asigalov61/Intelligent-VIRTUOSO/raw/main/Intelligent-Virtuoso-Music-TXT-Dataset.zip'\r\n",
        "!unzip -j '/content/Intelligent-Virtuoso-Music-TXT-Dataset.zip'\r\n",
        "!rm '/content/Intelligent-Virtuoso-Music-TXT-Dataset.zip'\r\n",
        "%cd /content/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EHuggjW7etzZ",
        "cellView": "form"
      },
      "source": [
        "#@title (OPTION 2) Start from scratch\n",
        "#@markdown Download special Tegridy Piano MIDI dataset\n",
        "\n",
        "#@markdown Works best stand-alone/as-is for the optimal results\n",
        "%cd /content/Dataset/\n",
        "!rm *.mid \n",
        "!rm *.midi\n",
        "!wget 'https://github.com/asigalov61/Tegridy-MIDI-Dataset/raw/master/Tegridy-Piano-CC-BY-NC-SA.zip'\n",
        "!unzip -j '/content/Dataset/Tegridy-Piano-CC-BY-NC-SA.zip'\n",
        "!rm '/content/Dataset/Tegridy-Piano-CC-BY-NC-SA.zip'\n",
        "%cd /content/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-1ypXZoySkHJ"
      },
      "source": [
        "# If you are not sure where to start or what settings to select, please use original defaults"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BRy0VfpFIpaj",
        "cellView": "form"
      },
      "source": [
        "#@title Process MIDIs to special MIDI dataset with Tegridy MIDI Processor\n",
        "#@markdown NOTES:\n",
        "\n",
        "#@markdown 1) Dataset MIDI file names are used as song names. Feel free to change it to anything you like.\n",
        "\n",
        "#@markdown 2) Best results are achieved with the single-track, single-channel, single-instrument MIDI 0 files with plain English names (avoid special or sys/foreign chars)\n",
        "\n",
        "#@markdown 3) MIDI Channel = -1 means all MIDI channels. Otherwise, only single indicated MIDI channel will be processed.\n",
        "\n",
        "full_path_to_output_dataset_to = \"/content/Intelligent-Virtuoso-Music-MIDI-Dataset.data\" #@param {type:\"string\"}\n",
        "desired_MIDI_channel_to_process = 0 #@param {type:\"slider\", min:-1, max:15, step:1}\n",
        "MIDI_events_time_denominator = 100 #@param {type:\"slider\", min:1, max:200, step:1}\n",
        "debug = False #@param {type:\"boolean\"}\n",
        "\n",
        "print('TMIDI Processor')\n",
        "print('Starting up...')\n",
        "\n",
        "chords_list = []\n",
        "\n",
        "###########\n",
        "\n",
        "average_note_pitch = 0\n",
        "min_note = 127\n",
        "max_note = 0\n",
        "\n",
        "files_count = 0\n",
        "\n",
        "ev = 0\n",
        "\n",
        "chords_list_f = []\n",
        "melody_list_f = []\n",
        "\n",
        "chords_list = []\n",
        "chords_count = 0\n",
        "\n",
        "melody_chords = []\n",
        "melody_count = 0\n",
        "\n",
        "song_names = []\n",
        "\n",
        "###########\n",
        "\n",
        "def list_average(num):\n",
        "  sum_num = 0\n",
        "  for t in num:\n",
        "      sum_num = sum_num + t           \n",
        "\n",
        "  avg = sum_num / len(num)\n",
        "  return avg\n",
        "\n",
        "###########\n",
        "\n",
        "print('Loading MIDI files...')\n",
        "print('This may take a while on a large dataset in particular.')\n",
        "\n",
        "\n",
        "%cd /content/\n",
        "dataset_addr = \"/content/Dataset/\"\n",
        "os.chdir(dataset_addr)\n",
        "filez = os.listdir(dataset_addr)\n",
        "\n",
        "print('Creating list of songs from MIDI file names...')\n",
        "for f in filez: # Based on input MIDI file names w/o the extension\n",
        "  fn = os.path.basename(f)\n",
        "  fno = fn.split('.')[0]\n",
        "  song_names.append(fno)\n",
        "\n",
        "print('Processing MIDI files. Please wait...')\n",
        "for f in tqdm.auto.tqdm(filez):\n",
        "  files_count += 1\n",
        "  chords_list, melody = TMIDI.Tegridy_MIDI_Processor(f, desired_MIDI_channel_to_process, MIDI_events_time_denominator)\n",
        "\n",
        "  fn = os.path.basename(f)\n",
        "  fno = fn.split('.')[0].replace(' ', '_')\n",
        "\n",
        "  chords_l, melody_l = TMIDI.Tegridy_Chords_Converter(chords_list, melody, fno)\n",
        "  \n",
        "  chords_list_f.extend(chords_l)\n",
        "  melody_list_f.extend(melody_l)\n",
        "  chords_count += len(chords_l)\n",
        "  melody_count += len(melody_l)\n",
        "\n",
        "average_note_pitch = int((min_note + max_note) / 2)\n",
        "\n",
        "print('Task complete :)')\n",
        "print('==================================================')\n",
        "print('Number of processed dataset MIDI files:', files_count)\n",
        "print('Average note pitch =', average_note_pitch)\n",
        "#print('Min note pitch =', min_note)\n",
        "#print('Max note pitch =', max_note)\n",
        "#print('Number of MIDI events recorded:', len(events_matrix))\n",
        "print('Number of MIDI chords recorded:', chords_count)\n",
        "print('The longest chord:', len(max(chords_list_f, key=len)), 'notes') \n",
        "print(max(chords_list_f, key=len))\n",
        "print('Number of recorded melody events:', len(melody_list_f))\n",
        "print('First melody event:', melody_list_f[0], 'Last Melody event:', melody_list_f[-1])\n",
        "print('Total number of MIDI events recorded:', len(chords_list_f))\n",
        "# Dataset\n",
        "MusicDataset = [chords_list_f, melody_list_f]\n",
        "\n",
        "with open(full_path_to_output_dataset_to, 'wb') as filehandle:\n",
        "    # store the data as binary data stream\n",
        "    pickle.dump(MusicDataset, filehandle)\n",
        "print('Dataset was saved at:', full_path_to_output_dataset_to)\n",
        "\n",
        "# MIDI/files stats code from the previous version.\n",
        "\n",
        "print('Task complete. Enjoy! :)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A378EUz_7K0G",
        "cellView": "form"
      },
      "source": [
        "#@title Process MIDI Dataset to TXT Dataset (w/Tegridy MIDI-TXT Processor)\n",
        "#@markdown Output file is a plain UTF-8 TXT file, readable by any TXT application. On Windows you can open it even with the Notepad.\n",
        "#@markdown line_by_line_dataset option is for creating new types of IV datasets. Useful for AI BPE tokenizers.\n",
        "full_path_to_TXT_dataset = \"/content/Intelligent-Virtuoso-Music-TXT-Dataset.txt\" #@param {type:\"string\"}\n",
        "line_by_line_dataset = True #@param {type:\"boolean\"}\n",
        "simulate_velocity = True #@param {type:\"boolean\"}\n",
        "\n",
        "# MIDI Dataset to txt dataset converter \n",
        "print('TMIDI-TXT Processor')\n",
        "print('Starting up...')\n",
        "if os.path.exists(full_path_to_TXT_dataset):\n",
        "  os.remove(full_path_to_TXT_dataset)\n",
        "  print('Removing old Dataset...')\n",
        "else:\n",
        "  print(\"Creating new Dataset file...\")\n",
        "if simulate_velocity:\n",
        "  print('Simulated velocity mode is enabled.')\n",
        "\n",
        "TXT = ''\n",
        "number_of_chords = 0\n",
        "number_of_bad_chords = 0\n",
        "dataset_name = 'DATASET=Intelligent_VIRTUOSO_TXT_Music_Dataset'\n",
        "\n",
        "file = open(full_path_to_TXT_dataset, 'a')\n",
        "TXT, number_of_chords, number_of_bad_chords = TMIDI.Tegridy_MIDI_TXT_Processor(dataset_name, \n",
        "                                                                               chords_list_f, \n",
        "                                                                               melody_list_f, \n",
        "                                                                               simulate_velocity, \n",
        "                                                                               line_by_line_dataset)\n",
        "file.write(TXT)\n",
        "file.close()\n",
        "print('Number of chords recorded: ', number_of_chords)\n",
        "print('Number of bad/skipped chords: ', number_of_bad_chords)\n",
        "print('Done!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0cj2xl5xqwea"
      },
      "source": [
        "# Setup and Intialize the Model\r\n",
        "\r\n",
        "## YOU MUST RUN ALL CELLS/CODE IN THIS SECTION to init the model. Does not matter if the model is empty or pre-trained.\r\n",
        "\r\n",
        "## DO NOT EXECUTE TRAIN CELL/CODE UNLESS YOU INTEND TO TRAIN FROM SCRATCH"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z1MQDOVMySmJ",
        "cellView": "form"
      },
      "source": [
        "#@title Setup functions and procedures\n",
        "model_attention_span_in_tokens = 768 #@param {type:\"slider\", min:0, max:1024, step:16}\n",
        "\n",
        "class CharDataset(Dataset):\n",
        "\n",
        "    def __init__(self, data, block_size):\n",
        "        chars = sorted(list(set(data)))\n",
        "        data_size, vocab_size = len(data), len(chars)\n",
        "        print('data has %d characters, %d unique.' % (data_size, vocab_size))\n",
        "        \n",
        "        self.stoi = { ch:i for i,ch in enumerate(chars) }\n",
        "        self.itos = { i:ch for i,ch in enumerate(chars) }\n",
        "        self.block_size = block_size\n",
        "        self.vocab_size = vocab_size\n",
        "        self.data = data\n",
        "    \n",
        "    def __len__(self):\n",
        "        return len(self.data) - self.block_size\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        # grab a chunk of (block_size + 1) characters from the data\n",
        "        chunk = self.data[idx:idx + self.block_size + 1]\n",
        "        # encode every character to an integer\n",
        "        dix = [self.stoi[s] for s in chunk]\n",
        "        \n",
        "        x = torch.tensor(dix[:-1], dtype=torch.long)\n",
        "        y = torch.tensor(dix[1:], dtype=torch.long)\n",
        "        return x, y\n",
        "\n",
        "        \n",
        "block_size = model_attention_span_in_tokens # spatial extent of the model for its context"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m4QIgbe3ySmN",
        "cellView": "form"
      },
      "source": [
        "#@title Specify full path to the processed TMIDI-TXT dataset file\n",
        "full_path_to_training_text_file = \"/content/Intelligent-Virtuoso-Music-TXT-Dataset.txt\" #@param {type:\"string\"}\n",
        "text = open(full_path_to_training_text_file, 'r').read() # don't worry we won't run out of file handles\n",
        "train_dataset = CharDataset(text, block_size) # one line of poem is roughly 50 characters"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bpNxwzNkySmQ",
        "cellView": "form"
      },
      "source": [
        "#@title Create GPT2 model\n",
        "model_embed_size = 256 #@param {type:\"slider\", min:0, max:1024, step:64}\n",
        "number_of_heads = 16 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "number_of_layers = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "\n",
        "\n",
        "mconf = GPTConfig(train_dataset.vocab_size, \n",
        "                  train_dataset.block_size,\n",
        "                  n_layer=number_of_layers, \n",
        "                  n_head=number_of_heads, \n",
        "                  n_embd=model_embed_size)\n",
        "\n",
        "model = GPT(mconf)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BWaOS0sRySmS",
        "cellView": "form"
      },
      "source": [
        "#@title Setup all training parameters\n",
        "number_of_training_epochs = 1 #@param {type:\"slider\", min:1, max:5, step:1}\n",
        "training_batch_size = 24 #@param {type:\"slider\", min:0, max:160, step:4}\n",
        "model_learning_rate = 6e-4 #@param {type:\"number\"}\n",
        "# initialize a trainer instance and kick off training\n",
        "\n",
        "tconf = TrainerConfig(max_epochs=number_of_training_epochs, \n",
        "                      batch_size=training_batch_size, \n",
        "                      learning_rate=model_learning_rate,\n",
        "                      num_workers=4)\n",
        "trainer = Trainer(model, train_dataset, None, tconf)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B_18H-M-q4CB"
      },
      "source": [
        "# Train the model or Load/Re-load the existing pre-trained model checkpoint"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cRffqT9WFBHB",
        "cellView": "form"
      },
      "source": [
        "#@title (OPTION 1) Train the model\n",
        "%cd /content/\n",
        "trainer.train()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YVWEhUj1cg7N",
        "cellView": "form"
      },
      "source": [
        "#@title Plot Positional Embeddings\n",
        "\n",
        "# visualize some of the learned positional embeddings, maybe they contain structure\n",
        "plt.figure(figsize=(18, 1))  \n",
        "ci = model.pos_emb.data[0, :, 0].cpu()\n",
        "zci = torch.cat((torch.tensor([0.0]), ci)) # pre-cat a zero\n",
        "plt.imshow(zci.view(1, block_size+1).numpy())\n",
        "plt.axis('off')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pMkyEMghC-KR",
        "cellView": "form"
      },
      "source": [
        "#@title Save/Re-Save the model from memory\n",
        "#@markdown Standard PyTorch AI models file extension is PTH\n",
        "full_path_to_save_model_to = \"/content/Intelligent-Virtuoso-Trained-Model.pth\" #@param {type:\"string\"}\n",
        "%cd /content/\n",
        "torch.save(model, full_path_to_save_model_to)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CmD7VRZhDcnJ",
        "cellView": "form"
      },
      "source": [
        "#@title (OPTION 2) Load existing model/checkpoint\n",
        "full_path_to_model_checkpoint = \"/content/Intelligent-Virtuoso-Trained-Model.pth\" #@param {type:\"string\"}\n",
        "model = torch.load(full_path_to_model_checkpoint)\n",
        "model.eval()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FfgeQl8_rEox"
      },
      "source": [
        "# Generate, download, plot, and listen to the output"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ZEqKJ6NySmV",
        "cellView": "form"
      },
      "source": [
        "#@title Generate and download the composition as TXT file.\n",
        "#@markdown PLEASE NOTE IMPORTANT POINTS: \n",
        "\n",
        "#@markdown 0) If you are not sure where to start/what settings to set, please use original defaults.\n",
        "\n",
        "#@markdown 1) Model primes from the dataset !!!\n",
        "\n",
        "#@markdown 2) Model's first output may be empty or garbled so please try several times before discarting the model\n",
        "\n",
        "#@markdown 3) You can now communicate to the model desired length of the output composition by suffixing input_prompt with number of chords.\n",
        "\n",
        "#@markdown I.e. SONG=Relax_with_900_Chords\n",
        "\n",
        "#@markdown 3) Coherence of GPT2 Models is inversly proportional to the length of the generated composition, so the best resutls are achieved with shorter compositions and/or continuation routines use (which be implemented in the future version of Intelligent VIRTUOSO)\n",
        "\n",
        "print('Intelligent VIRTUOSO Model Generator')\n",
        "print('Starting up...')\n",
        "number_of_tokens_to_generate = 32768 #@param {type:\"slider\", min:0, max:32768, step:128}\n",
        "creativity_temperature = 0.8 #@param {type:\"slider\", min:0.05, max:4, step:0.05}\n",
        "top_k_prob = 16 #@param {type:\"slider\", min:0, max:50, step:1}\n",
        "input_prompt = \"SONG=Deep\" #@param {type:\"string\"}\n",
        "debug = False #@param {type:\"boolean\"}\n",
        "\n",
        "os.chdir('/content/')\n",
        "\n",
        "model.to(device)\n",
        "\n",
        "context = input_prompt\n",
        "x = torch.tensor([train_dataset.stoi[s] for s in context], dtype=torch.long)[None,...].to(trainer.device)\n",
        "y = sample(model, x, number_of_tokens_to_generate, temperature=creativity_temperature, sample=True, top_k=top_k_prob)[0]\n",
        "completion = ''.join([train_dataset.itos[int(i)] for i in y])\n",
        "\n",
        "''' #You can also try auto-regressive sampling on the output \n",
        "#but it does not show any improvements cuz its essentially one model canibalizing itself. :(\n",
        "\n",
        "context = input_prompt\n",
        "x = torch.tensor([train_dataset.stoi[s] for s in context], dtype=torch.long)[None,...].to(trainer.device)\n",
        "\n",
        "for i in range(10):\n",
        "  context = completion\n",
        "  x = torch.tensor([train_dataset.stoi[s] for s in context], dtype=torch.long)[None,...].to(trainer.device)\n",
        "  y = sample(model, x, number_of_tokens_to_generate, temperature=creativity_temperature, sample=True, top_k=top_k_prob)[0]\n",
        "  completion = ''.join([train_dataset.itos[int(i)] for i in y])'''\n",
        "\n",
        "# Stuff for datetime stamp\n",
        "now = ''\n",
        "now_n = str(datetime.now())\n",
        "now_n = now_n.replace(' ', '_')\n",
        "now_n = now_n.replace(':', '_')\n",
        "now = now_n.replace('.', '_')\n",
        "    \n",
        "fname = '/content/Intelligent-VIRTUOSO-Composition-' + 'generated-on-' + str(now) \n",
        "\n",
        "\n",
        "print('Done!')\n",
        "print('Saving to', str(fname + '.txt'))\n",
        "with open(fname + '.txt', \"w\") as text_file:\n",
        "    print(completion, file=text_file)\n",
        "\n",
        "print('Downloading TXT file...')\n",
        "from google.colab import files\n",
        "files.download(fname + '.txt')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "22qDcd4NO2bs",
        "cellView": "form"
      },
      "source": [
        "#@title Convert to MIDI from TXT (w/Tegridy MIDI-TXT Processor)\n",
        "\n",
        "#@markdown NOTE: For now, only the first generated performance is recorded as MIDI.\n",
        "#@markdown The rest of generated output sequence is only recorded in the generated TXT file.\n",
        "#@markdown Therefore, please check TXT file for other/better sequences that might've been generated.\n",
        "\n",
        "#@markdown Standard MIDI timings are 400/120(80)\n",
        "\n",
        "#@markdown dataset_MIDI_events_time_denominator MUST MATCH with the dataset's denominator!!!\n",
        "\n",
        "#@markdown Silence offset is model specific and usually the same so most likely it will need to be set up only once. Otherwise, please play with the settings utill you will find the right ones for your particular model.\n",
        "\n",
        "#@markdown line_by_line_dataset option is for support of legacy datasets (IV 1.0-1.1). From now on IV will be using new line-by-line datasets for compatibility with AI BPE tokenizers.\n",
        "\n",
        "line_by_line_dataset = True #@param {type:\"boolean\"}\n",
        "dataset_MIDI_events_time_denominator = 100 #@param {type:\"slider\", min:1, max:200, step:1}\n",
        "number_of_ticks_per_quarter = 425 #@param {type:\"slider\", min:1, max:1000, step:8}\n",
        "start_from_this_generated_event = 0 #@param {type:\"slider\", min:0, max:100, step:1}\n",
        "remove_generated_silence_if_needed = False #@param {type:\"boolean\"}\n",
        "silence_offset_from_start = 75000 #@param {type:\"integer\"}\n",
        "simulate_velocity = False #@param {type:\"boolean\"}\n",
        "\n",
        "song_score = []\n",
        "n = 0\n",
        "z = 0\n",
        "detailed_stats = 0\n",
        "\n",
        "with open(str(fname + '.txt'), 'r') as file:\n",
        "    input=file.read()\n",
        "\n",
        "output_signature = 'Intelligent VIRTUOSO'\n",
        "\n",
        "midi_data, n, z, detailed_stats = TMIDI.Tegridy_TXT_MIDI_Processor(input,\n",
        "                                             line_by_line_dataset,\n",
        "                                             dataset_MIDI_events_time_denominator,\n",
        "                                             number_of_ticks_per_quarter,\n",
        "                                             start_from_this_generated_event,\n",
        "                                             remove_generated_silence_if_needed,\n",
        "                                             silence_offset_from_start,\n",
        "                                             simulate_velocity,\n",
        "                                             output_signature)                         \n",
        "\n",
        "with open(fname + '.mid', 'wb') as midi_file:\n",
        "    midi_file.write(midi_data)\n",
        "    midi_file.close()\n",
        "print('Done!')\n",
        "\n",
        "from google.colab import files\n",
        "files.download(fname + '.mid')\n",
        "print('Detailed MIDI stats:')\n",
        "detailed_stats"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kILhoHR7JmmS",
        "cellView": "form"
      },
      "source": [
        "#@title Listen to the last generated composition\n",
        "#@markdown NOTE: May be very slow with the long compositions\n",
        "print('Synthesizing the last output MIDI. Please stand-by... ')\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "Audio(str(fname + '.wav'), rate=16000)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Snu3fb4N-Nd"
      },
      "source": [
        "## Congrats! :) You did it :)"
      ]
    }
  ]
}