Upload 4 files

MIDI_Images_Solo_Piano_Dataset_Maker.ipynb

@@ -0,0 +1,492 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "private_outputs": true,
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# MIDI Images Solo Piano Dataset Maker (ver. 1.0)\n",
+        "\n",
+        "***\n",
+        "\n",
+        "Powered by tegridy-tools: https://github.com/asigalov61/tegridy-tools\n",
+        "\n",
+        "***\n",
+        "\n",
+        "#### Project Los Angeles\n",
+        "\n",
+        "#### Tegridy Code 2024\n",
+        "\n",
+        "***"
+      ],
+      "metadata": {
+        "id": "LUgrspEA-68o"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (SETUP ENVIRONMENT)"
+      ],
+      "metadata": {
+        "id": "7N-KXNgQ_a0h"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "pxNxlyfZ8hCg",
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Install dependecies\n",
+        "!git clone --depth 1 https://github.com/asigalov61/tegridy-tools"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Import all needed modules\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Loading core modules...')\n",
+        "print('Please wait...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "import os\n",
+        "import copy\n",
+        "import math\n",
+        "import statistics\n",
+        "import random\n",
+        "import pickle\n",
+        "import shutil\n",
+        "from itertools import groupby\n",
+        "from collections import Counter\n",
+        "from sklearn.metrics import pairwise_distances\n",
+        "from sklearn import metrics\n",
+        "from joblib import Parallel, delayed, parallel_config\n",
+        "import numpy as np\n",
+        "from tqdm import tqdm\n",
+        "from PIL import Image\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "print('Done!')\n",
+        "print('=' * 70)\n",
+        "print('Creating I/O dirs...')\n",
+        "\n",
+        "if not os.path.exists('/content/Dataset'):\n",
+        "    os.makedirs('/content/Dataset')\n",
+        "\n",
+        "print('Done!')\n",
+        "print('=' * 70)\n",
+        "print('Loading tegridy-tools modules...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "%cd /content/tegridy-tools/tegridy-tools\n",
+        "\n",
+        "import TMIDIX\n",
+        "import TMELODIES\n",
+        "import TPLOTS\n",
+        "import HaystackSearch\n",
+        "\n",
+        "%cd /content/\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Done!')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "id": "OblKfMMT8rfM",
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (DOWNLOAD SAMPLE MIDI DATASET)"
+      ],
+      "metadata": {
+        "id": "gUXM7WsN_ioe"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Download sample MIDI dataset (POP909)\n",
+        "%cd /content/Dataset/\n",
+        "!git clone --depth 1 https://github.com/music-x-lab/POP909-Dataset\n",
+        "%cd /content/"
+      ],
+      "metadata": {
+        "id": "JLm4OmOUYlEK",
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Save file list\n",
+        "###########\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Loading MIDI files...')\n",
+        "print('This may take a while on a large dataset in particular...')\n",
+        "\n",
+        "dataset_addr = '/content/Dataset/'\n",
+        "\n",
+        "# os.chdir(dataset_addr)\n",
+        "filez = list()\n",
+        "for (dirpath, dirnames, filenames) in os.walk(dataset_addr):\n",
+        "    filez += [os.path.join(dirpath, file) for file in filenames if file.endswith('.mid') or file.endswith('.midi') or file.endswith('.kar')]\n",
+        "print('=' * 70)\n",
+        "\n",
+        "if filez == []:\n",
+        "    print('Could not find any MIDI files. Please check Dataset dir...')\n",
+        "    print('=' * 70)\n",
+        "\n",
+        "print('Randomizing file list...')\n",
+        "random.shuffle(filez)\n",
+        "print('Done!')\n",
+        "print('=' * 70)\n",
+        "print('Total found MIDI files:', len(filez))\n",
+        "print('=' * 70)\n",
+        "\n",
+        "TMIDIX.Tegridy_Any_Pickle_File_Writer(filez, 'filez')\n",
+        "\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "AJrFrZ9grhMM"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (LOAD TMIDIX MIDI PROCESSOR)"
+      ],
+      "metadata": {
+        "id": "RJeTdierAbeF"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Load TMIDIX MIDI processor\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('TMIDIX MIDI Processor')\n",
+        "print('=' * 70)\n",
+        "print('Loading...')\n",
+        "\n",
+        "###########\n",
+        "\n",
+        "def TMIDIX_MIDI_Processor(midi_file):\n",
+        "\n",
+        "    fn = os.path.basename(midi_file)\n",
+        "    fn1 = fn.split('.mid')[0]\n",
+        "\n",
+        "    try:\n",
+        "\n",
+        "        #=======================================================\n",
+        "        # START PROCESSING\n",
+        "\n",
+        "        raw_score = TMIDIX.midi2single_track_ms_score(midi_file)\n",
+        "\n",
+        "        escore_notes = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]\n",
+        "\n",
+        "        escore_notes = TMIDIX.augment_enhanced_score_notes(escore_notes, timings_divider=256)\n",
+        "\n",
+        "        sp_escore_notes = TMIDIX.recalculate_score_timings(TMIDIX.solo_piano_escore_notes(escore_notes, keep_drums=False))\n",
+        "\n",
+        "        if sp_escore_notes:\n",
+        "\n",
+        "            bmatrix = TMIDIX.escore_notes_to_binary_matrix(sp_escore_notes)\n",
+        "\n",
+        "            return [fn1, bmatrix]\n",
+        "\n",
+        "        else:\n",
+        "            return [fn1, []]\n",
+        "\n",
+        "        #=======================================================\n",
+        "\n",
+        "    except Exception as ex:\n",
+        "        print('WARNING !!!')\n",
+        "        print('=' * 70)\n",
+        "        print('Bad MIDI:', midi_file)\n",
+        "        print('Error detected:', ex)\n",
+        "        print('=' * 70)\n",
+        "        return None\n",
+        "\n",
+        "print('Done!')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "fBbIiUWSZA5y"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (PROCESS MIDIs)"
+      ],
+      "metadata": {
+        "id": "R3QxQN6OA_jX"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Process MIDIs with TMIDIX MIDI processor\n",
+        "output_folder = \"/content/MIDI-Images/\" # @param {\"type\":\"string\"}\n",
+        "\n",
+        "NUMBER_OF_PARALLEL_JOBS = 4 # Number of parallel jobs\n",
+        "NUMBER_OF_FILES_PER_ITERATION = 4 # Number of files to queue for each parallel iteration\n",
+        "SAVE_EVERY_NUMBER_OF_ITERATIONS = 128 # Save every 2560 files\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('TMIDIX MIDI Processor')\n",
+        "print('=' * 70)\n",
+        "print('Starting up...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "###########\n",
+        "\n",
+        "melody_chords_f = []\n",
+        "\n",
+        "files_count = 0\n",
+        "\n",
+        "print('Processing MIDI files...')\n",
+        "print('Please wait...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "for i in tqdm(range(0, len(filez), NUMBER_OF_FILES_PER_ITERATION)):\n",
+        "\n",
+        "  with parallel_config(backend='threading', n_jobs=NUMBER_OF_PARALLEL_JOBS, verbose = 0):\n",
+        "\n",
+        "    output = Parallel(n_jobs=NUMBER_OF_PARALLEL_JOBS, verbose=0)(delayed(TMIDIX_MIDI_Processor)(f) for f in filez[i:i+NUMBER_OF_FILES_PER_ITERATION])\n",
+        "\n",
+        "    for o in output:\n",
+        "\n",
+        "        if o is not None:\n",
+        "            melody_chords_f.append(o)\n",
+        "\n",
+        "    if i % (NUMBER_OF_FILES_PER_ITERATION * SAVE_EVERY_NUMBER_OF_ITERATIONS) == 0 and i != 0:\n",
+        "\n",
+        "        print('SAVING !!!')\n",
+        "        print('=' * 70)\n",
+        "        print('Saving processed files...')\n",
+        "        files_count += len(melody_chords_f)\n",
+        "        print('=' * 70)\n",
+        "        print('Processed so far:', files_count, 'out of', len(filez), '===', files_count / len(filez), 'good files ratio')\n",
+        "        print('=' * 70)\n",
+        "        print('Writing images...')\n",
+        "        print('Please wait...')\n",
+        "\n",
+        "        for mat in melody_chords_f:\n",
+        "\n",
+        "          if mat[1]:\n",
+        "\n",
+        "            TPLOTS.binary_matrix_to_images(mat[1],\n",
+        "                                            128,\n",
+        "                                            32,\n",
+        "                                            output_folder=output_folder+str(mat[0])+'/',\n",
+        "                                            output_img_prefix=str(mat[0]),\n",
+        "                                            output_img_ext='.png',\n",
+        "                                            verbose=False\n",
+        "                                            )\n",
+        "\n",
+        "        print('Done!')\n",
+        "        print('=' * 70)\n",
+        "        melody_chords_f = []\n",
+        "\n",
+        "print('SAVING !!!')\n",
+        "print('=' * 70)\n",
+        "print('Saving processed files...')\n",
+        "files_count += len(melody_chords_f)\n",
+        "print('=' * 70)\n",
+        "print('Processed so far:', files_count, 'out of', len(filez), '===', files_count / len(filez), 'good files ratio')\n",
+        "print('=' * 70)\n",
+        "print('Writing images...')\n",
+        "print('Please wait...')\n",
+        "\n",
+        "for mat in melody_chords_f:\n",
+        "\n",
+        "  if mat[1]:\n",
+        "\n",
+        "    TPLOTS.binary_matrix_to_images(mat[1],\n",
+        "                                    128,\n",
+        "                                    32,\n",
+        "                                    output_folder=output_folder+str(mat[0])+'/',\n",
+        "                                    output_img_prefix=str(mat[0]),\n",
+        "                                    output_img_ext='.png',\n",
+        "                                    verbose=False\n",
+        "                                    )\n",
+        "\n",
+        "print('Done!')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "15y4uzSOZX52"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (LOAD IMAGES)"
+      ],
+      "metadata": {
+        "id": "GtejvUFAFocZ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Load created MIDI images\n",
+        "full_path_to_metadata_pickle_files = \"/content/MIDI-Images\" #@param {type:\"string\"}\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('MIDI Images Reader')\n",
+        "print('=' * 70)\n",
+        "print('Searching for images...')\n",
+        "\n",
+        "filez = list()\n",
+        "for (dirpath, dirnames, filenames) in os.walk(full_path_to_metadata_pickle_files):\n",
+        "    filez += [os.path.join(dirpath, file) for file in filenames if file.endswith('.png')]\n",
+        "print('=' * 70)\n",
+        "\n",
+        "filez.sort()\n",
+        "\n",
+        "print('Found', len(filez), 'images!')\n",
+        "print('=' * 70)\n",
+        "print('Reading images...')\n",
+        "print('Please wait...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "fidx = 0\n",
+        "\n",
+        "all_read_images = []\n",
+        "\n",
+        "for img in tqdm(filez):\n",
+        "\n",
+        "    img = Image.open(img)\n",
+        "\n",
+        "    img_arr = np.array(img).tolist()\n",
+        "\n",
+        "    all_read_images.append(img_arr)\n",
+        "\n",
+        "    fidx += 1\n",
+        "\n",
+        "print('Done!')\n",
+        "print('=' * 70)\n",
+        "print('Loaded', fidx, 'images!')\n",
+        "print('=' * 70)\n",
+        "print('Done!')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "cXpLWHG1dBB3"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (TEST IMAGES)"
+      ],
+      "metadata": {
+        "id": "qbClHSmhB1NF"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Test created MIDI images\n",
+        "\n",
+        "print('=' * 70)\n",
+        "\n",
+        "image = random.choice(all_read_images)\n",
+        "\n",
+        "escore = TMIDIX.binary_matrix_to_original_escore_notes(image)\n",
+        "\n",
+        "output_score, patches, overflow_patches = TMIDIX.patch_enhanced_score_notes(escore)\n",
+        "\n",
+        "detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(output_score,\n",
+        "                                                          output_signature = 'MIDI Images',\n",
+        "                                                          output_file_name = '/content/MIDI-Images-Composition',\n",
+        "                                                          track_name='Project Los Angeles',\n",
+        "                                                          list_of_MIDI_patches=patches,\n",
+        "                                                          timings_multiplier=256\n",
+        "                                                          )\n",
+        "\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "id": "nrPDM1VQdKES",
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (ZIP IMAGES)"
+      ],
+      "metadata": {
+        "id": "sIq55gvPCgJh"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Zip created MIDI images\n",
+        "!zip -9 -r POP909_MIDI_Images_128_128_32_BW.zip MIDI-Images/ > /dev/null"
+      ],
+      "metadata": {
+        "id": "tVe0REKSqJeV",
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Congrats! You did it! :)"
+      ],
+      "metadata": {
+        "id": "iDdMYg4haGFn"
+      }
+    }
+  ]
+}

