{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c02965ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List, Dict, Optional, Any, Tuple\n",
    "\n",
    "def _build_artist_vox_mappings(\n",
    "    metas: List[Dict],\n",
    ") -> Tuple[Dict[str, List[int]], Dict[str, Optional[Dict[str, Any]]]]:\n",
    "    \"\"\"\n",
    "    Build mappings from artist IDs to metadata indices and vox stem paths with duration.\n",
    "\n",
    "    Args:\n",
    "        metas: List of metadata dictionaries\n",
    "\n",
    "    Returns:\n",
    "        Tuple of (artist_id_to_meta_idx, artist_id_to_vox_paths)\n",
    "        - artist_id_to_meta_idx: Maps artist_id to list of meta indices\n",
    "        - artist_id_to_vox_paths: Maps artist_id to dict with 'path' and 'duration_s' (or None)\n",
    "    \"\"\"\n",
    "    # Build mapping of artist_ids to meta indices\n",
    "    artist_id_to_meta_idx = {}\n",
    "    for idx, meta in enumerate(metas):\n",
    "        if \"artist_ids\" in meta:\n",
    "            if len(meta[\"artist_ids\"]) == 1:  # only do if there is a single artist\n",
    "                for artist_id in meta[\"artist_ids\"]:\n",
    "                    if artist_id not in artist_id_to_meta_idx:\n",
    "                        artist_id_to_meta_idx[artist_id] = []\n",
    "                    artist_id_to_meta_idx[artist_id].append(idx)\n",
    "\n",
    "    # Build mapping of artist_ids to vox stem paths with duration\n",
    "    artist_id_to_vox_paths = {}\n",
    "    for artist_id, meta_indices in artist_id_to_meta_idx.items():\n",
    "        for meta_idx in meta_indices:\n",
    "            meta = metas[meta_idx]\n",
    "            if \"stems\" in meta and \"Vocals\" in meta[\"stems\"]:\n",
    "                # Extract duration_s from the parent metadata\n",
    "                duration_s = meta.get(\"duration_s\", None)\n",
    "                if artist_id not in artist_id_to_vox_paths:\n",
    "                    artist_id_to_vox_paths[artist_id] = []\n",
    "                artist_id_to_vox_paths[artist_id].append({\n",
    "                    \"path\": meta[\"stems\"][\"Vocals\"],\n",
    "                    \"duration_s\": duration_s,\n",
    "                })\n",
    "\n",
    "    return artist_id_to_meta_idx, artist_id_to_vox_paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b115d923",
   "metadata": {},
   "outputs": [],
   "source": [
    "from suno_utils.utils.text import read_jsonl, write_jsonl\n",
    "\n",
    "#filepath = \"/app2/suno/data/auk_v0/metas_v8_tr_mini.jsonl\"\n",
    "filepath = \"/app2/suno/data/diffusion/v1/metas_v9_tr_filtered.jsonl\"\n",
    "\n",
    "metas = read_jsonl(filepath)\n",
    "#print(len(metas))\n",
    "#metas = pl.read_ndjson(filepath)\n",
    "print(len(metas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f92fe016",
   "metadata": {},
   "outputs": [],
   "source": [
    "artist_id_to_meta_idx, artist_id_to_vox_paths = _build_artist_vox_mappings(metas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7c21f7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "\n",
    "output_dir = \"/home/christian/code/christian/metadata/vox\"\n",
    "output_filename = \"artist_id_to_vox_paths_tr.json\"\n",
    "\n",
    "with open(os.path.join(output_dir, output_filename), \"w\") as f:\n",
    "    json.dump(artist_id_to_vox_paths, f)\n",
    "\n",
    "print(len(artist_id_to_vox_paths))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85c0f377",
   "metadata": {},
   "outputs": [],
   "source": [
    "for artist_id, vox_paths in artist_id_to_vox_paths.items():\n",
    "    print(artist_id, vox_paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf516bd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# filtere\n",
    "print(len(artist_id_to_vox_paths))\n",
    "filtered_artist_ids = [k for k, v in artist_id_to_vox_paths.items() if len(v) > 1]\n",
    "print(len(filtered_artist_ids))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "174ed7f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# count the total number of paths \n",
    "num_stems = [len(v) for k, v in artist_id_to_vox_paths.items() if len(v) > 1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d0e9423",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.hist(num_stems, bins=100)\n",
    "print(f\"min: {np.min(num_stems)}\")\n",
    "print(f\"max: {np.max(num_stems)}\")\n",
    "print(f\"mean: {np.mean(num_stems):.2f}\")\n",
    "print(f\"std: {np.std(num_stems):.2f}\")\n",
    "print(f\"median: {np.median(num_stems)}\")\n",
    "print(f\"count: {len(num_stems)}\")\n",
    "print(f\"total stems: {np.sum(num_stems)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4490998c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from suno_utils.audio import Audio\n",
    "stem_dicts = artist_id_to_vox_paths[filtered_artist_ids[9]]\n",
    "print(len(stem_dicts))\n",
    "\n",
    "for stem_dict in stem_dicts:\n",
    "    audio = Audio.from_file(stem_dict[\"path\"])\n",
    "    audio.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "daf15cd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/christian/miniconda3/envs/suno_env_fa2/lib/python3.10/site-packages/pydantic/_internal/_generate_schema.py:2249: UnsupportedFieldAttributeWarning: The 'repr' attribute with value False was provided to the `Field()` function, which has no effect in the context it was used. 'repr' is field-specific metadata, and can only be attached to a model field using `Annotated` metadata or by assignment. This may have happened because an `Annotated` type alias using the `type` statement was used, or if the `Field()` function was attached to a single member of a union type.\n",
      "  warnings.warn(\n",
      "/home/christian/miniconda3/envs/suno_env_fa2/lib/python3.10/site-packages/pydantic/_internal/_generate_schema.py:2249: UnsupportedFieldAttributeWarning: The 'frozen' attribute with value True was provided to the `Field()` function, which has no effect in the context it was used. 'frozen' is field-specific metadata, and can only be attached to a model field using `Annotated` metadata or by assignment. This may have happened because an `Annotated` type alias using the `type` statement was used, or if the `Field()` function was attached to a single member of a union type.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# load checkpoint\n",
    "import os\n",
    "import torch\n",
    "import sys\n",
    "sys.path.append(\"/home/christian/code/christian/vox_id/\")\n",
    "from train import SpeakerEmbeddingModel, _read_opus_window, _fast_trim_mono, wav_to_logmels\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1440103c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['model', 'optimizer', 'lr_scheduler', 'global_step', 'run_config', 'epoch'])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "SpeakerEmbeddingModel(\n",
       "  (encoder): ECAPA_M(\n",
       "    (frame1): Sequential(\n",
       "      (0): Conv1d(80, 512, kernel_size=(5,), stride=(1,), padding=(2,))\n",
       "      (1): ReLU()\n",
       "      (2): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    )\n",
       "    (b1): Res2NetTDNN(\n",
       "      (inp): Conv1d(512, 1024, kernel_size=(1,), stride=(1,))\n",
       "      (blocks): ModuleList(\n",
       "        (0-6): 7 x Conv1d(128, 128, kernel_size=(3,), stride=(1,), padding=(2,), dilation=(2,))\n",
       "      )\n",
       "      (bn): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (se): SEBlock(\n",
       "        (fc1): Conv1d(1024, 128, kernel_size=(1,), stride=(1,))\n",
       "        (fc2): Conv1d(128, 1024, kernel_size=(1,), stride=(1,))\n",
       "      )\n",
       "      (act): ReLU(inplace=True)\n",
       "    )\n",
       "    (b2): Res2NetTDNN(\n",
       "      (inp): Conv1d(1024, 1024, kernel_size=(1,), stride=(1,))\n",
       "      (blocks): ModuleList(\n",
       "        (0-6): 7 x Conv1d(128, 128, kernel_size=(3,), stride=(1,), padding=(3,), dilation=(3,))\n",
       "      )\n",
       "      (bn): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (se): SEBlock(\n",
       "        (fc1): Conv1d(1024, 128, kernel_size=(1,), stride=(1,))\n",
       "        (fc2): Conv1d(128, 1024, kernel_size=(1,), stride=(1,))\n",
       "      )\n",
       "      (act): ReLU(inplace=True)\n",
       "    )\n",
       "    (b3): Res2NetTDNN(\n",
       "      (inp): Conv1d(1024, 1024, kernel_size=(1,), stride=(1,))\n",
       "      (blocks): ModuleList(\n",
       "        (0-6): 7 x Conv1d(128, 128, kernel_size=(3,), stride=(1,), padding=(4,), dilation=(4,))\n",
       "      )\n",
       "      (bn): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (se): SEBlock(\n",
       "        (fc1): Conv1d(1024, 128, kernel_size=(1,), stride=(1,))\n",
       "        (fc2): Conv1d(128, 1024, kernel_size=(1,), stride=(1,))\n",
       "      )\n",
       "      (act): ReLU(inplace=True)\n",
       "    )\n",
       "    (merge): Conv1d(3072, 3072, kernel_size=(1,), stride=(1,))\n",
       "    (asp): ASP(\n",
       "      (attn): Sequential(\n",
       "        (0): Conv1d(3072, 192, kernel_size=(1,), stride=(1,))\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv1d(192, 3072, kernel_size=(1,), stride=(1,))\n",
       "        (3): Softmax(dim=-1)\n",
       "      )\n",
       "    )\n",
       "    (lin): Linear(in_features=6144, out_features=512, bias=True)\n",
       "    (bn): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  )\n",
       "  (aamsoftmax): AAMSoftmax()\n",
       ")"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#checkpoint_path = \"/app2/suno/checkpoints/2025-10-20_23-46-08_s8724\"\n",
    "checkpoint_path = \"/app2/suno/checkpoints/2025-10-21_00-03-55_s8066\"\n",
    "\n",
    "# load the checkpoint\n",
    "checkpoint = torch.load(os.path.join(checkpoint_path, \"last_ckpt.pt\"))\n",
    "\n",
    "# print the checkpoint\n",
    "print(checkpoint.keys())\n",
    "\n",
    "model = SpeakerEmbeddingModel(n_classes=53170, **checkpoint[\"run_config\"][\"model\"])\n",
    "model.load_state_dict(checkpoint[\"model\"])\n",
    "model.eval()\n",
    "model.cuda()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "43d1cae1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "53808\n"
     ]
    }
   ],
   "source": [
    "# lets load some val data\n",
    "import json\n",
    "val_metas_filepath = \"/home/christian/code/christian/metadata/vox/artist_id_to_vox_paths_tr.json\"\n",
    "with open(val_metas_filepath, \"r\") as f:\n",
    "    val_metas = json.load(f)\n",
    "\n",
    "print(len(val_metas))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1098964d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18615\n",
      "['tgi7nlpa' '2f23pcej' 'qvo5a1pr' 'dy4r87w7' 'gycdqr39' 'dri9f1jk'\n",
      " 'vwdynfhm' '9xy7ygv9' 'gszxqykm' 'v4g3vno1']\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# select 10 artists where we have more than 10 files\n",
    "filtered_artist_ids = [k for k, v in val_metas.items() if len(v) > 5]\n",
    "print(len(filtered_artist_ids))\n",
    "\n",
    "# select 10 random artists from the list\n",
    "random_artist_ids = np.random.choice(filtered_artist_ids, size=10, replace=False)\n",
    "print(random_artist_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b0bbdfee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# UMAP Visualization Notebook Cell\n",
    "# Run this in your notebook after training\n",
    "\n",
    "import os\n",
    "import json\n",
    "import torch\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import umap\n",
    "from tqdm import tqdm\n",
    "import random\n",
    "\n",
    "# Import from your training script\n",
    "from train import (\n",
    "    SpeakerEmbeddingModel,\n",
    "    wav_to_logmels,\n",
    "    _fast_trim_mono,\n",
    "    _get_segments,\n",
    "    Audio,\n",
    ")\n",
    "\n",
    "\n",
    "def create_umap_plot(\n",
    "    model, metas_filepath, num_artists=15, files_per_artist=8, device=\"cuda\"\n",
    "):\n",
    "    \"\"\"Create UMAP plot of speaker embeddings.\"\"\"\n",
    "\n",
    "    # Load metadata\n",
    "    with open(metas_filepath, \"r\") as f:\n",
    "        metas = json.load(f)\n",
    "\n",
    "    # Sample artists and files\n",
    "    #artist_ids = list(metas.keys())\n",
    "    #sampled_artists = random.sample(artist_ids, min(num_artists, len(artist_ids)))\n",
    "\n",
    "    # select 10 artists where we have more than 10 files\n",
    "    filtered_artist_ids = [k for k, v in metas.items() if len(v) > 4]\n",
    "    print(len(filtered_artist_ids))\n",
    "\n",
    "    # select 10 random artists from the list\n",
    "    sampled_artists = np.random.choice(filtered_artist_ids, size=num_artists, replace=False)\n",
    "    print(sampled_artists)\n",
    "\n",
    "    print(\n",
    "        f\"Sampling {len(sampled_artists)} artists with {files_per_artist} files each...\"\n",
    "    )\n",
    "\n",
    "    # Process audio files and collect embeddings\n",
    "    embeddings = []\n",
    "    labels = []\n",
    "\n",
    "    for artist_id in tqdm(sampled_artists, desc=\"Processing artists\"):\n",
    "        files = metas[artist_id]\n",
    "        sampled_files = random.sample(files, min(files_per_artist, len(files)))\n",
    "\n",
    "        for file_info in sampled_files:\n",
    "            audio_path = file_info[\"path\"]\n",
    "\n",
    "            try:\n",
    "                # Load audio\n",
    "                audio = Audio.from_file(audio_path, n_channels=1)\n",
    "\n",
    "                # Trim silence\n",
    "                audio_trim, _ = _fast_trim_mono(audio.array_float, audio.sample_rate)\n",
    "\n",
    "                # Get 3-second segment\n",
    "                segments = _get_segments(\n",
    "                    audio_trim,\n",
    "                    audio.sample_rate,\n",
    "                    num_segments=1,\n",
    "                    segment_duration_sec=3.0,\n",
    "                )\n",
    "\n",
    "                if len(segments) == 0:\n",
    "                    continue\n",
    "\n",
    "                # Convert to tensor\n",
    "                segment_tensor = torch.tensor(\n",
    "                    segments[0], dtype=torch.float32\n",
    "                ).unsqueeze(0)\n",
    "\n",
    "                # Convert to log-mels\n",
    "                logmels = wav_to_logmels(segment_tensor, audio.sample_rate, n_mels=80)\n",
    "\n",
    "                # Get embedding\n",
    "                with torch.no_grad():\n",
    "                    embedding = model.embed(logmels.to(device))\n",
    "\n",
    "                embeddings.append(embedding.cpu().numpy().flatten())\n",
    "                labels.append(artist_id)\n",
    "\n",
    "            except Exception as e:\n",
    "                print(f\"Error processing {audio_path}: {e}\")\n",
    "                continue\n",
    "\n",
    "    if len(embeddings) == 0:\n",
    "        print(\"No embeddings generated!\")\n",
    "        return\n",
    "\n",
    "    # Convert to numpy arrays\n",
    "    embeddings = np.array(embeddings)\n",
    "    print(\n",
    "        f\"Generated {len(embeddings)} embeddings with dimension {embeddings.shape[1]}\"\n",
    "    )\n",
    "\n",
    "    # Create UMAP embedding\n",
    "    print(\"Computing UMAP...\")\n",
    "    reducer = umap.UMAP(\n",
    "        n_components=2, random_state=42, n_neighbors=15, min_dist=0.1, metric=\"cosine\"\n",
    "    )\n",
    "    umap_embedding = reducer.fit_transform(embeddings)\n",
    "\n",
    "    # Create plot\n",
    "    print(\"Creating visualization...\")\n",
    "    plt.figure(figsize=(14, 10))\n",
    "\n",
    "    # Get unique artists and assign colors\n",
    "    unique_artists = list(set(labels))\n",
    "    colors = plt.cm.tab20(np.linspace(0, 1, len(unique_artists)))\n",
    "    artist_to_color = dict(zip(unique_artists, colors))\n",
    "\n",
    "    # Plot points\n",
    "    for artist_id in unique_artists:\n",
    "        mask = np.array(labels) == artist_id\n",
    "        plt.scatter(\n",
    "            umap_embedding[mask, 0],\n",
    "            umap_embedding[mask, 1],\n",
    "            c=[artist_to_color[artist_id]],\n",
    "            label=artist_id,\n",
    "            alpha=0.7,\n",
    "            s=60,\n",
    "            edgecolors=\"black\",\n",
    "            linewidth=0.5,\n",
    "        )\n",
    "\n",
    "    plt.title(\n",
    "        f\"UMAP Visualization of Speaker Embeddings\\n({len(embeddings)} samples from {len(unique_artists)} artists)\",\n",
    "        fontsize=16,\n",
    "        fontweight=\"bold\",\n",
    "    )\n",
    "    plt.xlabel(\"UMAP Dimension 1\", fontsize=14)\n",
    "    plt.ylabel(\"UMAP Dimension 2\", fontsize=14)\n",
    "\n",
    "    # Add legend\n",
    "    if len(unique_artists) <= 20:\n",
    "        plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\", fontsize=10)\n",
    "    else:\n",
    "        print(\n",
    "            f\"Too many artists ({len(unique_artists)}) for legend. Consider reducing num_artists.\"\n",
    "        )\n",
    "\n",
    "    plt.grid(True, alpha=0.3)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "    # Print statistics\n",
    "    print(f\"\\nStatistics:\")\n",
    "    print(f\"Total embeddings: {len(embeddings)}\")\n",
    "    print(f\"Number of artists: {len(unique_artists)}\")\n",
    "    print(f\"Embedding dimension: {embeddings.shape[1]}\")\n",
    "    print(f\"UMAP shape: {umap_embedding.shape}\")\n",
    "\n",
    "    return umap_embedding, embeddings, labels\n",
    "\n",
    "\n",
    "# Usage example:\n",
    "# umap_coords, embeddings, labels = create_umap_plot(\n",
    "#     model,\n",
    "#     \"/home/christian/code/christian/metadata/vox/artist_id_to_vox_paths_tr.json\",\n",
    "#     num_artists=15,\n",
    "#     files_per_artist=8\n",
    "# )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b2bc9c1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20934\n",
      "['5e7hpr4o' '3ww2nqup' 'a8rmoidf' '2ncbx9eq' 'tdgamswo' '8657cqta'\n",
      " 'jkny5ee3' '5m5q2o8d' 'zj1q4m6k' '8tz0kuj7' 'cbhtiszu' 'nt2a76np'\n",
      " 'cklrzn3n' 'wo3mz7wp' '79f0v5d4' 'tp8qnqhy' '7506v9jh' 'hpr28qi6'\n",
      " 'zc8mmw5o' 'vgj3t8ud' '24suqrvw' 'l4fq5bbn' 'dkbm6662' 'w4trnxpe'\n",
      " 'd5r123da' '02o1g9mh' 'hhel57j1' 'funh6z90' 'kkhm3r7x' '6u5do794'\n",
      " '4g86b6cx' 'u073gzmk' 'o2ni9h6n' 't0g5l484' 'r3k2ry07' 'pfqumbv2'\n",
      " '01rva2fh' '31qrtvwn' 'cm0oo7pf' '5czjfq8w' '25jc5w45' 'a928qw7r'\n",
      " 'j0905904' 'mvggd6ut' 'u9g786j0' 'ynvgzf9f' 'uv6pcwd4' 'xdtkxpnh'\n",
      " 'gke7x530' '8w218v3g']\n",
      "Sampling 50 artists with 10 files each...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Processing artists: 100%|██████████| 50/50 [08:22<00:00, 10.04s/it]\n",
      "/home/christian/miniconda3/envs/suno_env_fa2/lib/python3.10/site-packages/umap/umap_.py:1952: UserWarning: n_jobs value 1 overridden to 1 by setting random_state. Use no seed for parallelism.\n",
      "  warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated 418 embeddings with dimension 512\n",
      "Computing UMAP...\n",
      "Creating visualization...\n",
      "Too many artists (50) for legend. Consider reducing num_artists.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Statistics:\n",
      "Total embeddings: 418\n",
      "Number of artists: 50\n",
      "Embedding dimension: 512\n",
      "UMAP shape: (418, 2)\n"
     ]
    }
   ],
   "source": [
    "umap_coords, embeddings, labels = create_umap_plot(\n",
    "     model,\n",
    "     \"/home/christian/code/christian/metadata/vox/artist_id_to_vox_paths_tr.json\",\n",
    "     num_artists=50,\n",
    "     files_per_artist=10\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee0c23b3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db84b458",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "suno_env_fa2",
   "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.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}