{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "d31d8850", "metadata": {}, "outputs": [], "source": [ "import os\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"" ] }, { "cell_type": "code", "execution_count": 2, "id": "7cd4c0dd", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Warning : `load_model` does not return WordVectorModel or SupervisedModel any more, but a `FastText` object which is very similar.\n" ] } ], "source": [ "import tqdm\n", "import math\n", "import torch\n", "import random\n", "import funcy\n", "import copy\n", "import gc\n", "import re\n", "import json\n", "import tempfile\n", "import collections\n", "import pandas as pd\n", "import numpy as np\n", "import fasttext\n", "from joblib import Parallel, delayed\n", "\n", "from suno_utils.audio import Audio\n", "from suno_utils.utils.text import write_jsonl, read_jsonl, write_json, read_json, normalize_whitespace\n", "from suno_utils.utils.s3 import read_from_s3, check_s3_file_exists, open_from_s3\n", "from suno_utils.utils.tokenizers import tokenize\n", "from suno_utils.harvest.youtube.constants.text_lang import BASE_TO_FASTTEXT_REMAP\n", "\n", "LANG_ID_MODEL_FP = \"s3://suno-data/georg/trained_models/chirp_v1/lid.176.bin\"\n", "text_lang_model = read_from_s3(LANG_ID_MODEL_FP, read_f=fasttext.load_model)\n", "\n", "def _get_text_lang(text):\n", " \"\"\"get probability of input language for text\"\"\"\n", " text = text.replace(\"’\", \"'\").lower()\n", " text = re.sub(r\"\\[.+?\\]\", \" \", text)\n", " text = normalize_whitespace(text)\n", " out = text_lang_model.predict(text, k=1)\n", " lang_str = out[0][0]\n", " p_lang = out[1][0]\n", " lang = lang_str.split(\"__\")[-1]\n", " lang = BASE_TO_FASTTEXT_REMAP.get(lang, lang)\n", "# if p_lang >= 0.8:\n", "# return lang\n", " return p_lang, lang\n", "\n", "\n", "TMP_DIR = os.path.join(os.getcwd(), \"tmp\")\n", "os.makedirs(TMP_DIR, exist_ok=True)" ] }, { "cell_type": "code", "execution_count": null, "id": "9e30f743", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "cb688ac7", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "d9d50793", "metadata": {}, "source": [ "## genius_hq" ] }, { "cell_type": "code", "execution_count": 4, "id": "8f428b8f", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/georg/anaconda3/envs/ml10/lib/python3.10/site-packages/Bio/pairwise2.py:278: BiopythonDeprecationWarning: Bio.pairwise2 has been deprecated, and we intend to remove it in a future release of Biopython. As an alternative, please consider using Bio.Align.PairwiseAligner as a replacement, and contact the Biopython developers if you still need the Bio.pairwise2 module.\n", " warnings.warn(\n" ] } ], "source": [ "from Bio import pairwise2\n", "\n", "from suno_utils.utils.metrics import get_cer\n", "from suno_utils.tasks.hoot import parse_lyrics, legacy_parse_lyrics, EMBEDDING_RATE as HOOT_EMBEDDING_RATE\n", "from suno_utils.utils.lyrics import remove_speakers" ] }, { "cell_type": "code", "execution_count": 5, "id": "54a969c0", "metadata": {}, "outputs": [], "source": [ "# base_metas = read_from_s3(\"s3://suno-data/datasets/bundles/v1/genius_hq/metas.jsonl\", read_f=read_jsonl)\n", "# raw_lyrics_map = {m[\"id\"]: m[\"lyrics\"] for m in base_metas}\n", "# del base_metas\n", "# gc.collect();" ] }, { "cell_type": "code", "execution_count": 6, "id": "2cd505d5", "metadata": {}, "outputs": [], "source": [ "base_metas = read_from_s3(\"s3://suno-data/datasets/bundles/v1/genius_hq/metas_plus.jsonl\", read_f=read_jsonl)\n", "# TODO: original IDs are already unique here, but did we resolve correctly by highest genius views?\n", "# could be a way to filter translations that don't contain the word 'translation'" ] }, { "cell_type": "code", "execution_count": 7, "id": "6ac295a0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2090009 clips\n", "858539 filtered clips\n", "52575 hours\n" ] } ], "source": [ "print(len(base_metas), \"clips\")\n", "metas = []\n", "for m in base_metas:\n", " if (\n", " m[\"genius_views\"] < 20 or \n", " m[\"youtube_views\"] < 100 or \n", " m[\"lang\"] is None or \n", " m[\"lang\"].lower()[:2] != \"en\" or \n", " \"translation\" in m[\"genius_slug\"].lower() or\n", " m[\"duration_s\"] < 2*60 or\n", " m[\"duration_s\"] > 8*60 or\n", " len(m[\"lyrics\"]) < 512 or\n", " len(m[\"lyrics\"]) > 6144 or\n", " _get_text_lang(m[\"lyrics\"])[1] != \"en\"\n", " ):\n", " continue\n", " new_m = {\n", " \"id\": m[\"id\"],\n", " \"lyrics\": m[\"lyrics\"].strip(),\n", " \"duration_s\": m[\"duration_s\"],\n", " \"lang\": m[\"lang\"],\n", " \"audio_filepath\": m[\"audio_filepath\"],\n", " \"original_id\": m[\"original_id\"],\n", " \"genius_slug\": m[\"genius_slug\"],\n", " }\n", " metas.append(new_m)\n", "print(len(metas), \"filtered clips\")\n", "print(round(sum(m[\"duration_s\"] for m in metas)/60/60), \"hours\")\n", "metas_map = {m[\"id\"]: m for m in metas}\n", "# 2090009 clips\n", "# 858539 filtered clips\n", "# 52575 hours of english" ] }, { "cell_type": "code", "execution_count": 8, "id": "29cb5d64", "metadata": {}, "outputs": [], "source": [ "del base_metas, metas\n", "gc.collect();" ] }, { "cell_type": "markdown", "id": "a1cc806d", "metadata": {}, "source": [ "#### do alignment (will be cache in TMP_DIR)" ] }, { "cell_type": "code", "execution_count": 8, "id": "d350830c", "metadata": {}, "outputs": [], "source": [ "# we need tokenzier to decode greedy hoot preds\n", "# (use a dict instead of model to allow multiprocessing)\n", "with open(\"/home/georg/models/hoot_vocab.json\") as f:\n", " vocab = json.load(f)\n", "inv_vocab = {v: k for k, v in vocab.items()}\n", "def decode_token_ids(token_ids):\n", " prev_idx = None\n", " tokens = []\n", " for idx in token_ids:\n", " idx = int(idx)\n", " if idx == prev_idx:\n", " continue\n", " if idx != len(vocab):\n", " tokens.append(inv_vocab[idx])\n", " prev_idx = idx\n", " return \"\".join(tokens).replace(\"▁\", \" \").strip()\n", "\n", "MIN_SEGMENT_DURATION_S = 5 # TODO: should this be larger??\n", "MAX_SEGMENT_DURATION_S = 2*60\n", "MAX_PAD_BOUNDARY_S = 8\n", "MAX_PAD_S = 2\n", "EARLY_VERSE_TERMINATE_CHANCE = 0.9" ] }, { "cell_type": "code", "execution_count": 9, "id": "a273ecbd", "metadata": {}, "outputs": [], "source": [ "def _norm_lyrics_to_plain(text):\n", " text = text.lower()\n", " text = re.sub(r\"\\[.*?\\]\", \" \", text)\n", " text = re.sub(r\"[^a-z\\'\\s]\", \" \", text)\n", " return normalize_whitespace(text)\n", "\n", "def _get_alignable_tokens(text):\n", " # replace all metatags so we don't tokenize within\n", " tag_repl_map = {}\n", " safe_text = \"\"\n", " offs = 0\n", " for m in re.finditer(r\"\\[.*?\\]\", text):\n", " if m.start() - offs > 0:\n", " safe_text += text[offs:m.start()]\n", " uid = str(random.randint(9999999, 99999999))\n", " safe_text += uid\n", " tag_repl_map[uid] = m.group()\n", " offs = m.end()\n", " if len(text) - offs > 0:\n", " safe_text += text[offs:]\n", " # get tokens that we want to align\n", " safe_words = [s for s in re.split(\"([A-Za-z\\']+)\", safe_text) if len(s) > 0]\n", " words_to_align = [\n", " (n, word.lower()) \n", " for n, word in enumerate(safe_words) \n", " if re.match(r\"^[a-z\\']+$\", word.lower())\n", " ]\n", " # add back in metatags\n", " words = []\n", " for safe_word in safe_words:\n", " word = safe_word\n", " for k, v in tag_repl_map.items():\n", " if k in safe_word:\n", " word = word.replace(k, v)\n", " words.append(word)\n", " return words, words_to_align\n", "\n", "def _assign_word_timings(words_to_align, aligned_words):\n", " flat_words_a = [w for _, w in words_to_align]\n", " flat_words_b = [m[\"text\"] for m in aligned_words]\n", " assert(len(set(flat_words_a) & set(flat_words_b)) >= 0.75 * len(set(flat_words_a) | set(flat_words_b)))\n", " alignment = pairwise2.align.globalxx(\n", " flat_words_a, flat_words_b, gap_char=[\"*\"]\n", " )[0]\n", " assert(np.mean([int(e != \"*\") for e in alignment.seqA]) >= 0.75)\n", " assert(np.mean([int(e != \"*\") for e in alignment.seqB]) >= 0.75)\n", " # assign align info to tokens in ground truth\n", " flat_words_a_timed = []\n", " idx_a = 0\n", " idx_b = 0\n", " for a, b in zip(alignment.seqA, alignment.seqB):\n", " if a != \"*\":\n", " start_s = None\n", " end_s = None\n", " p_align = None\n", " assert(a == words_to_align[idx_a][1])\n", " idx = words_to_align[idx_a][0]\n", " if b != \"*\":\n", " start_s = aligned_words[idx_b][\"start_s\"]\n", " end_s = aligned_words[idx_b][\"end_s\"]\n", " p_align = aligned_words[idx_b][\"p_align\"]\n", " flat_words_a_timed.append({\n", " \"word\": a,\n", " \"start_s\": round(start_s, 2),\n", " \"end_s\": round(end_s, 2),\n", " \"p_align\": round(p_align, 3),\n", " \"orig_idx\": idx,\n", " })\n", " idx_a += 1\n", " if b != \"*\":\n", " idx_b += 1\n", " return flat_words_a_timed\n", "\n", "def _merge_metatags_whitespace(all_words_timed):\n", " # generally forward merge cause of \"[Chorus]\\nFirst line.\"\n", " # but also maybe backward with first part \")\\n\\n[Verse]\\n\"\n", " merged_words_timed = []\n", " n = 0\n", " while True:\n", " if n == len(all_words_timed):\n", " break\n", " if \"success\" not in all_words_timed[n]:\n", " # we have whitespace so lets see if we can merge a prefix to previous\n", " word = all_words_timed[n][\"word\"]\n", " if \"\\n\" in word and word.index(\"\\n\") > 0 and n > 0 and merged_words_timed[-1].get(\"success\", False):\n", " merged_words_timed[-1][\"word\"] += word[:word.index(\"\\n\")]\n", " word = word[word.index(\"\\n\"):]\n", " elif n == len(all_words_timed) - 1:\n", " merged_words_timed[-1][\"word\"] += word\n", " n += 1\n", " continue\n", " # lets see if we can merge forward \n", " if len(all_words_timed)-1 > n and all_words_timed[n+1].get(\"success\", False):\n", " # merge forward\n", " new_m = {\n", " \"word\": word + all_words_timed[n+1][\"word\"],\n", " \"success\": all_words_timed[n+1][\"success\"],\n", " \"start_s\": all_words_timed[n+1][\"start_s\"],\n", " \"end_s\": all_words_timed[n+1][\"end_s\"],\n", " \"p_align\": all_words_timed[n+1][\"p_align\"],\n", " }\n", " merged_words_timed.append(new_m)\n", " n += 2\n", " continue\n", " else:\n", " merged_words_timed.append({\"word\": word})\n", " n += 1\n", " continue\n", " else:\n", " merged_words_timed.append(copy.deepcopy(all_words_timed[n]))\n", " n += 1\n", " continue\n", " return merged_words_timed\n", "\n", "# pad words\n", "def _pad_words(merged_words_timed, duration_s):\n", " # calc max duration\n", " duration_s = max(duration_s, max([m[\"end_s\"] for m in merged_words_timed if m.get(\"success\", False)]))\n", " # make copy so we can modify in place\n", " padded_words_timed = copy.deepcopy(merged_words_timed)\n", " for n, m in enumerate(padded_words_timed):\n", " if not m.get(\"success\", False):\n", " continue\n", " # do left padding\n", " if n == 0:\n", " if m[\"start_s\"] <= MAX_PAD_BOUNDARY_S:\n", " m[\"start_s\"] = 0\n", " else:\n", " m[\"start_s\"] = m[\"start_s\"] - MAX_PAD_S\n", " else:\n", " mm = merged_words_timed[n-1]\n", " if mm.get(\"success\", False):\n", " if m[\"start_s\"] - mm[\"end_s\"] > 0.01:\n", " m[\"start_s\"] -= min(MAX_PAD_S, (m[\"start_s\"] - mm[\"end_s\"]) / 2)\n", " m[\"start_s\"] = max(0, m[\"start_s\"])\n", " m[\"start_s\"] = min(duration_s, m[\"start_s\"])\n", " # do right padding \n", " if n == len(merged_words_timed) - 1:\n", " if duration_s - m[\"end_s\"] <= MAX_PAD_BOUNDARY_S:\n", " m[\"end_s\"] = duration_s\n", " else:\n", " m[\"end_s\"] = m[\"end_s\"] + MAX_PAD_S\n", " else:\n", " mm = merged_words_timed[n+1]\n", " if mm.get(\"success\", False):\n", " if mm[\"start_s\"] - m[\"end_s\"] > 0.01:\n", " m[\"end_s\"] += min(MAX_PAD_S, (mm[\"start_s\"] - m[\"end_s\"]) / 2)\n", " m[\"end_s\"] = max(0, m[\"end_s\"])\n", " m[\"end_s\"] = min(duration_s, m[\"end_s\"])\n", " m[\"start_s\"] = round(m[\"start_s\"], 2)\n", " m[\"end_s\"] = round(m[\"end_s\"], 2)\n", " return padded_words_timed\n", "\n", "def _merge_into_lines(padded_words_timed):\n", " # first reconsitute lines so we don't break mid-line\n", " lines = []\n", " tmp_line = []\n", " for m in padded_words_timed:\n", " if \"\\n\" in m[\"word\"] and len(tmp_line) > 0:\n", " lines.append(tmp_line)\n", " tmp_line = []\n", " tmp_line.append(m)\n", " if len(tmp_line) > 0:\n", " lines.append(tmp_line)\n", " # simplify and classify as good breakpoints\n", " annotated_lines = []\n", " for line in lines:\n", " assert(len(line) > 0)\n", " text = \"\".join(m[\"word\"] for m in line)\n", " start_s = None\n", " end_s = None\n", " l = [m[\"start_s\"] for m in line[:2] if \"start_s\" in m and m[\"start_s\"] is not None]\n", " if len(l) > 0:\n", " start_s = l[0]\n", " l = [m[\"end_s\"] for m in line[-2:] if \"end_s\" in m and m[\"end_s\"] is not None]\n", " if len(l) > 0:\n", " end_s = l[-1]\n", " success = (\n", " start_s is not None and \n", " end_s is not None and\n", " np.mean([m.get(\"success\", False) for m in line]) >= 0.75\n", " # do mean of success > 0.75\n", " )\n", " new_m = {\n", " \"text\": text,\n", " \"success\": success,\n", " }\n", " if success:\n", " new_m[\"start_s\"] = start_s\n", " new_m[\"end_s\"] = end_s\n", " annotated_lines.append(new_m)\n", " return annotated_lines\n", "\n", "def _collect_valid_segment_from_lines(annotated_lines):\n", " # group lines into segments\n", " valid_break_lines = [(n, line) for n, line in enumerate(annotated_lines) if line[\"success\"]] \n", " segments = []\n", " tmp_segment = []\n", " for idx, line in valid_break_lines:\n", " \n", " try:\n", " # check if we wanna evict\n", " if (\n", " len(tmp_segment) > 0 and \n", " (\n", " (\n", " (\n", " re.match(r\"^\\s*\\n\\s*\\n\\s*\", line[\"text\"]) or\n", " re.match(r\"^\\s*\\[.*\\]\\s*$\", line[\"text\"])\n", " ) and \n", " random.random() >= EARLY_VERSE_TERMINATE_CHANCE and\n", " len(normalize_whitespace(line[\"text\"])) >= 25\n", " ) or \n", " line[\"end_s\"] - tmp_segment[0][-1][\"start_s\"] > MAX_SEGMENT_DURATION_S\n", " )\n", " ):\n", " segments.append(tmp_segment)\n", " tmp_segment = []\n", " except:\n", " import pdb; pdb.set_trace()\n", " \n", " \n", " tmp_segment.append((idx, line))\n", " if len(tmp_segment) > 0:\n", " segments.append(tmp_segment)\n", " # splice back in non-success lines\n", " all_segments = []\n", " offs = 0\n", " for seg in segments:\n", " first_idx = seg[0][0]\n", " last_idx = seg[-1][0]\n", " if first_idx > offs:\n", " all_segments.append(annotated_lines[offs:first_idx])\n", " all_segments.append(annotated_lines[first_idx:last_idx+1])\n", " offs = last_idx+1\n", " last_idx = segments[-1][-1][0] + 1\n", " if last_idx < len(annotated_lines):\n", " all_segments.append(annotated_lines[last_idx:len(annotated_lines)])\n", " # merge and filter segment lines\n", " # TODO: ignoring instrumental stuff here (add as empty string in future)\n", " merged_segments = []\n", " for lines in all_segments:\n", " assert(len(lines) > 0)\n", " text = \"\".join(m[\"text\"] for m in lines)\n", " start_s = lines[0].get(\"start_s\")\n", " end_s = lines[-1].get(\"end_s\")\n", " success = (\n", " start_s is not None and \n", " end_s is not None and\n", " np.mean([m[\"success\"] for m in lines]) >= 0.75\n", " # do mean of success > 0.75\n", " )\n", " if not success or end_s - start_s > MAX_SEGMENT_DURATION_S or end_s - start_s < MIN_SEGMENT_DURATION_S:\n", " continue\n", " merged_segments.append({\n", " \"text\": text,\n", " \"start_s\": start_s,\n", " \"end_s\": end_s,\n", " })\n", " return merged_segments\n", "\n", "def _verify_durations(segments, duration_s):\n", " assert(\n", " duration_s + 0.01 > \n", " np.sum([e[\"end_s\"] - e[\"start_s\"] for e in segments if e.get(\"start_s\") is not None])\n", " )" ] }, { "cell_type": "code", "execution_count": 10, "id": "3cd6dcbc", "metadata": {}, "outputs": [], "source": [ "# arr[0]: probs.argmax(axis=-1), # decoded ID\n", "# arr[1]: probs.max(axis=-1), # prob decoded ID\n", "# arr[2]: probs[:,-1], # prob blank\n", "\n", "def _get_aligned_lyrics(align_metas, align_archive, silent=False):\n", " aligned_lyrics_map = {}\n", " tot_duration_s = 0\n", " tot_duration_silence_s = 0\n", " for m in tqdm.tqdm(align_metas, disable=silent):\n", " arr = align_archive[m[\"id\"]]\n", " if m[\"id\"] not in metas_map:\n", " continue\n", " meta = metas_map[m[\"id\"]]\n", " if meta[\"lang\"][:2].lower() != \"en\":\n", " continue\n", " if \"alignment\" not in m:\n", " continue\n", " aligned_words = m[\"alignment\"]\n", " if len(aligned_words) <= 50:\n", " continue\n", " duration_s = round(arr.shape[-1] / HOOT_EMBEDDING_RATE, 2)\n", " if duration_s < 30 or duration_s > 10*60 or np.abs(meta[\"duration_s\"] - duration_s) > 5:\n", " continue\n", " # check language and alignment quality\n", " p_silence = round(arr[2].mean(), 3)\n", " weights = 1 - arr[2]\n", " p_en = round((arr[1]*weights).sum() / weights.sum(), 3)\n", " p_align = np.mean([mm[\"p_align\"] for mm in aligned_words])\n", " if p_en < 0.65 or p_align < 0.1:\n", " continue\n", " true_text_norm = _norm_lyrics_to_plain(meta[\"lyrics\"])\n", " greedy_preds = decode_token_ids(arr[0])\n", " cer_val = round(get_cer(true_text_norm, greedy_preds), 3)\n", " if cer_val > 0.75:\n", " continue\n", " # do alignment\n", " all_words, words_to_align = _get_alignable_tokens(meta[\"lyrics\"])\n", " try:\n", " timed_words = _assign_word_timings(words_to_align, aligned_words)\n", " except:\n", " # sometimes error on np.mean with None\n", " continue\n", " # add into full words\n", " timed_words_map = {m[\"orig_idx\"]: m for m in timed_words}\n", " all_words_timed = []\n", " for n, w in enumerate(all_words):\n", " if n not in timed_words_map:\n", " all_words_timed.append({\"word\": w})\n", " continue\n", " assert(w.lower() == timed_words_map[n][\"word\"]) \n", " new_m = {\n", " \"word\": w,\n", " \"success\": timed_words_map[n][\"start_s\"] is not None,\n", " \"start_s\": timed_words_map[n][\"start_s\"],\n", " \"end_s\": timed_words_map[n][\"end_s\"],\n", " \"p_align\": timed_words_map[n][\"p_align\"],\n", " }\n", " all_words_timed.append(new_m)\n", " # merge meta tags forward for timing (eg [Verse 1])\n", " merged_words_timed = _merge_metatags_whitespace(all_words_timed)\n", " try:\n", " _verify_durations(merged_words_timed, duration_s)\n", " except:\n", " # this shouldn't happen but is super rare so fine for noq\n", " continue\n", " # pad words if possible\n", " padded_words_timed = _pad_words(merged_words_timed, duration_s)\n", " try:\n", " _verify_durations(padded_words_timed, duration_s)\n", " except:\n", " # this shouldn't happen but is super rare so fine for noq\n", " continue\n", " # merge into lines\n", " annotated_lines = _merge_into_lines(padded_words_timed)\n", " try:\n", " _verify_durations(annotated_lines, duration_s)\n", " except:\n", " # this shouldn't happen but is super rare so fine for noq\n", " continue\n", " # merge into segments and filer\n", " valid_segments = _collect_valid_segment_from_lines(annotated_lines)\n", " try:\n", " _verify_durations(valid_segments, duration_s)\n", " except:\n", " # this shouldn't happen but is super rare so fine for noq\n", " continue\n", " # if less than hald the string aligned maybe skip as well\n", " retained_text = \"\".join(m[\"text\"] for m in valid_segments)\n", " if len(retained_text) / len(meta[\"lyrics\"]) < 0.5:\n", " continue\n", " assert(all(\n", " MIN_SEGMENT_DURATION_S - 0.1 <= m[\"end_s\"] - m[\"start_s\"] <= MAX_SEGMENT_DURATION_S + 0.1 \n", " for m in valid_segments\n", " ))\n", " aligned_lyrics_map[m[\"id\"]] = valid_segments\n", " return aligned_lyrics_map\n", "\n", "def collect_lyrics(work_item):\n", " archive_nr = work_item\n", " base_url = \"s3://suno-data/datasets/bundles/v1/genius_hq\"\n", " align_metas = read_from_s3(\n", " os.path.join(base_url, \"hoot_logits\", \"metas\", f\"part_{archive_nr}.jsonl\"), read_f=read_jsonl\n", " )\n", " align_archive = read_from_s3(\n", " os.path.join(base_url, \"hoot_logits\", f\"part_{archive_nr}.npz\"), read_f=np.load\n", " )\n", " aligned_lyrics_map = _get_aligned_lyrics(align_metas, align_archive, silent=True)\n", " return [(k, v) for k, v in aligned_lyrics_map.items()]" ] }, { "cell_type": "code", "execution_count": 11, "id": "04a716c4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "253/1000, retained\n" ] } ], "source": [ "# test output\n", "out = collect_lyrics(0)\n", "print(f\"{len(out)}/1000, retained\")\n", "# 255/1000, retained\n", "# should be ~500k songs retained\n", "# should be ~30k hours max (less cause segments)" ] }, { "cell_type": "code", "execution_count": null, "id": "93991c09", "metadata": {}, "outputs": [], "source": [ "# # plot duration hist and duration retained\n", "# l = []\n", "# for _, m in out:\n", "# for mm in m:\n", "# l.append((mm[\"end_s\"] - mm[\"start_s\"]))\n", "# print(round(np.sum(l)/60/60, 1), \"hours retained\")\n", "# pd.Series(l).hist(bins=50);\n", "# # 12.9 hours retained" ] }, { "cell_type": "code", "execution_count": 15, "id": "5f106b58", "metadata": { "scrolled": true }, "outputs": [], "source": [ "# # listen to some\n", "# k, segments = random.choice(out)\n", "# meta = metas_map[k]\n", "# audio = Audio.from_s3(meta[\"audio_filepath\"])\n", "# print(f\"{meta['id']}\")\n", "# print(meta[\"genius_slug\"])\n", "# print(\"-\"*10)\n", "# for s in segments:\n", "# print(s[\"text\"])\n", "# audio.get_segment(s[\"start_s\"], s[\"end_s\"]).play()\n", "# print(\"-\"*10)" ] }, { "cell_type": "code", "execution_count": 16, "id": "6f809ee6", "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ " 0%| | 0/44 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# max is prob around 1000\n", "pd.Series(n_tokens_list).hist(bins=50);" ] }, { "cell_type": "code", "execution_count": null, "id": "f1611437", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "71969894", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "75bdde26", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "80cc74c5", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.12" } }, "nbformat": 4, "nbformat_minor": 5 }