{ "cells": [ { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import ast\n", "import os\n", "import shutil\n", "import sys\n", "from collections import defaultdict\n", "import json\n", "\n", "import numpy as np\n", "import pandas as pd\n", "from preference_data_preparation_4min_30b_task import *\n", "from sklearn.model_selection import train_test_split\n", "from suno_utils.utils.s3 import download_s3_files\n", "from suno_utils.utils.text import read_json, read_jsonl, write_json, write_jsonl\n", "from tqdm import tqdm\n", "import matplotlib.pyplot as plt\n", "\n", "pd.set_option(\"display.max_rows\", 500)\n", "pd.set_option(\"display.max_columns\", 500)\n", "pd.set_option(\"display.width\", 1000)\n", "\n", "# setup autoload\n", "%load_ext autoreload\n", "%autoreload 2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "OUT_DATA_DIR = \"/app/suno/data/dpo/13b_s32_v30/\"\n", "os.makedirs(OUT_DATA_DIR, exist_ok=True)\n", "shutil.copyfile(\n", " \"/app/suno/data/dpo/7v_v20_full/tokenizer_60k.json\",\n", " os.path.join(OUT_DATA_DIR, \"tokenizer_60k.json\"),\n", ")\n", "NPZ_DIR = \"/app/suno/data/dpo/13b_s32_npz\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# df = pd.read_csv(\n", "# \"/home/tony/Data/Preference/13b_v0/interesting_clips_v3p5_s_8_20240813.csv\"\n", "# ) # , engine='python')\n", "df = pd.read_pickle(\n", " \"/home/tony/Data/Preference/13b_v32/interesting_clips_v4_h_s_32_20250303_full_long.pkl\"\n", ") # , engine='python')\n", "print(\"Preference data shape\", df.shape)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "converted_paths = os.listdir(NPZ_DIR)\n", "print(len(converted_paths))\n", "\n", "converted_paths = set([f.replace(\".npz\", \"\") for f in converted_paths])\n", "print(len(converted_paths))\n", "\n", "if \"cycle\" in NPZ_DIR:\n", " # hack in the cycle label\n", " df[\"s3_id\"] += \"_gen_cycle\"\n", "\n", "print(\"pre-downloaded df\", df.shape)\n", "df[df[\"s3_id\"].isin(converted_paths)].shape\n", "df = df[df[\"s3_id\"].isin(converted_paths)].copy()\n", "print(\"downloaded df\", df.shape)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df[\"is_13b\"] = df[\"model_name\"].str.contains(\"-s-\")\n", "df[\"is_13b\"].value_counts()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(df[\"is_public\"].value_counts())\n", "# remove public for now cause fucking users\n", "# df = df[~df[\"is_public\"]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# LET's do the data prep" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "## for 13b this is easy for now\n", "print(df.groupby([\"preference\"])[\"model_name\"].value_counts())\n", "print(df.shape)\n", "df = df[df[\"model_name\"].isin([\"chirp-v4-h-s-32\"])]\n", "print(df.shape)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(df.shape)\n", "df = df[\n", " df[\"request_id\"].isin(\n", " df[\"request_id\"].value_counts().index[df[\"request_id\"].value_counts() == 2]\n", " )\n", "]\n", "print(df.shape)\n", "print(df.groupby([\"preference\"])[\"model_name\"].value_counts())\n", "assert df.shape[0] == df[\"request_id\"].nunique() * 2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import json\n", "\n", "def custom_parse(x):\n", " try:\n", " return json.loads(x)\n", " except:\n", " return {}" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Let's use the old selection for now -- for quality assurance\n", "# expand the metadata columns -- this takes forever...~ 6 mins\n", "# test_slice = df[\"metadata\"].apply(lambda x: ast.literal_eval(str(x)))\n", "test_slice = df[\"metadata\"] #.apply(lambda x: custom_parse(x))\n", "test_slice_series = test_slice.apply(pd.Series)\n", "df = pd.concat([df, test_slice_series], axis=1, join=\"inner\")\n", "print(\"unique_requests\", df[\"request_id\"].nunique())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# def modify_model_name(model_name, metadata):\n", "# if (\n", "# model_name.startswith(\"chirp-v3p5-engine-t\")\n", "# or model_name.startswith(\"chirp-v3p5-engine-s\")\n", "# or model_name.startswith(\"chirp-v4\")\n", "# or model_name.startswith(\"chirp-v3p5-h-s-31\")\n", "# ):\n", "# if \"param_experiment\" in metadata:\n", "# exp = metadata.get(\"param_experiment\", \"\")\n", "# if exp:\n", "# return f\"{model_name}_{exp}\"\n", "# return model_name\n", "\n", "\n", "# df[\"param_model_name\"] = df.apply(\n", "# lambda row: modify_model_name(row[\"model_name\"], row[\"metadata\"]), axis=1\n", "# )\n", "# diff_experiments = (df[\"param_model_name\"].str.contains(\"text_\"))| (df[\"param_model_name\"].str.contains(\"step_\")) | (df[\"param_model_name\"].str.contains(\"tk_\"))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# # try taking out diffusion experiment -- cause they could literally be noise\n", "# print(\"unique_requests\", df[\"request_id\"].nunique())\n", "# df = df[~diff_experiments].copy()\n", "# df = df[\n", "# df[\"request_id\"].isin(\n", "# df[\"request_id\"].value_counts().index[df[\"request_id\"].value_counts() == 2]\n", "# )\n", "# ]\n", "# print(\"unique_requests\", df[\"request_id\"].nunique())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# GPT requests are also fine for now\n", "print(\"unique_requests\", df[\"request_id\"].nunique())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df = df.loc[:, ~df.columns.duplicated()].copy()\n", "# get the original duration of the clips, if they are concacted\n", "df[\"original_duration_s\"] = df[\"total_start_s\"] + df[\"duration\"]\n", "# classify the continue at behavoirs by the duration choice\n", "audio_prompt_id_to_continue_at = {}\n", "for _, row in df[~df[\"continued_parent\"].isna()].iterrows():\n", " audio_prompt_id = row[\"continued_parent\"]\n", " if audio_prompt_id not in audio_prompt_id_to_continue_at:\n", " audio_prompt_id_to_continue_at[audio_prompt_id] = row[\"continue_at\"]\n", " else:\n", " # pick the max\n", " audio_prompt_id = max(\n", " audio_prompt_id_to_continue_at[audio_prompt_id], row[\"continue_at\"]\n", " )\n", "print(len(audio_prompt_id_to_continue_at))\n", "df[\"has_continue_and_start_continue_at\"] = df[\"s3_id\"].apply(\n", " lambda x: audio_prompt_id_to_continue_at.get(x)\n", ")\n", "# we want continue at to be at most of the clip...\n", "df[\"good_continue_at\"] = (\n", " (df[\"has_continue_and_start_continue_at\"] / df[\"duration\"]) > 0.9\n", ") | df[\"has_continue_and_start_continue_at\"].isna()\n", "print(df[\"good_continue_at\"].value_counts())\n", "\n", "\n", "print(\n", " \"\\n Check some basics... \\n\",\n", " df[\"preference\"].value_counts(),\n", " df[\"is_13b\"].value_counts(),\n", " df[\"model_name\"].value_counts(),\n", " df.groupby([\"preference\"])[\"model_name\"].value_counts(),\n", ")\n", "\n", "df = df.sort_values(by=[\"request_id\", \"preference\"])\n", "df[\"duration_rel_diff\"] = df[\"duration\"].diff()\n", "df[\"play_rel_diff\"] = df[\"reaction_play_count\"].diff()\n", "print(df[\"task\"].value_counts())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df = df.sort_values(by=[\"request_id\", \"preference\", \"diff_preference\"])\n", "df[\"pos_diff_preference\"] = df[\"diff_preference\"].diff()\n", "# df[\"cer_diff_preference\"] = df[\"cer\"].diff()\n", "df[df[\"preference\"]][\"pos_diff_preference\"].value_counts()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# df[df[\"preference\"]][\"cer_diff_preference\"].hist(bins=50)\n", "# print(df[df[\"preference\"]][\"cer_diff_preference\"].quantile(0.95))\n", "# plt.show()\n", "# print(df[df[\"preference\"]][\"cer\"].hist(bins=50))\n", "# plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_mask = (df[\"preference\"] == True) & (\n", " (df[\"upvote_count\"] >= 1)\n", ")\n", "print(\"positive with likes\", df[test_mask].shape)\n", "# positive with likes (285955, 149) -- 0215 data\n", "# positive with likes (517621, 151) -- 0217 data" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "normal_pos_play_count = 3\n", "# this is lower, cause a concat is probably already ensuring that it is good\n", "concat_pos_play_count = 2\n", "# this is a filter on the concated clip\n", "concat_total_play_count = 3\n", "\n", "neg_filter_selection_mask = (\n", " (df[\"preference\"] == False) # get basics aligned\n", " & (df[\"reaction_play_count\"] >= 1) # has to be played once\n", " # & (df[\"play_count\"] <= 3) # if it is actually bad, shouldn't be listened often\n", " & (df[\"duration\"] >= 5) # can't be too short, otherwise it is obvious\n", " # & (df[\"duration\"] <= 240) # can't be badly long\n", " & (df[\"has_continue_and_start_continue_at\"].isna()) # won't have any continues\n", " & (df[\"norm_play_frac\"] <= 3.1)\n", " # & (df[\"dislike_count\"] >= 1) # this is kinda strict\n", " # & (\n", " # (df_slice[\"is_in_playlist\"] == False)\n", " # & (df_slice[\"concat_in_playlist\"] == False)\n", " # ) # can't be part of a playlist -- otherwise there are some like signal in it?\n", ")\n", "pos_filter_selectin_mask = (\n", " (df[\"preference\"] == True) # get basics aligned\n", " & (\n", " df[\"good_continue_at\"] == True\n", " ) # if continue, needs to continue off a certain percentage\n", " & (df[\"reaction_play_count\"] >= 1)\n", " & (df[\"play_rel_diff\"] >= 0) # this is more like quality assurance\n", " & (df[\"duration\"] >= 5) # can't be too short, otherwise it is obvious\n", " # & (df[\"duration\"] <= 240) # can't be badly long\n", " & (df[\"dislike_count\"] == 0) # can't have dislikes\n", " & (df[\"flag_count\"] == 0) # can't have issues\n", " & (\n", " (\n", " (df[\"part_of_concat\"] == True)\n", " & (df[\"reaction_play_count\"] >= concat_pos_play_count)\n", " & (df[\"concat_play_counts\"] >= concat_total_play_count)\n", " )\n", " | (\n", " (df[\"part_of_concat\"] == False)\n", " & (df[\"reaction_play_count\"] >= normal_pos_play_count)\n", " )\n", " )\n", " & (df[\"user_n_clips\"] >= 100) # user needs to have genereated at least 20\n", " # & (df[\"duration_rel_diff\"] < 10) # positive isn't just longer\n", " # & ((df[\"upvote_count\"] >= 1) )\n", " & ((df[\"norm_play_frac\"] >= 5.1) | (~df[\"continued_parent\"].isna()))\n", " & (\n", " df[\"norm_play_frac\"] >= df[\"reaction_play_count\"] / 2\n", " ) # play duration is not low on average\n", " & (\n", " df[\"task\"].isin([\"\", \"extend\", \"upload_extend\"])\n", " ) # play duration is not low on average\n", " # & (df[\"pos_diff_preference\"] == 2)\n", ")\n", "print(\n", " \"negative\",\n", " sum(neg_filter_selection_mask),\n", " \"positive\",\n", " sum(pos_filter_selectin_mask),\n", ")\n", "\n", "neg_filter_requests = df[neg_filter_selection_mask][\"request_id\"].unique()\n", "pos_filter_requests = df[pos_filter_selectin_mask][\"request_id\"].unique()\n", "# looking for very strong signal here:\n", "# listen to the positive/negative more than once\n", "# disliked one of the clips\n", "unique_requests = set(pos_filter_requests).intersection(neg_filter_requests)\n", "print(\n", " \"total pair requests\",\n", " df[\"request_id\"].nunique(),\n", " \"selected pair requests\",\n", " len(unique_requests),\n", " f\"frac {len(unique_requests) / df['request_id'].nunique():.3f}\",\n", ")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df_slice = df[df[\"request_id\"].isin(set(unique_requests))].copy()\n", "print(\n", " f\"{os.path.basename(OUT_DATA_DIR)} requests\",\n", " df_slice[\"request_id\"].nunique(),\n", " \"clips\",\n", " df_slice.shape[0],\n", " f\"total khrs {sum(df_slice['duration'] / 3600 / 1000):.3f};\",\n", " f\"N gpus for 1000 iters {df_slice.shape[0] / 8 / 2 / 1000:.3f};\",\n", " f\"4 gpus for x iters {df_slice.shape[0] / 8 / 4 / 4:.3f};\",\n", " f\"n unique users {df_slice['user_id'].nunique()}\",\n", " f\"n pro users {df_slice[df_slice['is_pro_user']]['user_id'].nunique()}\",\n", ")\n", "# 76171 152342 total khrs 2.880 n gpus for 1250 iters 3.809\n", "# 8 v9 requests 106299 clips 212598 total khrs 9.776; N gpus for 1000 iters 13.287; n unique users 27775\n", "# 29 v2 requests 22572 clips 45144 total khrs 2.252; N gpus for 1000 iters 2.821; 4 gpus for x iters 705.375; n unique users 18149 n pro users 10155\n", "# 29 v4 requests 32479 clips 64958 total khrs 3.248; N gpus for 1000 iters 4.060; 4 gpus for x iters 1014.969; n unique users 25192 n pro users 13547\n", "# samve for v5\n", "# 31 v9 requests 63922 clips 127844 total khrs 6.631; N gpus for 1000 iters 7.990; 4 gpus for x iters 1997.562; n unique users 25461 n pro users 24396\n", "# 32 v1 requests 42336 clips 84672 total khrs 4.311; N gpus for 1000 iters 5.292; 4 gpus for x iters 1323.000; n unique users 20440 n pro users 14949\n", "# 32 v2 requests 83218 clips 166436 total khrs 8.672; N gpus for 1000 iters 10.402; 4 gpus for x iters 2600.562; n unique users 36912 n pro users 24545\n", "# 32 v3 requests 71020 clips 142040 total khrs 7.562; N gpus for 1000 iters 8.877; 4 gpus for x iters 2219.375; n unique users 25143 n pro users 22341\n", "# 32 v5 requests 83743 clips 167486 total khrs 8.923; N gpus for 1000 iters 10.468; 4 gpus for x iters 2616.969; n unique users 28348 n pro users 24894\n", "# 32 v6 requests 63924 clips 127848 total khrs 6.725; N gpus for 1000 iters 7.990; 4 gpus for x iters 1997.625; n unique users 24675 n pro users 22071\n", "# 32 v7 requests 106565 clips 213130 total khrs 11.335; N gpus for 1000 iters 13.321; 4 gpus for x iters 3330.156; n unique users 34779 n pro users 29833\n", "# 32 v8 requests 135955 clips 271910 total khrs 14.459; N gpus for 1000 iters 16.994; 4 gpus for x iters 4248.594; n unique users 42469 n pro users 35114\n", "# 32 v9 requests 60046 clips 120092 total khrs 6.444; N gpus for 1000 iters 7.506; 4 gpus for x iters 1876.438; n unique users 15885 n pro users 14566\n", "# 32 v10 requests 79415 clips 158830 total khrs 8.497; N gpus for 1000 iters 9.927; 4 gpus for x iters 2481.719; n unique users 19892 n pro users 17860\n", "# 32 v13 requests 173814 clips 347628 total khrs 18.463; N gpus for 1000 iters 21.727; 4 gpus for x iters 5431.688; n unique users 43848 n pro users 39116\n", "# 32 v14 requests 87118 clips 174236 total khrs 8.689; N gpus for 1000 iters 10.890; 4 gpus for x iters 2722.438; n unique users 22826 n pro users 20899\n", "# 32 v15 requests 68523 clips 137046 total khrs 7.169; N gpus for 1000 iters 8.565; 4 gpus for x iters 1070.672; n unique users 26101 n pro users 23037\n", "# 32 v16 requests 88908 clips 177816 total khrs 8.876; N gpus for 1000 iters 11.114; 4 gpus for x iters 1389.188; n unique users 23225 n pro users 21243\n", "# 32 v17 requests 43677 clips 87354 total khrs 4.468; N gpus for 1000 iters 5.460; 4 gpus for x iters 682.453; n unique users 17554 n pro users 16917\n", "# using 0215 s8 v9 selection requests 72501 clips 145002 total khrs 7.577; N gpus for 1000 iters 9.063; 4 gpus for x iters 1132.828; n unique users 19147 n pro users 17467\n", "# using 0217 s8 v9 selection requests 72957 clips 145914 total khrs 7.631; N gpus for 1000 iters 9.120; 4 gpus for x iters 1139.953; n unique users 19167 n pro users 17480\n", "# 32 v18 requests 72957 clips 145914 total khrs 7.631; N gpus for 1000 iters 9.120; 4 gpus for x iters 1139.953; n unique users 19167 n pro users 17480\n", "# 32 v20 requests 52910 clips 105820 total khrs 5.572; N gpus for 1000 iters 6.614; 4 gpus for x iters 826.719; n unique users 16708 n pro users 15184\n", "# 32 v21 requests 54396 cqlips 108792 total khrs 5.732; N gpus for 1000 iters 6.800; 4 gpus for x iters 849.938; n unique users 17148 n pro users 15552\n", "# 32 v24 requests 375375 clips 750750 total khrs 35.534; N gpus for 1000 iters 46.922; 4 gpus for x iters 5865.234; n unique users 81216 n pro users 70009\n", "# 32 v25 requests 367757 clips 735514 total khrs 35.610; N gpus for 1000 iters 45.970; 4 gpus for x iters 5746.203; n unique users 82243 n pro users 71597\n", "# 32 v26 requests 130175 clips 260350 total khrs 13.203; N gpus for 1000 iters 16.272; 4 gpus for x iters 2033.984; n unique users 30091 n pro users 26580\n", "# 32 v28 cycle requests 365502 clips 731004 total khrs 35.369; N gpus for 1000 iters 45.688; 4 gpus for x iters 5710.969; n unique users 81990 n pro users 71365\n", "# 32 v29 requests 397502 clips 795004 total khrs 38.561; N gpus for 1000 iters 49.688; 4 gpus for x iters 6210.969; n unique users 87074 n pro users 74445" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_mask = (df_slice[\"preference\"] == True) & (\n", " (df_slice[\"is_in_playlist\"] == True) | (df_slice[\"concat_in_playlist\"] == True)\n", ")\n", "print(\"positive in playlist\", df_slice[test_mask].shape)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_mask = (df_slice[\"preference\"] == True) & (\n", " (df_slice[\"upvote_count\"] >= 1)\n", ")\n", "print(\"positive with likes\", df_slice[test_mask].shape)\n", "# positive with likes (60349, 149)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# BREAK" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# interesting_clips_must_be_positive_mask = (\n", "# (df_slice[\"upvoted\"] == True)\n", "# | (df_slice[\"has_action\"] == True)\n", "# | (df_slice[\"part_of_concat\"] == True)\n", "# )\n", "# interesting_clips_must_be_not_negative_mask = (df_slice[\"downvoted\"] == False) # & (df_slice[\"dislike_count\"] < 1)\n", "# interesting_clips_mask = interesting_clips_must_be_positive_mask & interesting_clips_must_be_not_negative_mask\n", "# assert interesting_clips_mask.eq(df_slice[\"preference\"]).all()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# save positive ids\n", "# positive_preference_ids = df_slice[df_slice[\"preference\"] == False][\"s3_id\"].to_json(orient='values')\n", "# with open('/home/tony/Data/Preference/7b_v2/7v_v20_full_recut_id_negative.json', 'w') as file:\n", "# file.write(positive_preference_ids)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# df_slice[df_slice[\"task\"] == \"upload_extend\"]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# df_slice[\"promotion\"].value_counts()\n", "# df_slice[\"source\"].value_counts()\n", "# df_slice[\"gpt_description_prompt\"].isna().value_counts()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df_slice.groupby('user_id')['gpt_description_prompt'].transform('any').value_counts()\n", "df_slice[\"person_type\"] = df_slice[\"gpt_description_prompt\"].isna().astype(int)\n", "df_slice[\"person_type\"].value_counts()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "result_dict = dict(zip(df_slice['id'], df_slice['person_type']))\n", "print(len(result_dict))\n", "# with open(os.path.join(OUT_DATA_DIR, \"person_info.json\"), \"w\") as fp:\n", "# json.dump(result_dict, fp)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df[\"user_id\"].nunique(), df_slice[\"user_id\"].nunique()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "with open(f\"/app/suno/data/dpo/13b_s32_v29/quality/full_pair_quality.json\", \"r\") as f:\n", " result = json.load(f)\n", "\n", "# need to take care of the tail only\n", "def fast_slope(y):\n", " \"\"\"\n", " Calculate the slope of a linear regression line extremely quickly.\n", " \n", " Parameters:\n", " y (list or array): List of float values\n", " \n", " Returns:\n", " float: The slope of the linear regression line\n", " \"\"\"\n", " # detect if x is long enough\n", " if len(y) < 3 * 60 / 5:\n", " return 0\n", " y = np.asarray(y, dtype=np.float64)\n", " n = len(y)\n", " \n", " # Fast calculation using vectorized operations\n", " x = np.arange(n)\n", " x_mean = (n - 1) / 2 # Analytical mean of range(n)\n", " y_mean = np.mean(y)\n", " \n", " # Optimized computation of slope using vectorized operations\n", " # Formula: slope = sum((x_i - x_mean) * (y_i - y_mean)) / sum((x_i - x_mean)^2)\n", " numerator = np.sum(y * x) - n * x_mean * y_mean\n", " denominator = np.sum(x * x) - n * x_mean * x_mean\n", " \n", " return numerator / (denominator + 0.001)\n", "\n", "df_slice[\"ave_ear\"] = df_slice[\"s3_id\"].map(lambda x: np.mean(result[x]) if x in result and result[x] else 0)\n", "df_slice[\"decay_ear\"] = df_slice[\"s3_id\"].map(lambda x: fast_slope(result[x]) if x in result and result[x] else 0)\n", "\n", "df_slice[\"ave_ear_diff\"] = df_slice[\"ave_ear\"].diff()\n", "df_slice[\"decay_ear_diff\"] = df_slice[\"decay_ear\"].diff()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "_ = df_slice[df_slice[\"preference\"]][\"ave_ear_diff\"].hist(bins=np.linspace(-10, 10, 100))\n", "print(df_slice[df_slice[\"preference\"]][\"ave_ear_diff\"].quantile(0.05))\n", "plt.show()\n", "_ = df_slice[df_slice[\"preference\"]][\"decay_ear\"].hist(bins=np.linspace(-1, 1, 100))\n", "print(df_slice[df_slice[\"preference\"]][\"decay_ear\"].quantile(0.05))\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# extra cut here to filter out the tail of the qualities\n", "unique_non_decay_positive_requets = df_slice[(df_slice[\"preference\"]) &(df_slice[\"ave_ear_diff\"] > -3.5) & (df_slice[\"decay_ear\"] > -0.21)][\"request_id\"]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df_slice[df_slice[\"request_id\"].isin(set(unique_non_decay_positive_requets))].shape[0]/df_slice.shape[0]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df_slice = df_slice[df_slice[\"request_id\"].isin(set(unique_non_decay_positive_requets))].copy()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# df_slice.to_pickle(\"/home/tony/Data/Preference/13b_v32/interesting_clips_v4_h_s_32_20250303_full_long_final_v30.pkl\")\n", "print(df_slice.shape)\n", "print(df_slice[\"task\"].value_counts())\n", "BREAK" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Need to kick out the ones has gpt prompt -- these are pairs with different text inputs" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# don't have continue at\n", "# df_slice[df_slice[\"continue_at\"].isna()][\"request_id\"].nunique()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "final_filtered_requests = df_slice[\"request_id\"].unique()\n", "print(len(final_filtered_requests))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# df_slice.to_csv(\"/home/tony/Data/Preference/7b_v2/7b_before_recode_20240412\", index=False)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_requests, val_requests = train_test_split(\n", " sorted(list(final_filtered_requests)), test_size=0.01, random_state=42\n", ")\n", "print(len(train_requests), len(val_requests))\n", "\n", "train_df = df_slice[df_slice[\"request_id\"].isin(set(train_requests))].copy()\n", "val_df = df_slice[df_slice[\"request_id\"].isin(set(val_requests))].copy()\n", "train_df = train_df.sort_values(by=[\"request_id\", \"preference\"])\n", "train_df = train_df# .reset_index()\n", "val_df = val_df.sort_values(by=[\"request_id\", \"preference\"])\n", "val_df = val_df#.reset_index()\n", "\n", "print(train_df.shape, val_df.shape)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# BREAK" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Actually make" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# val_df[[\"request_id\", \"metadata\", \"updated_at\", \"user_id\", \"preference\"]].head()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "total_duration = 0\n", "for i, row in tqdm(train_df.iterrows(), total=len(train_df)):\n", " # we need to alternate between preference: neg, pos\n", " # print(i, row)\n", " try:\n", " assert row[\"preference\"] == (i % 2 == 1)\n", " except:\n", " print(i, row)\n", " total_duration += row[\"duration\"]\n", "print(\n", " f\"{round(total_duration / 60 / 60):,} hours of {train_df.shape[0]} clips, {train_df.shape[0] / 8 / 4 / 1000} nodes, {train_df.shape[0] / 8 / 8 / 4} steps\"\n", ")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "make_dataset(val_df, OUT_DATA_DIR, is_val=True, npz_dir=NPZ_DIR)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "make_dataset(train_df, OUT_DATA_DIR, is_val=False, npz_dir=NPZ_DIR)" ] }, { "cell_type": "markdown", "metadata": { "ExecuteTime": { "end_time": "2024-01-29T19:46:47.549860Z", "start_time": "2024-01-29T19:46:47.548015Z" } }, "source": [ "# Validation" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# verify\n", "mm = np.memmap(os.path.join(OUT_DATA_DIR, f\"data_val.bin\"), dtype=np.uint16, mode=\"r\")\n", "test_metas = read_jsonl(os.path.join(OUT_DATA_DIR, f\"meta_val.jsonl\"))\n", "test_info = read_json(os.path.join(OUT_DATA_DIR, f\"info_val.json\"))\n", "mm = mm.reshape(-1, 6016, 13)\n", "assert len(mm) == len(test_metas)\n", "assert mm[:100, :, 0].min() >= 0\n", "assert mm[:100, :, 0].max() <= 4000\n", "assert mm[:100, :, 1:].min() >= 0\n", "assert mm[:100, :, 1:].max() <= 2048" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# # randomly listen to some stuff\n", "# from suno_utils.tasks.dac_2c_12cb import preload_models as preload_codec_models\n", "# from suno_utils.tasks.dac_2c_12cb import (\n", "# encode as codec_encode,\n", "# decode_stream_to_full_audio as codec_decode,\n", "# EMBEDDING_RATE as CODEC_EMBEDDING_RATE,\n", "# decode as decode\n", "# )\n", "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", "# _ = preload_codec_models(\"/app/suno/data/dpo/models/dac_2c_25x12.pt\", device=\"cuda\")\n", "# assert len(test_metas) == len(mm)\n", "# idx_list = list(range(len(test_metas)))\n", "# # random.shuffle(idx_list)\n", "# # idx_list = [idx for idx in idx_list if \"text\" in test_metas[idx]]\n", "# print(len(mm))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# import random\n", "# idx = random.choice(test_info[\"perference_0\"][\"idx_list\"])\n", "# assert \"original_duration_s\" in test_metas[idx]\n", "# # positive index should be shifted by 1\n", "# pos_idx = idx + 1\n", "# print(\n", "# \"tags:\",\n", "# test_metas[idx].get(\"tags\") == test_metas[pos_idx].get(\"tags\"),\n", "# test_metas[idx].get(\"tags\"),\n", "# )\n", "# arr = mm[idx, 1:].copy().astype(np.int16)[:, 1:]\n", "# pos_arr = mm[pos_idx, 1:].copy().astype(np.int16)[:, 1:]\n", "# pad_idx_arr = np.where(arr == COARSE_PAD_TOKEN)[0]\n", "# if len(pad_idx_arr) > 0:\n", "# arr = arr[: pad_idx_arr[0], :]\n", "# pos_pad_idx_arr = np.where(pos_arr == COARSE_PAD_TOKEN)[0]\n", "# if len(pos_pad_idx_arr) > 0:\n", "# pos_arr = pos_arr[: pos_pad_idx_arr[0], :]\n", "# a = decode(arr)\n", "# print(\"\\n negative example \\n\", test_metas[idx])\n", "# a.play(compress=False)\n", "# pos_a = decode(pos_arr)\n", "# print(\"\\n positive example \\n\", test_metas[pos_idx])\n", "# pos_a.play(compress=False)\n", "# print(\n", "# \"text:\",\n", "# test_metas[idx].get(\"text\") == test_metas[pos_idx].get(\"text\"),\n", "# test_metas[idx].get(\"text\"),\n", "# )" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# val_df[val_df[\"tags\"] == 'a vibrant blend of experimental jazz fusion, drum-and-bass and swagger fuzzed-out guitars']" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# from collections import Counter\n", "# c = Counter()\n", "# for _, row in df_slice.iterrows():\n", "# # print(row[\"metadata\"])\n", "# for k in ast.literal_eval(row[\"metadata\"]).keys():\n", "# c[k] += 1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# original_npz_path = f\"/app/suno/data/dpo/7b_npz/{test_metas[idx]['id']}.npz\"\n", "# original_npz_path = \"/app/suno/data/dpo/7b_npz/729c3011-f672-4ccd-8d82-1cbf2b52ff69.npz\"\n", "# original_arr = np.load(original_npz_path)[\"v2_raw\"]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def validation_on_metas(input_metas):\n", "\n", " total_bad = 0\n", " total_good = 0\n", " for idx in range(len(input_metas)):\n", " if idx % 2 == 0:\n", " pos_idx = idx + 1\n", " if input_metas[idx].get(\"tags\") != input_metas[pos_idx].get(\"tags\"):\n", " # print(test_metas[idx].get(\"text\") == test_metas[pos_idx].get(\"text\"), test_metas[idx].get(\"tags\"), test_metas[pos_idx].get(\"tags\"))\n", " total_bad += 1\n", " else:\n", " total_good += 1\n", " print(total_good, total_bad)\n", " return\n", "\n", "\n", "validation_on_metas(test_metas)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_info = read_json(os.path.join(OUT_DATA_DIR, f\"info_tr.json\"))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "n_neg_tr = train_info[\"perference_0\"][\"idx_list\"]\n", "n_pos_tr = train_info[\"perference_1\"][\"idx_list\"]\n", "assert len(n_pos_tr) == len(n_neg_tr)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "total_iters = len(n_neg_tr) + len(n_pos_tr)\n", "print(\"total samples\", total_iters, train_df.shape)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(\"1 epoch per batch 4, total\", total_iters / 8 / 4 / 2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "!cd /home/tony/Work/tony/slurm/13b_dpo && sbatch sbatch_ipo_13b_s32" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import shutil\n", "\n", "# Basic file copy\n", "shutil.copy('/home/tony/Work/tony/Preference/make_dataset_13b_v3p5data_s32_debug.ipynb', os.path.join(OUT_DATA_DIR, \"make_dataset.ipynb\"))\n", "print(\"Cache kept!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# some gymathtics loading prev data" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# prev_v3_data = \"/app/suno/data/dpo/7v_v20_full/\"\n", "\n", "# test_val_metas = read_jsonl(os.path.join(prev_v3_data, f\"meta_val.jsonl\"))\n", "# test_tr_metas = read_jsonl(os.path.join(prev_v3_data, f\"meta_tr.jsonl\"))\n", "\n", "# all_ids = set()\n", "# for meta in test_val_metas:\n", "# all_ids.add(meta[\"id\"])\n", "# for meta in test_tr_metas:\n", "# all_ids.add(meta[\"id\"])\n", "# print(len(all_ids), len(test_val_metas) + len(test_tr_metas))\n", "\n", "# all_ids = list(all_ids)\n", "# with open(\"/home/tony/Data/Preference/7b_v2/7v_v20_full_recut_id.json\", \"w\") as fp:\n", "# json.dump(all_ids, fp)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# train_df[\"lang\"].value_counts()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# import json\n", "# # with open(f\"/home/tony/Data/Preference/13b_s32_v29/full_pair_quality.json\", \"r\") as f:\n", "# # result = json.load(f)\n", "# result = {}\n", "# print(len(result))\n", "# for job_idx in range(8):\n", "# with open(f\"/app/suno/data/dpo/13b_s32_v29/quality/full_pair_quality_{job_idx}.json\", \"r\") as fp:\n", "# current_result = json.load(fp)\n", "# result.update(current_result)\n", "# print(len(result))\n", "# with open(f\"/app/suno/data/dpo/13b_s32_v29/quality/full_pair_quality.json\", \"w\") as f:\n", "# json.dump(result, f, indent=4)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 4 }