TPLOTS.py

@@ -0,0 +1,1205 @@
+#! /usr/bin/python3
+
+r'''############################################################################
+################################################################################
+#
+#
+#	      Tegridy Plots Python Module (TPLOTS)
+#	      Version 1.0
+#
+#	      Project Los Angeles
+#
+#	      Tegridy Code 2024
+#
+#       https://github.com/asigalov61/tegridy-tools
+#
+#
+################################################################################
+#
+#       Copyright 2024 Project Los Angeles / Tegridy Code
+#
+#       Licensed under the Apache License, Version 2.0 (the "License");
+#       you may not use this file except in compliance with the License.
+#       You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#       Unless required by applicable law or agreed to in writing, software
+#       distributed under the License is distributed on an "AS IS" BASIS,
+#       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#       See the License for the specific language governing permissions and
+#       limitations under the License.
+#
+################################################################################
+################################################################################
+#
+# Critical dependencies
+#
+# !pip install numpy
+# !pip install scipy
+# !pip install matplotlib
+# !pip install networkx
+# !pip3 install scikit-learn
+#
+################################################################################
+#
+# Future critical dependencies
+#
+# !pip install umap-learn
+# !pip install alphashape
+#
+################################################################################
+'''
+
+################################################################################
+# Modules imports
+################################################################################
+
+import os
+from collections import Counter
+from itertools import groupby
+
+import numpy as np
+
+import networkx as nx
+
+from sklearn.manifold import TSNE
+from sklearn import metrics
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.decomposition import PCA
+
+from scipy.ndimage import zoom
+from scipy.spatial import distance_matrix
+from scipy.sparse.csgraph import minimum_spanning_tree
+from scipy.stats import zscore
+
+import matplotlib.pyplot as plt
+from PIL import Image
+
+################################################################################
+# Constants
+################################################################################
+
+ALL_CHORDS_FILTERED = [[0], [0, 3], [0, 3, 5], [0, 3, 5, 8], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 7],
+                      [0, 3, 7, 10], [0, 3, 8], [0, 3, 9], [0, 3, 10], [0, 4], [0, 4, 6],
+                      [0, 4, 6, 9], [0, 4, 6, 10], [0, 4, 7], [0, 4, 7, 10], [0, 4, 8], [0, 4, 9],
+                      [0, 4, 10], [0, 5], [0, 5, 8], [0, 5, 9], [0, 5, 10], [0, 6], [0, 6, 9],
+                      [0, 6, 10], [0, 7], [0, 7, 10], [0, 8], [0, 9], [0, 10], [1], [1, 4],
+                      [1, 4, 6], [1, 4, 6, 9], [1, 4, 6, 10], [1, 4, 6, 11], [1, 4, 7],
+                      [1, 4, 7, 10], [1, 4, 7, 11], [1, 4, 8], [1, 4, 8, 11], [1, 4, 9], [1, 4, 10],
+                      [1, 4, 11], [1, 5], [1, 5, 8], [1, 5, 8, 11], [1, 5, 9], [1, 5, 10],
+                      [1, 5, 11], [1, 6], [1, 6, 9], [1, 6, 10], [1, 6, 11], [1, 7], [1, 7, 10],
+                      [1, 7, 11], [1, 8], [1, 8, 11], [1, 9], [1, 10], [1, 11], [2], [2, 5],
+                      [2, 5, 8], [2, 5, 8, 11], [2, 5, 9], [2, 5, 10], [2, 5, 11], [2, 6], [2, 6, 9],
+                      [2, 6, 10], [2, 6, 11], [2, 7], [2, 7, 10], [2, 7, 11], [2, 8], [2, 8, 11],
+                      [2, 9], [2, 10], [2, 11], [3], [3, 5], [3, 5, 8], [3, 5, 8, 11], [3, 5, 9],
+                      [3, 5, 10], [3, 5, 11], [3, 7], [3, 7, 10], [3, 7, 11], [3, 8], [3, 8, 11],
+                      [3, 9], [3, 10], [3, 11], [4], [4, 6], [4, 6, 9], [4, 6, 10], [4, 6, 11],
+                      [4, 7], [4, 7, 10], [4, 7, 11], [4, 8], [4, 8, 11], [4, 9], [4, 10], [4, 11],
+                      [5], [5, 8], [5, 8, 11], [5, 9], [5, 10], [5, 11], [6], [6, 9], [6, 10],
+                      [6, 11], [7], [7, 10], [7, 11], [8], [8, 11], [9], [10], [11]]
+
+################################################################################
+
+CHORDS_TYPES = ['WHITE', 'BLACK', 'UNKNOWN', 'MIXED WHITE', 'MIXED BLACK', 'MIXED GRAY']
+
+################################################################################
+
+WHITE_NOTES = [0, 2, 4, 5, 7, 9, 11]
+
+################################################################################
+
+BLACK_NOTES = [1, 3, 6, 8, 10]
+
+################################################################################
+# Helper functions
+################################################################################
+
+def tones_chord_type(tones_chord, 
+                     return_chord_type_index=True,
+                     ):
+
+  """
+  Returns tones chord type
+  """
+
+  WN = WHITE_NOTES
+  BN = BLACK_NOTES
+  MX = WHITE_NOTES + BLACK_NOTES
+
+
+  CHORDS = ALL_CHORDS_FILTERED
+
+  tones_chord = sorted(tones_chord)
+
+  ctype = 'UNKNOWN'
+
+  if tones_chord in CHORDS:
+
+    if sorted(set(tones_chord) & set(WN)) == tones_chord:
+      ctype = 'WHITE'
+
+    elif sorted(set(tones_chord) & set(BN)) == tones_chord:
+      ctype = 'BLACK'
+
+    if len(tones_chord) > 1 and sorted(set(tones_chord) & set(MX)) == tones_chord:
+
+      if len(sorted(set(tones_chord) & set(WN))) == len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED GRAY'
+
+      elif len(sorted(set(tones_chord) & set(WN))) > len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED WHITE'
+
+      elif len(sorted(set(tones_chord) & set(WN))) < len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED BLACK'
+
+  if return_chord_type_index:
+    return CHORDS_TYPES.index(ctype)
+
+  else:
+    return ctype
+
+###################################################################################
+
+def tone_type(tone, 
+              return_tone_type_index=True
+              ):
+
+  """
+  Returns tone type
+  """
+
+  tone = tone % 12
+
+  if tone in BLACK_NOTES:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('BLACK')
+    else:
+      return "BLACK"
+
+  else:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('WHITE')
+    else:
+      return "WHITE"
+
+###################################################################################
+
+def find_closest_points(points, return_points=True):
+
+  """
+  Find closest 2D points
+  """
+
+  coords = np.array(points)
+
+  num_points = coords.shape[0]
+  closest_matches = np.zeros(num_points, dtype=int)
+  distances = np.zeros((num_points, num_points))
+
+  for i in range(num_points):
+      for j in range(num_points):
+          if i != j:
+              distances[i, j] = np.linalg.norm(coords[i] - coords[j])
+          else:
+              distances[i, j] = np.inf
+
+  closest_matches = np.argmin(distances, axis=1)
+  
+  if return_points:
+    points_matches = coords[closest_matches].tolist()
+    return points_matches
+  
+  else:
+    return closest_matches.tolist()
+
+################################################################################
+
+def reduce_dimensionality_tsne(list_of_valies,
+                                n_comp=2,
+                                n_iter=5000,
+                                verbose=True
+                              ):
+
+  """
+  Reduces the dimensionality of the values using t-SNE.
+  """
+
+  vals = np.array(list_of_valies)
+
+  tsne = TSNE(n_components=n_comp,
+              n_iter=n_iter,
+              verbose=verbose)
+
+  reduced_vals = tsne.fit_transform(vals)
+
+  return reduced_vals.tolist()
+
+################################################################################
+
+def compute_mst_edges(similarity_scores_list):
+
+  """
+  Computes the Minimum Spanning Tree (MST) edges based on the similarity scores.
+  """
+  
+  num_tokens = len(similarity_scores_list[0])
+
+  graph = nx.Graph()
+
+  for i in range(num_tokens):
+      for j in range(i + 1, num_tokens):
+          weight = 1 - similarity_scores_list[i][j]
+          graph.add_edge(i, j, weight=weight)
+
+  mst = nx.minimum_spanning_tree(graph)
+
+  mst_edges = list(mst.edges(data=False))
+
+  return mst_edges
+
+################################################################################
+
+def square_binary_matrix(binary_matrix, 
+                         matrix_size=128,
+                         interpolation_order=5,
+                         return_square_matrix_points=False
+                         ):
+
+  """
+  Reduces an arbitrary binary matrix to a square binary matrix
+  """
+
+  zoom_factors = (matrix_size / len(binary_matrix), 1)
+
+  resized_matrix = zoom(binary_matrix, zoom_factors, order=interpolation_order)
+
+  resized_matrix = (resized_matrix > 0.5).astype(int)
+
+  final_matrix = np.zeros((matrix_size, matrix_size), dtype=int)
+  final_matrix[:, :resized_matrix.shape[1]] = resized_matrix
+
+  points = np.column_stack(np.where(final_matrix == 1)).tolist()
+
+  if return_square_matrix_points:
+    return points
+
+  else:
+    return resized_matrix
+
+################################################################################
+
+def square_matrix_points_colors(square_matrix_points):
+
+  """
+  Returns colors for square matrix points
+  """
+
+  cmap = generate_colors(12)
+
+  chords = []
+  chords_dict = set()
+  counts = []
+
+  for k, v in groupby(square_matrix_points, key=lambda x: x[0]):
+    pgroup = [vv[1] for vv in v]
+    chord = sorted(set(pgroup))
+    tchord = sorted(set([p % 12 for p in chord]))
+    chords_dict.add(tuple(tchord))
+    chords.append(tuple(tchord))
+    counts.append(len(pgroup))
+
+  chords_dict = sorted(chords_dict)
+
+  colors = []
+
+  for i, c in enumerate(chords):
+    colors.extend([cmap[round(sum(c) / len(c))]] * counts[i])
+
+  return colors
+
+################################################################################
+
+def hsv_to_rgb(h, s, v):
+
+  if s == 0.0:
+      return v, v, v
+
+  i = int(h*6.0)
+  f = (h*6.0) - i
+  p = v*(1.0 - s)
+  q = v*(1.0 - s*f)
+  t = v*(1.0 - s*(1.0-f))
+  i = i%6
+  
+  return [(v, t, p), (q, v, p), (p, v, t), (p, q, v), (t, p, v), (v, p, q)][i]
+
+################################################################################
+
+def generate_colors(n):
+  return [hsv_to_rgb(i/n, 1, 1) for i in range(n)]
+
+################################################################################
+
+def add_arrays(a, b):
+  return [sum(pair) for pair in zip(a, b)]
+
+################################################################################
+
+def calculate_similarities(lists_of_values, metric='cosine'):
+  return metrics.pairwise_distances(lists_of_values, metric=metric).tolist()
+
+################################################################################
+
+def get_tokens_embeddings(x_transformer_model):
+  return x_transformer_model.net.token_emb.emb.weight.detach().cpu().tolist()
+
+################################################################################
+
+def minkowski_distance_matrix(X, p=3):
+
+  X = np.array(X)
+
+  n = X.shape[0]
+  dist_matrix = np.zeros((n, n))
+
+  for i in range(n):
+      for j in range(n):
+          dist_matrix[i, j] = np.sum(np.abs(X[i] - X[j])**p)**(1/p)
+
+  return dist_matrix.tolist()
+
+################################################################################
+
+def robust_normalize(values):
+
+  values = np.array(values)
+  q1 = np.percentile(values, 25)
+  q3 = np.percentile(values, 75)
+  iqr = q3 - q1
+
+  filtered_values = values[(values >= q1 - 1.5 * iqr) & (values <= q3 + 1.5 * iqr)]
+
+  min_val = np.min(filtered_values)
+  max_val = np.max(filtered_values)
+  normalized_values = (values - min_val) / (max_val - min_val)
+
+  normalized_values = np.clip(normalized_values, 0, 1)
+
+  return normalized_values.tolist()
+
+################################################################################
+
+def min_max_normalize(values):
+
+  scaler = MinMaxScaler()
+
+  return scaler.fit_transform(values).tolist()
+
+################################################################################
+
+def remove_points_outliers(points, z_score_threshold=3):
+
+  points = np.array(points)
+
+  z_scores = np.abs(zscore(points, axis=0))
+
+  return points[(z_scores < z_score_threshold).all(axis=1)].tolist()
+
+################################################################################
+
+def generate_labels(lists_of_values, 
+                    return_indices_labels=False
+                    ):
+
+  ordered_indices = list(range(len(lists_of_values)))
+  ordered_indices_labels = [str(i) for i in ordered_indices]
+  ordered_values_labels = [str(lists_of_values[i]) for i in ordered_indices]
+
+  if return_indices_labels:
+    return ordered_indices_labels
+  
+  else:
+    return ordered_values_labels
+
+################################################################################
+
+def reduce_dimensionality_pca(list_of_values, n_components=2):
+
+  """
+  Reduces the dimensionality of the values using PCA.
+  """
+
+  pca = PCA(n_components=n_components)
+  pca_data = pca.fit_transform(list_of_values)
+  
+  return pca_data.tolist()
+
+def reduce_dimensionality_simple(list_of_values, 
+                                 return_means=True,
+                                 return_std_devs=True,
+                                 return_medians=False,
+                                 return_vars=False
+                                 ):
+  
+  '''
+  Reduces dimensionality of the values in a simple way
+  '''
+
+  array = np.array(list_of_values)
+  results = []
+
+  if return_means:
+      means = np.mean(array, axis=1)
+      results.append(means)
+
+  if return_std_devs:
+      std_devs = np.std(array, axis=1)
+      results.append(std_devs)
+
+  if return_medians:
+      medians = np.median(array, axis=1)
+      results.append(medians)
+
+  if return_vars:
+      vars = np.var(array, axis=1)
+      results.append(vars)
+
+  merged_results = np.column_stack(results)
+  
+  return merged_results.tolist()
+
+################################################################################
+
+def reduce_dimensionality_2d_distance(list_of_values, p=5):
+
+  '''
+  Reduces the dimensionality of the values using 2d distance
+  '''
+
+  values = np.array(list_of_values)
+
+  dist_matrix = distance_matrix(values, values, p=p)
+
+  mst = minimum_spanning_tree(dist_matrix).toarray()
+
+  points = []
+
+  for i in range(len(values)):
+      for j in range(len(values)):
+          if mst[i, j] > 0:
+              points.append([i, j])
+
+  return points
+
+################################################################################
+
+def normalize_to_range(values, n):
+    
+  min_val = min(values)
+  max_val = max(values)
+  
+  range_val = max_val - min_val
+  
+  normalized_values = [((value - min_val) / range_val * 2 * n) - n for value in values]
+  
+  return normalized_values
+
+################################################################################
+
+def reduce_dimensionality_simple_pca(list_of_values, n_components=2):
+
+  '''
+  Reduces the dimensionality of the values using simple PCA
+  '''
+
+  reduced_values = []
+
+  for l in list_of_values:
+
+    norm_values = [round(v * len(l)) for v in normalize_to_range(l, (n_components+1) // 2)]
+
+    pca_values = Counter(norm_values).most_common()
+    pca_values = [vv[0] / len(l) for vv in pca_values]
+    pca_values = pca_values[:n_components]
+    pca_values = pca_values + [0] * (n_components - len(pca_values))
+
+    reduced_values.append(pca_values)
+
+  return reduced_values
+
+################################################################################
+
+def filter_and_replace_values(list_of_values, 
+                              threshold, 
+                              replace_value, 
+                              replace_above_threshold=False
+                              ):
+
+  array = np.array(list_of_values)
+
+  modified_array = np.copy(array)
+  
+  if replace_above_threshold:
+    modified_array[modified_array > threshold] = replace_value
+  
+  else:
+    modified_array[modified_array < threshold] = replace_value
+  
+  return modified_array.tolist()
+
+################################################################################
+
+def find_shortest_constellation_path(points, 
+                                     start_point_idx, 
+                                     end_point_idx,
+                                     p=5,
+                                     return_path_length=False,
+                                     return_path_points=False,
+                                     ):
+
+    """
+    Finds the shortest path between two points of the points constellation
+    """
+
+    points = np.array(points)
+
+    dist_matrix = distance_matrix(points, points, p=p)
+
+    mst = minimum_spanning_tree(dist_matrix).toarray()
+
+    G = nx.Graph()
+
+    for i in range(len(points)):
+        for j in range(len(points)):
+            if mst[i, j] > 0:
+                G.add_edge(i, j, weight=mst[i, j])
+
+    path = nx.shortest_path(G, 
+                            source=start_point_idx, 
+                            target=end_point_idx, 
+                            weight='weight'
+                            )
+    
+    path_length = nx.shortest_path_length(G, 
+                                          source=start_point_idx, 
+                                          target=end_point_idx, 
+                                          weight='weight')
+        
+    path_points = points[np.array(path)].tolist()
+
+
+    if return_path_points:
+      return path_points
+
+    if return_path_length:
+      return path_length
+
+    return path
+
+################################################################################
+# Core functions
+################################################################################
+
+def plot_ms_SONG(ms_song,
+                  preview_length_in_notes=0,
+                  block_lines_times_list = None,
+                  plot_title='ms Song',
+                  max_num_colors=129, 
+                  drums_color_num=128, 
+                  plot_size=(11,4), 
+                  note_height = 0.75,
+                  show_grid_lines=False,
+                  return_plt = False,
+                  timings_multiplier=1,
+                  save_plt='',
+                  save_only_plt_image=True,
+                  save_transparent=False
+                  ):
+
+  '''ms SONG plot'''
+
+  notes = [s for s in ms_song if s[0] == 'note']
+
+  if (len(max(notes, key=len)) != 7) and (len(min(notes, key=len)) != 7):
+    print('The song notes do not have patches information')
+    print('Ploease add patches to the notes in the song')
+
+  else:
+
+    start_times = [(s[1] * timings_multiplier) / 1000 for s in notes]
+    durations = [(s[2]  * timings_multiplier) / 1000 for s in notes]
+    pitches = [s[4] for s in notes]
+    patches = [s[6] for s in notes]
+
+    colors = generate_colors(max_num_colors)
+    colors[drums_color_num] = (1, 1, 1)
+
+    pbl = (notes[preview_length_in_notes][1] * timings_multiplier) / 1000
+
+    fig, ax = plt.subplots(figsize=plot_size)
+
+    for start, duration, pitch, patch in zip(start_times, durations, pitches, patches):
+        rect = plt.Rectangle((start, pitch), duration, note_height, facecolor=colors[patch])
+        ax.add_patch(rect)
+
+    ax.set_xlim([min(start_times), max(add_arrays(start_times, durations))])
+    ax.set_ylim([min(pitches)-1, max(pitches)+1])
+
+    ax.set_facecolor('black')
+    fig.patch.set_facecolor('white')
+
+    if preview_length_in_notes > 0:
+      ax.axvline(x=pbl, c='white')
+
+    if block_lines_times_list:
+      for bl in block_lines_times_list:
+        ax.axvline(x=bl, c='white')
+           
+    if show_grid_lines:
+      ax.grid(color='white')
+
+    plt.xlabel('Time (s)', c='black')
+    plt.ylabel('MIDI Pitch', c='black')
+
+    plt.title(plot_title)
+
+    if save_plt != '':
+      if save_only_plt_image:
+        plt.axis('off')
+        plt.title('')
+        plt.savefig(save_plt, 
+                    transparent=save_transparent, 
+                    bbox_inches='tight', 
+                    pad_inches=0, 
+                    facecolor='black'
+                    )
+        plt.close()
+      
+      else:
+        plt.savefig(save_plt)
+        plt.close()
+
+    if return_plt:
+      return fig
+
+    plt.show()
+    plt.close()
+
+################################################################################
+
+def plot_square_matrix_points(list_of_points,
+                              list_of_points_colors,
+                              plot_size=(7, 7),
+                              point_size = 10,
+                              show_grid_lines=False,
+                              plot_title = 'Square Matrix Points Plot',
+                              return_plt=False,
+                              save_plt='',
+                              save_only_plt_image=True,
+                              save_transparent=False
+                              ):
+
+  '''Square matrix points plot'''
+
+  fig, ax = plt.subplots(figsize=plot_size)
+
+  ax.set_facecolor('black')
+
+  if show_grid_lines:
+    ax.grid(color='white')
+
+  plt.xlabel('Time Step', c='black')
+  plt.ylabel('MIDI Pitch', c='black')
+
+  plt.title(plot_title)
+
+  plt.scatter([p[0] for p in list_of_points], 
+              [p[1] for p in list_of_points], 
+              c=list_of_points_colors, 
+              s=point_size
+              )
+
+  if save_plt != '':
+    if save_only_plt_image:
+      plt.axis('off')
+      plt.title('')
+      plt.savefig(save_plt, 
+                  transparent=save_transparent, 
+                  bbox_inches='tight', 
+                  pad_inches=0, 
+                  facecolor='black'
+                  )
+      plt.close()
+    
+    else:
+      plt.savefig(save_plt)
+      plt.close()
+
+  if return_plt:
+    return fig
+
+  plt.show()
+  plt.close()
+
+################################################################################
+
+def plot_cosine_similarities(lists_of_values,
+                             plot_size=(7, 7),
+                             save_plot=''
+                            ):
+
+  """
+  Cosine similarities plot
+  """
+
+  cos_sim = metrics.pairwise_distances(lists_of_values, metric='cosine')
+
+  plt.figure(figsize=plot_size)
+
+  plt.imshow(cos_sim, cmap="inferno", interpolation="nearest")
+
+  im_ratio = cos_sim.shape[0] / cos_sim.shape[1]
+
+  plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)
+
+  plt.xlabel("Index")
+  plt.ylabel("Index")
+
+  plt.tight_layout()
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+  plt.close()
+
+################################################################################
+
+def plot_points_with_mst_lines(points, 
+                               points_labels, 
+                               points_mst_edges,
+                               plot_size=(20, 20),
+                               labels_size=24,
+                               save_plot=''
+                               ):
+
+  """
+  Plots 2D points with labels and MST lines.
+  """
+
+  plt.figure(figsize=plot_size)
+
+  for i, label in enumerate(points_labels):
+      plt.scatter(points[i][0], points[i][1])
+      plt.annotate(label, (points[i][0], points[i][1]), fontsize=labels_size)
+
+  for edge in points_mst_edges:
+      i, j = edge
+      plt.plot([points[i][0], points[j][0]], [points[i][1], points[j][1]], 'k-', alpha=0.5)
+
+  plt.title('Points Map with MST Lines', fontsize=labels_size)
+  plt.xlabel('X-axis', fontsize=labels_size)
+  plt.ylabel('Y-axis', fontsize=labels_size)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+
+################################################################################
+
+def plot_points_constellation(points, 
+                              points_labels,
+                              p=5,                              
+                              plot_size=(15, 15),
+                              labels_size=12,
+                              show_grid=False,
+                              save_plot=''
+                              ):
+
+  """
+  Plots 2D points constellation
+  """
+
+  points = np.array(points)
+
+  dist_matrix = distance_matrix(points, points, p=p)
+
+  mst = minimum_spanning_tree(dist_matrix).toarray()
+
+  plt.figure(figsize=plot_size)
+
+  plt.scatter(points[:, 0], points[:, 1], color='blue')
+
+  for i, label in enumerate(points_labels):
+      plt.annotate(label, (points[i, 0], points[i, 1]), 
+                   textcoords="offset points", 
+                   xytext=(0, 10), 
+                   ha='center',
+                   fontsize=labels_size
+                   )
+
+  for i in range(len(points)):
+      for j in range(len(points)):
+          if mst[i, j] > 0:
+              plt.plot([points[i, 0], points[j, 0]], [points[i, 1], points[j, 1]], 'k--')
+
+  plt.xlabel('X-axis', fontsize=labels_size)
+  plt.ylabel('Y-axis', fontsize=labels_size)
+  plt.title('2D Coordinates with Minimum Spanning Tree', fontsize=labels_size)
+
+  plt.grid(show_grid)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+
+################################################################################
+
+def binary_matrix_to_images(matrix, 
+                            step,
+                            overlap,
+                            output_folder='./Dataset/', 
+                            output_img_prefix='image', 
+                            output_img_ext='.png',
+                            save_to_array=False,
+                            verbose=True
+                            ):
+
+    if not save_to_array:
+
+      if verbose:
+        print('=' * 70)
+        print('Checking output folder dir...')
+
+      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
+
+      if verbose:
+        print('Done!')
+
+    if verbose:
+      print('=' * 70)
+      print('Writing images...')
+
+    matrix = np.array(matrix, dtype=np.uint8)
+    
+    image_array = []
+    
+    for i in range(0, max(1, matrix.shape[0]), overlap):
+       
+        submatrix = matrix[i:i+step, :]
+
+        if submatrix.shape[0] < 128:
+          zeros_array = np.zeros((128-submatrix.shape[0], 128))
+          submatrix = np.vstack((submatrix, zeros_array))
+
+        img = Image.fromarray(submatrix * 255).convert('1')
+        
+        if save_to_array:
+          image_array.append(np.array(img))
+
+        else:
+          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
+  
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
+      print('=' * 70)
+
+    if save_to_array:
+        return np.array(image_array).tolist()
+
+################################################################################
+
+def images_to_binary_matrix(list_of_images):
+
+    image_array = np.array(list_of_images)
+   
+    original_matrix = []
+    
+    for img in image_array:
+
+        submatrix = np.array(img)
+        original_matrix.extend(submatrix.tolist())
+    
+    return original_matrix
+
+################################################################################
+
+def square_image_matrix(image_matrix,
+                        matrix_size=128,
+                        num_pca_components=5,
+                        filter_out_zero_rows=False,
+                        return_square_matrix_points=False
+                        ):
+
+  """
+  Reduces an arbitrary image matrix to a square image matrix
+  """
+
+  matrix = np.array(image_matrix)
+
+  if filter_out_zero_rows:
+    matrix = matrix[~np.all(matrix == 0, axis=1)]
+
+  target_rows = matrix_size
+
+  rows_per_group = matrix.shape[0] // target_rows
+
+  compressed_matrix = np.zeros((target_rows, matrix.shape[1]), dtype=np.int32)
+
+  for i in range(target_rows):
+      start_row = i * rows_per_group
+      end_row = (i + 1) * rows_per_group
+      group = matrix[start_row:end_row, :]
+      
+      pca = PCA(n_components=num_pca_components)
+      pca.fit(group)
+      
+      principal_component = np.mean(pca.components_, axis=0)
+      contributions = np.dot(group, principal_component)
+      selected_row_index = np.argmax(contributions)
+      
+      compressed_matrix[i, :] = group[selected_row_index, :]
+
+  if return_square_matrix_points:
+    filtered_matrix = compressed_matrix[~np.all(compressed_matrix == 0, axis=1)]
+
+    row_indexes, col_indexes = np.where(filtered_matrix != 0)
+    points = np.column_stack((row_indexes, filtered_matrix[row_indexes, col_indexes])).tolist()
+
+    return points
+
+  else:
+    return compressed_matrix.tolist()
+
+################################################################################
+
+def image_matrix_to_images(image_matrix,
+                           step,
+                           overlap,
+                           num_img_channels=3,
+                           output_folder='./Dataset/',
+                           output_img_prefix='image',
+                           output_img_ext='.png',
+                           save_to_array=False,
+                           verbose=True
+                           ):
+
+    if num_img_channels > 1:
+      n_mat_channels = 3
+
+    else:
+      n_mat_channels = 1
+
+    if not save_to_array:
+
+      if verbose:
+        print('=' * 70)
+        print('Checking output folder dir...')
+
+      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
+
+      if verbose:
+        print('Done!')
+
+    if verbose:
+      print('=' * 70)
+      print('Writing images...')
+
+    matrix = np.array(image_matrix)
+
+    image_array = []
+
+    for i in range(0, max(1, matrix.shape[0]), overlap):
+
+        submatrix = matrix[i:i+step, :]
+
+        if submatrix.shape[0] < 128:
+          zeros_array = np.zeros((128-submatrix.shape[0], 128))
+          submatrix = np.vstack((submatrix, zeros_array))
+
+        if n_mat_channels == 3:
+
+          r = (submatrix // (256*256)) % 256
+          g = (submatrix // 256) % 256
+          b = submatrix % 256
+
+          rgb_image = np.stack((r, g, b), axis=-1).astype(np.uint8)
+          img = Image.fromarray(rgb_image, 'RGB')
+
+        else:
+          grayscale_image = submatrix.astype(np.uint8)
+          img = Image.fromarray(grayscale_image, 'L')
+
+        if save_to_array:
+          image_array.append(np.array(img))
+
+        else:
+          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
+
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
+      print('=' * 70)
+
+    if save_to_array:
+        return np.array(image_array).tolist()
+
+################################################################################
+
+def images_to_image_matrix(list_of_images,
+                           num_img_channels=3
+                           ):
+
+    if num_img_channels > 1:
+      n_mat_channels = 3
+
+    else:
+      n_mat_channels = 1
+
+    image_array = np.array(list_of_images)
+
+    original_matrix = []
+
+    for img in image_array:
+
+      if num_img_channels == 3:
+
+        rgb_array = np.array(img)
+
+        matrix = (rgb_array[..., 0].astype(np.int64) * 256*256 +
+                  rgb_array[..., 1].astype(np.int64) * 256 +
+                  rgb_array[..., 2].astype(np.int64))
+
+      else:
+        matrix = np.array(img)
+
+      original_matrix.extend(matrix)
+
+    return original_matrix
+
+################################################################################
+# [WIP] Future dev functions
+################################################################################
+
+'''
+import umap
+
+def reduce_dimensionality_umap(list_of_values,
+                               n_comp=2,
+                               n_neighbors=15,
+                               ):
+
+  """
+  Reduces the dimensionality of the values using UMAP.
+  """
+
+  vals = np.array(list_of_values)
+
+  umap_reducer = umap.UMAP(n_components=n_comp,
+                           n_neighbors=n_neighbors,
+                           n_epochs=5000,
+                           verbose=True
+                           )
+
+  reduced_vals = umap_reducer.fit_transform(vals)
+
+  return reduced_vals.tolist()
+'''
+
+################################################################################
+
+'''
+import alphashape
+from shapely.geometry import Point
+from matplotlib.tri import Triangulation, LinearTriInterpolator
+from scipy.stats import zscore
+
+#===============================================================================
+
+coordinates = points
+
+dist_matrix = minkowski_distance_matrix(coordinates, p=3)  # You can change the value of p as needed
+
+# Centering matrix
+n = dist_matrix.shape[0]
+H = np.eye(n) - np.ones((n, n)) / n
+
+# Apply double centering
+B = -0.5 * H @ dist_matrix**2 @ H
+
+# Eigen decomposition
+eigvals, eigvecs = np.linalg.eigh(B)
+
+# Sort eigenvalues and eigenvectors
+idx = np.argsort(eigvals)[::-1]
+eigvals = eigvals[idx]
+eigvecs = eigvecs[:, idx]
+
+# Select the top 2 eigenvectors
+X_transformed = eigvecs[:, :2] * np.sqrt(eigvals[:2])
+
+#===============================================================================
+
+src_points = X_transformed
+src_values = np.array([[p[1]] for p in points]) #np.random.rand(X_transformed.shape[0])
+
+#===============================================================================
+
+# Normalize the points to the range [0, 1]
+scaler = MinMaxScaler()
+points_normalized = scaler.fit_transform(src_points)
+
+values_normalized = custom_normalize(src_values)
+
+# Remove outliers based on z-score
+z_scores = np.abs(zscore(points_normalized, axis=0))
+filtered_points = points_normalized[(z_scores < 3).all(axis=1)]
+filtered_values = values_normalized[(z_scores < 3).all(axis=1)]
+
+# Compute the concave hull (alpha shape)
+alpha = 8  # Adjust alpha as needed
+hull = alphashape.alphashape(filtered_points, alpha)
+
+# Create a triangulation
+tri = Triangulation(filtered_points[:, 0], filtered_points[:, 1])
+
+# Interpolate the values on the triangulation
+interpolator = LinearTriInterpolator(tri, filtered_values[:, 0])
+xi, yi = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100))
+zi = interpolator(xi, yi)
+
+# Mask out points outside the concave hull
+mask = np.array([hull.contains(Point(x, y)) for x, y in zip(xi.flatten(), yi.flatten())])
+zi = np.ma.array(zi, mask=~mask.reshape(zi.shape))
+
+# Plot the filled contour based on the interpolated values
+plt.contourf(xi, yi, zi, levels=50, cmap='viridis')
+
+# Plot the original points
+#plt.scatter(filtered_points[:, 0], filtered_points[:, 1], c=filtered_values, edgecolors='k')
+
+plt.title('Filled Contour Plot with Original Values')
+plt.xlabel('X-axis')
+plt.ylabel('Y-axis')
+plt.colorbar(label='Value')
+plt.show()
+'''
+
+################################################################################
+#
+# This is the end of TPLOTS Python modules
+#
+################################################################################

midi_images_solo_piano_dataset_maker.py

@@ -0,0 +1,330 @@
+# -*- coding: utf-8 -*-
+"""MIDI_Images_Solo_Piano_Dataset_Maker.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/15E6o3Y1xPific5RtIZ-1CneHQhts3eEr
+
+# MIDI Images Solo Piano Dataset Maker (ver. 1.0)
+
+***
+
+Powered by tegridy-tools: https://github.com/asigalov61/tegridy-tools
+
+***
+
+#### Project Los Angeles
+
+#### Tegridy Code 2024
+
+***
+
+# (SETUP ENVIRONMENT)
+"""
+
+# @title Install dependecies
+!git clone --depth 1 https://github.com/asigalov61/tegridy-tools
+
+# Commented out IPython magic to ensure Python compatibility.
+#@title Import all needed modules
+
+print('=' * 70)
+print('Loading core modules...')
+print('Please wait...')
+print('=' * 70)
+
+import os
+import copy
+import math
+import statistics
+import random
+import pickle
+import shutil
+from itertools import groupby
+from collections import Counter
+from sklearn.metrics import pairwise_distances
+from sklearn import metrics
+from joblib import Parallel, delayed, parallel_config
+import numpy as np
+from tqdm import tqdm
+from PIL import Image
+import matplotlib.pyplot as plt
+
+print('Done!')
+print('=' * 70)
+print('Creating I/O dirs...')
+
+if not os.path.exists('/content/Dataset'):
+    os.makedirs('/content/Dataset')
+
+print('Done!')
+print('=' * 70)
+print('Loading tegridy-tools modules...')
+print('=' * 70)
+
+# %cd /content/tegridy-tools/tegridy-tools
+
+import TMIDIX
+import TMELODIES
+import TPLOTS
+import HaystackSearch
+
+# %cd /content/
+
+print('=' * 70)
+print('Done!')
+print('=' * 70)
+
+"""# (DOWNLOAD SAMPLE MIDI DATASET)"""
+
+# Commented out IPython magic to ensure Python compatibility.
+# @title Download sample MIDI dataset (POP909)
+# %cd /content/Dataset/
+!git clone --depth 1 https://github.com/music-x-lab/POP909-Dataset
+# %cd /content/
+
+#@title Save file list
+###########
+
+print('=' * 70)
+print('Loading MIDI files...')
+print('This may take a while on a large dataset in particular...')
+
+dataset_addr = '/content/Dataset/'
+
+# os.chdir(dataset_addr)
+filez = list()
+for (dirpath, dirnames, filenames) in os.walk(dataset_addr):
+    filez += [os.path.join(dirpath, file) for file in filenames if file.endswith('.mid') or file.endswith('.midi') or file.endswith('.kar')]
+print('=' * 70)
+
+if filez == []:
+    print('Could not find any MIDI files. Please check Dataset dir...')
+    print('=' * 70)
+
+print('Randomizing file list...')
+random.shuffle(filez)
+print('Done!')
+print('=' * 70)
+print('Total found MIDI files:', len(filez))
+print('=' * 70)
+
+TMIDIX.Tegridy_Any_Pickle_File_Writer(filez, 'filez')
+
+print('=' * 70)
+
+"""# (LOAD TMIDIX MIDI PROCESSOR)"""
+
+#@title Load TMIDIX MIDI processor
+
+print('=' * 70)
+print('TMIDIX MIDI Processor')
+print('=' * 70)
+print('Loading...')
+
+###########
+
+def TMIDIX_MIDI_Processor(midi_file):
+
+    fn = os.path.basename(midi_file)
+    fn1 = fn.split('.mid')[0]
+
+    try:
+
+        #=======================================================
+        # START PROCESSING
+
+        raw_score = TMIDIX.midi2single_track_ms_score(midi_file)
+
+        escore_notes = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]
+
+        escore_notes = TMIDIX.augment_enhanced_score_notes(escore_notes, timings_divider=256)
+
+        sp_escore_notes = TMIDIX.recalculate_score_timings(TMIDIX.solo_piano_escore_notes(escore_notes, keep_drums=False))
+
+        if sp_escore_notes:
+
+            bmatrix = TMIDIX.escore_notes_to_binary_matrix(sp_escore_notes)
+
+            return [fn1, bmatrix]
+
+        else:
+            return [fn1, []]
+
+        #=======================================================
+
+    except Exception as ex:
+        print('WARNING !!!')
+        print('=' * 70)
+        print('Bad MIDI:', midi_file)
+        print('Error detected:', ex)
+        print('=' * 70)
+        return None
+
+print('Done!')
+print('=' * 70)
+
+"""# (PROCESS MIDIs)"""
+
+#@title Process MIDIs with TMIDIX MIDI processor
+output_folder = "/content/MIDI-Images/" # @param {"type":"string"}
+
+NUMBER_OF_PARALLEL_JOBS = 4 # Number of parallel jobs
+NUMBER_OF_FILES_PER_ITERATION = 4 # Number of files to queue for each parallel iteration
+SAVE_EVERY_NUMBER_OF_ITERATIONS = 128 # Save every 2560 files
+
+print('=' * 70)
+print('TMIDIX MIDI Processor')
+print('=' * 70)
+print('Starting up...')
+print('=' * 70)
+
+###########
+
+melody_chords_f = []
+
+files_count = 0
+
+print('Processing MIDI files...')
+print('Please wait...')
+print('=' * 70)
+
+for i in tqdm(range(0, len(filez), NUMBER_OF_FILES_PER_ITERATION)):
+
+  with parallel_config(backend='threading', n_jobs=NUMBER_OF_PARALLEL_JOBS, verbose = 0):
+
+    output = Parallel(n_jobs=NUMBER_OF_PARALLEL_JOBS, verbose=0)(delayed(TMIDIX_MIDI_Processor)(f) for f in filez[i:i+NUMBER_OF_FILES_PER_ITERATION])
+
+    for o in output:
+
+        if o is not None:
+            melody_chords_f.append(o)
+
+    if i % (NUMBER_OF_FILES_PER_ITERATION * SAVE_EVERY_NUMBER_OF_ITERATIONS) == 0 and i != 0:
+
+        print('SAVING !!!')
+        print('=' * 70)
+        print('Saving processed files...')
+        files_count += len(melody_chords_f)
+        print('=' * 70)
+        print('Processed so far:', files_count, 'out of', len(filez), '===', files_count / len(filez), 'good files ratio')
+        print('=' * 70)
+        print('Writing images...')
+        print('Please wait...')
+
+        for mat in melody_chords_f:
+
+          if mat[1]:
+
+            TPLOTS.binary_matrix_to_images(mat[1],
+                                            128,
+                                            32,
+                                            output_folder=output_folder+str(mat[0])+'/',
+                                            output_img_prefix=str(mat[0]),
+                                            output_img_ext='.png',
+                                            verbose=False
+                                            )
+
+        print('Done!')
+        print('=' * 70)
+        melody_chords_f = []
+
+print('SAVING !!!')
+print('=' * 70)
+print('Saving processed files...')
+files_count += len(melody_chords_f)
+print('=' * 70)
+print('Processed so far:', files_count, 'out of', len(filez), '===', files_count / len(filez), 'good files ratio')
+print('=' * 70)
+print('Writing images...')
+print('Please wait...')
+
+for mat in melody_chords_f:
+
+  if mat[1]:
+
+    TPLOTS.binary_matrix_to_images(mat[1],
+                                    128,
+                                    32,
+                                    output_folder=output_folder+str(mat[0])+'/',
+                                    output_img_prefix=str(mat[0]),
+                                    output_img_ext='.png',
+                                    verbose=False
+                                    )
+
+print('Done!')
+print('=' * 70)
+
+"""# (LOAD IMAGES)"""
+
+#@title Load created MIDI images
+full_path_to_metadata_pickle_files = "/content/MIDI-Images" #@param {type:"string"}
+
+print('=' * 70)
+print('MIDI Images Reader')
+print('=' * 70)
+print('Searching for images...')
+
+filez = list()
+for (dirpath, dirnames, filenames) in os.walk(full_path_to_metadata_pickle_files):
+    filez += [os.path.join(dirpath, file) for file in filenames if file.endswith('.png')]
+print('=' * 70)
+
+filez.sort()
+
+print('Found', len(filez), 'images!')
+print('=' * 70)
+print('Reading images...')
+print('Please wait...')
+print('=' * 70)
+
+fidx = 0
+
+all_read_images = []
+
+for img in tqdm(filez):
+
+    img = Image.open(img)
+
+    img_arr = np.array(img).tolist()
+
+    all_read_images.append(img_arr)
+
+    fidx += 1
+
+print('Done!')
+print('=' * 70)
+print('Loaded', fidx, 'images!')
+print('=' * 70)
+print('Done!')
+print('=' * 70)
+
+"""# (TEST IMAGES)"""
+
+# @title Test created MIDI images
+
+print('=' * 70)
+
+image = random.choice(all_read_images)
+
+escore = TMIDIX.binary_matrix_to_original_escore_notes(image)
+
+output_score, patches, overflow_patches = TMIDIX.patch_enhanced_score_notes(escore)
+
+detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(output_score,
+                                                          output_signature = 'MIDI Images',
+                                                          output_file_name = '/content/MIDI-Images-Composition',
+                                                          track_name='Project Los Angeles',
+                                                          list_of_MIDI_patches=patches,
+                                                          timings_multiplier=256
+                                                          )
+
+print('=' * 70)
+
+"""# (ZIP IMAGES)"""
+
+# @title Zip created MIDI images
+!zip -9 -r POP909_MIDI_Images_128_128_32_BW.zip MIDI-Images/ > /dev/null
+
+"""# Congrats! You did it! :)"""