{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:58:21.040680Z", "start_time": "2024-05-16T13:58:19.777010Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:23:29.792518Z", "iopub.status.busy": "2024-10-30T01:23:29.792386Z", "iopub.status.idle": "2024-10-30T01:23:32.260765Z", "shell.execute_reply": "2024-10-30T01:23:32.260256Z", "shell.execute_reply.started": "2024-10-30T01:23:29.792498Z" } }, "outputs": [], "source": [ "import ast\n", "import os\n", "import shutil\n", "import sys\n", "from collections import defaultdict\n", "\n", "import json\n", "import numpy as np\n", "import pandas as pd\n", "from preference_data_preparation_4min_30b_task import *\n", "from preference_helper 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", "\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\n", "\n", "\n", "def custom_parse(x):\n", " try:\n", " return json.loads(x)\n", " except:\n", " return {}" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:58:21.082172Z", "start_time": "2024-05-16T13:58:21.041926Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:23:32.261514Z", "iopub.status.busy": "2024-10-30T01:23:32.261317Z", "iopub.status.idle": "2024-10-30T01:23:32.314559Z", "shell.execute_reply": "2024-10-30T01:23:32.314116Z", "shell.execute_reply.started": "2024-10-30T01:23:32.261500Z" } }, "outputs": [], "source": [ "OUT_DATA_DIR = \"/app/suno/data/dpo/30b_t5_v15\"\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/30b_npz\"" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:58:53.962528Z", "start_time": "2024-05-16T13:58:21.105919Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:23:32.315335Z", "iopub.status.busy": "2024-10-30T01:23:32.315201Z", "iopub.status.idle": "2024-10-30T01:23:56.000023Z", "shell.execute_reply": "2024-10-30T01:23:55.999440Z", "shell.execute_reply.started": "2024-10-30T01:23:32.315322Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Preference data shape (364402, 70)\n", "(237436, 71)\n" ] } ], "source": [ "df = pd.read_pickle(\n", " # \"/home/tony/Data/Preference/30b_v3/interesting_clips_v4_t_4_20240925_full_l10_with_cer.pkl\"\n", " \"/home/tony/Data/Preference/30b_v5/interesting_clips_v4_t_5_20241029_full_with_cer.pkl\"\n", " # \"/home/tony/Data/Preference/30b_v3/interesting_clips_v4_t_4_20240923_full_with_sem_distance_and_similarity.pkl\"\n", " # \"/home/tony/Data/Preference/30b_v2/interesting_clips_v4_t_3_20240919_full_l10_with_cer.pkl\"\n", ") # , engine='python')\n", "# df = pd.read_csv(\n", "# \"/home/tony/Data/Preference/30b_v0/interesting_clips_v4_t_1_20240808.csv\"\n", "# ) # , engine='python')\n", "print(\"Preference data shape\", df.shape)\n", "\n", "df_cover = pd.read_pickle(\n", " \"/home/tony/Data/Preference/30b_v5/interesting_clips_v4_t_5_20241029_full_with_sem_distance_and_similarity.pkl\"\n", ")\n", "print(df_cover.shape)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:23:56.000755Z", "iopub.status.busy": "2024-10-30T01:23:56.000606Z", "iopub.status.idle": "2024-10-30T01:23:56.788452Z", "shell.execute_reply": "2024-10-30T01:23:56.787873Z", "shell.execute_reply.started": "2024-10-30T01:23:56.000740Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "13379\n" ] } ], "source": [ "df_cover[df_cover[\"preference\"]][\"similarity\"].hist(bins=200)\n", "plt.show()\n", "df_cover[\"similarity_diff\"] = df_cover[\"similarity\"].diff()\n", "df_cover[df_cover[\"preference\"]][\"similarity_diff\"].hist(bins=200)\n", "plt.show()\n", "df_cover[\"continued_parent\"] = None\n", "df_cover[\"continue_at\"] = -1\n", "df_cover[df_cover[\"preference\"]][\"similarity\"].describe()\n", "df_cover_drops_id = df_cover[\n", " (df_cover[\"preference\"])\n", " & (~((0 < df_cover[\"similarity\"]) & (df_cover[\"similarity\"] <= 0.99)))\n", "][\"s3_id\"].unique()\n", "print(len(df_cover_drops_id))" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:23:56.789163Z", "iopub.status.busy": "2024-10-30T01:23:56.789017Z", "iopub.status.idle": "2024-10-30T01:23:57.747509Z", "shell.execute_reply": "2024-10-30T01:23:57.746933Z", "shell.execute_reply.started": "2024-10-30T01:23:56.789148Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "before filter on cover similarity (364402, 70)\n", "after filter on cover similarity (351023, 70)\n" ] } ], "source": [ "print(\"before filter on cover similarity\", df.shape)\n", "df = df[~df[\"s3_id\"].isin(df_cover_drops_id)].copy()\n", "print(\"after filter on cover similarity\", df.shape)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:23:57.751933Z", "iopub.status.busy": "2024-10-30T01:23:57.751481Z", "iopub.status.idle": "2024-10-30T01:23:58.864972Z", "shell.execute_reply": "2024-10-30T01:23:58.864213Z", "shell.execute_reply.started": "2024-10-30T01:23:57.751915Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "after dropna (351023, 66)\n" ] } ], "source": [ "df = df.dropna(axis=1, how=\"all\")\n", "print(\"after dropna\", df.shape)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:58:56.199480Z", "start_time": "2024-05-16T13:58:53.963687Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:23:58.865899Z", "iopub.status.busy": "2024-10-30T01:23:58.865723Z", "iopub.status.idle": "2024-10-30T01:24:46.676899Z", "shell.execute_reply": "2024-10-30T01:24:46.676113Z", "shell.execute_reply.started": "2024-10-30T01:23:58.865881Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1740153\n", "1740153\n", "pre-downloaded df (351023, 66)\n", "downloaded df (351023, 66)\n" ] } ], "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", "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": 8, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:58:56.467253Z", "start_time": "2024-05-16T13:58:56.207647Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:24:46.677803Z", "iopub.status.busy": "2024-10-30T01:24:46.677630Z", "iopub.status.idle": "2024-10-30T01:24:47.592422Z", "shell.execute_reply": "2024-10-30T01:24:47.591822Z", "shell.execute_reply.started": "2024-10-30T01:24:46.677784Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "is_30b\n", "True 351023\n", "Name: count, dtype: int64\n" ] }, { "data": { "text/plain": [ "task\n", "cover 224057\n", " 74896\n", "infill 39028\n", "extend 12720\n", "artist_consistency 322\n", "Name: count, dtype: int64" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[\"is_30b\"] = df[\"model_name\"].str.contains(\"-t\")\n", "print(df[\"is_30b\"].value_counts())\n", "df[\"task\"].value_counts()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# LET's do the data prep" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:24:47.593403Z", "iopub.status.busy": "2024-10-30T01:24:47.593117Z", "iopub.status.idle": "2024-10-30T01:24:47.953687Z", "shell.execute_reply": "2024-10-30T01:24:47.952960Z", "shell.execute_reply.started": "2024-10-30T01:24:47.593385Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(338303, 67)\n" ] } ], "source": [ "# drop extend for now\n", "# reason is -- cause they are likely caused by extend from 13b\n", "# we don't want contamination\n", "df = df[df[\"task\"] != \"extend\"].copy()\n", "print(df.shape)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:58:56.592883Z", "start_time": "2024-05-16T13:58:56.470781Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:24:47.954565Z", "iopub.status.busy": "2024-10-30T01:24:47.954394Z", "iopub.status.idle": "2024-10-30T01:24:48.143847Z", "shell.execute_reply": "2024-10-30T01:24:48.143169Z", "shell.execute_reply.started": "2024-10-30T01:24:47.954547Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "preference model_name \n", "False chirp-v3p5-engine-t-5 175841\n", "True chirp-v3p5-engine-t-5 162462\n", "Name: count, dtype: int64\n", "before filter on model name (338303, 67)\n", "after filter on model name (338303, 67)\n" ] } ], "source": [ "## for 13b this is easy for now\n", "print(df.groupby([\"preference\"])[\"model_name\"].value_counts())\n", "print(\"before filter on model name\", df.shape)\n", "df = df[df[\"model_name\"].isin([\"chirp-v3p5-engine-t-5\"])]\n", "print(\"after filter on model name\", df.shape)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:58:56.909539Z", "start_time": "2024-05-16T13:58:56.595736Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:24:48.144760Z", "iopub.status.busy": "2024-10-30T01:24:48.144589Z", "iopub.status.idle": "2024-10-30T01:24:48.532486Z", "shell.execute_reply": "2024-10-30T01:24:48.531761Z", "shell.execute_reply.started": "2024-10-30T01:24:48.144743Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "before filter on request id pairs (338303, 67)\n", "after filter on request id pairs (324924, 67)\n", "preference model_name \n", "False chirp-v3p5-engine-t-5 162462\n", "True chirp-v3p5-engine-t-5 162462\n", "Name: count, dtype: int64\n" ] } ], "source": [ "print(\"before filter on request id pairs\", 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(\"after filter on request id pairs\", 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": 12, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:24:48.533407Z", "iopub.status.busy": "2024-10-30T01:24:48.533228Z", "iopub.status.idle": "2024-10-30T01:25:43.806492Z", "shell.execute_reply": "2024-10-30T01:25:43.805739Z", "shell.execute_reply.started": "2024-10-30T01:24:48.533389Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "unique_requests 162462\n", "before removing duplicates (324924, 124)\n", "after removing duplicates (324924, 119)\n" ] } ], "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 = 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())\n", "# remove the duplicates\n", "print(\"before removing duplicates\", df.shape)\n", "df = df.loc[:, ~df.columns.duplicated()].copy()\n", "print(\"after removing duplicates\", df.shape)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:43.807521Z", "iopub.status.busy": "2024-10-30T01:25:43.807242Z", "iopub.status.idle": "2024-10-30T01:25:43.847616Z", "shell.execute_reply": "2024-10-30T01:25:43.847066Z", "shell.execute_reply.started": "2024-10-30T01:25:43.807504Z" } }, "outputs": [ { "data": { "text/plain": [ "task\n", "cover 210678\n", " 74896\n", "infill 39028\n", "artist_consistency 322\n", "Name: count, dtype: int64" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[\"task\"].value_counts()" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:43.848229Z", "iopub.status.busy": "2024-10-30T01:25:43.848092Z", "iopub.status.idle": "2024-10-30T01:25:44.357967Z", "shell.execute_reply": "2024-10-30T01:25:44.357341Z", "shell.execute_reply.started": "2024-10-30T01:25:43.848214Z" } }, "outputs": [ { "data": { "text/plain": [ "pos_diff_preference\n", "1.0 115126\n", "2.0 47336\n", "Name: count, dtype: int64" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "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": 15, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:44.358984Z", "iopub.status.busy": "2024-10-30T01:25:44.358650Z", "iopub.status.idle": "2024-10-30T01:25:44.544259Z", "shell.execute_reply": "2024-10-30T01:25:44.543555Z", "shell.execute_reply.started": "2024-10-30T01:25:44.358965Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "positive param_experiment\n", "s_max_t_12_tag_2 9001\n", "s_max_t_13_tag_2 8619\n", "s_30_t_12_tag_2 8379\n", "s_max_t_14_tag_2 8006\n", "s_max_t_13_tag_3 451\n", "s_max_t_12_tag_3 450\n", "s_max_t_14_tag_3 420\n", "s_30_t_12_tag_3 406\n", "Name: count, dtype: int64\n" ] } ], "source": [ "try:\n", " print(\"positive\", df[df[\"preference\"]][\"param_experiment\"].value_counts())\n", "except:\n", " pass" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:44.545136Z", "iopub.status.busy": "2024-10-30T01:25:44.544968Z", "iopub.status.idle": "2024-10-30T01:25:45.309040Z", "shell.execute_reply": "2024-10-30T01:25:45.308406Z", "shell.execute_reply.started": "2024-10-30T01:25:44.545120Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.3096\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAGdCAYAAADwjmIIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzHElEQVR4nO3deXRUZZ7/8U8qi6CBiEkYmgFHT2IWE0iC9ImJRdONIgra0wERpkFFaUFlc2mEYVCIIgFEB+MGAqJgnDRjQFsBp9XjgifBrRPpAAIBRexokxRLErZs9/eHzf1RJCRVoZJUHt6vc+occu9TTz3felLFJ0/dWzfAsixLAAAAhnG09wAAAABaAyEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABgpqL0H4A9crkr58uIWAQFSeHgXn/frT0yvkfo6PtNrpL6Oz/QaW7O+U303h5AjybLUKr9grdWvPzG9Rurr+Eyvkfo6PtNrbM/6+LgKAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJG4CjkAowUGNv23XH29pfp6gy8BDZzHCDkAjORwBKiu3lK3bhc12a62rl5HDh8j6AAGIuQAMFJAQIACHQGalluokgNVjbaJ7h6qZ0anyOEIIOQABiLkADBayYEqbSutaO9hAGgHHHgMAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARvIq5Dz77LOKjY11u91www32/pMnTyozM1OpqalKSUnRlClTVF5e7tZHaWmpJkyYoKSkJKWlpWnhwoWqra11a/PZZ58pIyNDiYmJGjx4sNatW9dgLDk5ORo0aJD69OmjkSNHauvWrd6UAgAADOf1Ss4VV1yhTz/91L69/vrr9r758+frww8/1JIlS7RmzRodOHBAkydPtvfX1dVp4sSJqqmpUW5urhYsWKD169crOzvbbrN//35NnDhRqampeuutt3THHXdo9uzZ2rx5s91m48aNysrK0qRJk7R+/XrFxcVp/PjxcrlcLX0eAACAYbwOOYGBgYqMjLRvl1xyiSSpsrJSeXl5mjlzptLS0pSYmKj58+ersLBQRUVFkqRPP/1UJSUlevLJJxUfH6+BAwdq2rRpysnJUXV1tSQpNzdXvXr10syZMxUVFaWxY8dqyJAheuWVV+wxrFq1SrfeeqtGjBih6OhoZWZmqlOnTsrLyzv3ZwQAABjB65Czb98+OZ1OXXvttXrooYdUWloqSSouLlZNTY3S09PttlFRUerZs6cdcoqKihQTE6OIiAi7jdPpVFVVlUpKSuw2aWlpbo/pdDrtPqqrq7Vt2za3x3E4HEpPT1dhYaG35UiSAgJ8f2utfv3pZnqN1Nfxb+39PsAcUt/5XmNr1ueJIG/eBPr27ausrCxdfvnlKisr0/PPP68xY8bo7bffVnl5uYKDg9W1a1e3+4SHh6usrEySVF5e7hZwJNk/N9emqqpKJ06c0JEjR1RXV6fw8PAGj7N3715vyjntvl1adL/26tefmF4j9Z0funW7qL2H0GKmz6Hp9Unm19ie9XkVcgYOHGj/Oy4uTklJSfrNb36jTZs2qVOnTj4fXFtxuSplWb7rLyDg50n1db/+xPQaqa/jCwpy6OKLPQsvhw4dVV1dfSuPyLdMn0PT65PMr7E16zvVd3O8Cjln6tq1qy677DJ9//33Sk9PV01NjSoqKtxWc1wulyIjIyX9vCJz5llQp86+Or3NmWdklZeXKzQ0VJ06dZLD4VBgYGCDg4xdLleDFSBPWZZa5Restfr1J6bXSH0dl7d1ddTnweQ5lMyvTzK/xvas75y+J+fo0aPav3+/IiMjlZiYqODgYBUUFNj79+7dq9LSUiUnJ0uSkpOTtWvXLreAkp+fr9DQUEVHR9tttmzZ4vY4+fn5dh8hISFKSEhwe5z6+noVFBQoJSXlXMoBAAAG8SrkLFy4UJ9//rl++OEH/fWvf9XkyZPlcDh00003qUuXLhoxYoQWLFigLVu2qLi4WLNmzVJKSoodUJxOp6Kjo/Xwww/rm2++0ebNm7VkyRKNGTNGISEhkqTRo0dr//79WrRokfbs2aOcnBxt2rRJ48aNs8dx5513au3atVq/fr327NmjuXPn6vjx4xo+fLjPnhgAANCxefVx1U8//aQHH3xQhw8f1iWXXKKrrrpKa9eutU8jnzVrlhwOh6ZOnarq6mo5nU7NmTPHvn9gYKCWLl2quXPnatSoUercubMyMjI0depUu03v3r21bNkyZWVlafXq1erRo4fmzZunAQMG2G2GDh2qgwcPKjs7W2VlZYqPj9eKFSta/HEVAAAwT4BlmfxJoGfKy31/4HFERBef9+tPTK+R+jq+oCCHunW7SMOyN2tbaUWjbRJ6dtWGqQN06NBR1dZ2vAOPTZ5D0+uTzK+xNes71XdzuHYVAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBI5xRyXnrpJcXGxuqJJ56wt508eVKZmZlKTU1VSkqKpkyZovLycrf7lZaWasKECUpKSlJaWpoWLlyo2tpatzafffaZMjIylJiYqMGDB2vdunUNHj8nJ0eDBg1Snz59NHLkSG3duvVcygEAAAZpccjZunWrcnNzFRsb67Z9/vz5+vDDD7VkyRKtWbNGBw4c0OTJk+39dXV1mjhxompqapSbm6sFCxZo/fr1ys7Ottvs379fEydOVGpqqt566y3dcccdmj17tjZv3my32bhxo7KysjRp0iStX79ecXFxGj9+vFwuV0tLAgAABmlRyDl69KimT5+uefPmKSwszN5eWVmpvLw8zZw5U2lpaUpMTNT8+fNVWFiooqIiSdKnn36qkpISPfnkk4qPj9fAgQM1bdo05eTkqLq6WpKUm5urXr16aebMmYqKitLYsWM1ZMgQvfLKK/ZjrVq1SrfeeqtGjBih6OhoZWZmqlOnTsrLy2v5swEAAIzRopDz2GOPaeDAgUpPT3fbXlxcrJqaGrftUVFR6tmzpx1yioqKFBMTo4iICLuN0+lUVVWVSkpK7DZpaWlufTudTruP6upqbdu2ze1xHA6H0tPTVVhY6HU9AQG+v7VWv/50M71G6uv4t/Z+H2AOqe98r7E16/NEkHdvA9KGDRu0fft2vfHGGw32lZeXKzg4WF27dnXbHh4errKyMrvN6QFHkv1zc22qqqp04sQJHTlyRHV1dQoPD2/wOHv37vW2JIWHd/H6Pu3Zrz8xvUbqOz9063ZRew+hxUyfQ9Prk8yvsT3r8yrk/Pjjj3riiSf08ssv64ILLmitMbU5l6tSluW7/gICfp5UX/frT0yvkfo6vqAghy6+2LPwcujQUdXV1bfyiHzL9Dk0vT7J/Bpbs75TfTfHq5Czbds2uVwuDR8+3N5WV1enL774Qjk5OVq5cqVqampUUVHhtprjcrkUGRkp6ecVmTPPgjp19tXpbc48I6u8vFyhoaHq1KmTHA6HAgMDGxxk7HK5GqwAecKy1Cq/YK3Vrz8xvUbq67i8raujPg8mz6Fkfn2S+TW2Z31eHZNz9dVX6+2339abb75p3xITE3XzzTfb/w4ODlZBQYF9n71796q0tFTJycmSpOTkZO3atcstoOTn5ys0NFTR0dF2my1btrg9dn5+vt1HSEiIEhIS3B6nvr5eBQUFSklJ8eoJAAAAZvJqJSc0NFQxMTFu2y688EJdfPHF9vYRI0ZowYIFCgsLU2hoqObNm6eUlBQ7oDidTkVHR+vhhx/W9OnTVVZWpiVLlmjMmDEKCQmRJI0ePVo5OTlatGiRRowYoS1btmjTpk1atmyZ/bh33nmnZsyYocTERPXt21evvvqqjh8/7rbKBAAAzl9eH3jcnFmzZsnhcGjq1Kmqrq6W0+nUnDlz7P2BgYFaunSp5s6dq1GjRqlz587KyMjQ1KlT7Ta9e/fWsmXLlJWVpdWrV6tHjx6aN2+eBgwYYLcZOnSoDh48qOzsbJWVlSk+Pl4rVqxo0cdVAADAPAGWZfIngZ4pL/f9gccREV183q8/Mb1G6uv4goIc6tbtIg3L3qxtpRWNtkno2VUbpg7QoUNHVVvb8Q48NnkOTa9PMr/G1qzvVN/N4dpVAADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABG8irkvP7667r55pvVr18/9evXT6NGjdLHH39s7z958qQyMzOVmpqqlJQUTZkyReXl5W59lJaWasKECUpKSlJaWpoWLlyo2tpatzafffaZMjIylJiYqMGDB2vdunUNxpKTk6NBgwapT58+GjlypLZu3epNKQAAwHBehZwePXroj3/8o9atW6e8vDxdffXVmjRpknbv3i1Jmj9/vj788EMtWbJEa9as0YEDBzR58mT7/nV1dZo4caJqamqUm5urBQsWaP369crOzrbb7N+/XxMnTlRqaqreeust3XHHHZo9e7Y2b95st9m4caOysrI0adIkrV+/XnFxcRo/frxcLte5Ph8AAMAQXoWcQYMGaeDAgbrssst0+eWX64EHHtCFF16ooqIiVVZWKi8vTzNnzlRaWpoSExM1f/58FRYWqqioSJL06aefqqSkRE8++aTi4+M1cOBATZs2TTk5OaqurpYk5ebmqlevXpo5c6aioqI0duxYDRkyRK+88oo9jlWrVunWW2/ViBEjFB0drczMTHXq1El5eXk+e2IAAEDH1uJjcurq6rRhwwYdO3ZMKSkpKi4uVk1NjdLT0+02UVFR6tmzpx1yioqKFBMTo4iICLuN0+lUVVWVSkpK7DZpaWluj+V0Ou0+qqurtW3bNrfHcTgcSk9PV2FhYYtqCQjw/a21+vWnm+k1Ul/Hv7X3+wBzSH3ne42tWZ8ngrx7G5B27typ0aNH6+TJk7rwwgv1/PPPKzo6Wjt27FBwcLC6du3q1j48PFxlZWWSpPLycreAI8n+ubk2VVVVOnHihI4cOaK6ujqFh4c3eJy9e/d6W84/79ulRfdrr379iek1Ut/5oVu3i9p7CC1m+hyaXp9kfo3tWZ/XIefyyy/Xm2++qcrKSv3f//2fZsyYoddee601xtZmXK5KWZbv+gsI+HlSfd2vPzG9Rurr+IKCHLr4Ys/Cy6FDR1VXV9/KI/It0+fQ9Pok82tszfpO9d0cr0NOSEiI/u3f/k2SlJiYqL/97W9avXq1brzxRtXU1KiiosJtNcflcikyMlLSzysyZ54Fdersq9PbnHlGVnl5uUJDQ9WpUyc5HA4FBgY2OMjY5XI1WAHylGWpVX7BWqtff2J6jdTXcXlbV0d9HkyeQ8n8+iTza2zP+s75e3Lq6+tVXV2txMREBQcHq6CgwN63d+9elZaWKjk5WZKUnJysXbt2uQWU/Px8hYaGKjo62m6zZcsWt8fIz8+3+wgJCVFCQoLb49TX16ugoEApKSnnWg4AADCEVys5Tz31lH71q1/pF7/4hY4ePap33nlHn3/+uVauXKkuXbpoxIgRWrBggcLCwhQaGqp58+YpJSXFDihOp1PR0dF6+OGHNX36dJWVlWnJkiUaM2aMQkJCJEmjR49WTk6OFi1apBEjRmjLli3atGmTli1bZo/jzjvv1IwZM5SYmKi+ffvq1Vdf1fHjxzV8+HDfPTMAAKBD8yrkuFwuzZgxQwcOHFCXLl0UGxurlStX6pprrpEkzZo1Sw6HQ1OnTlV1dbWcTqfmzJlj3z8wMFBLly7V3LlzNWrUKHXu3FkZGRmaOnWq3aZ3795atmyZsrKytHr1avXo0UPz5s3TgAED7DZDhw7VwYMHlZ2drbKyMsXHx2vFihUt/rgKAACYJ8CyTP4k0DPl5b4/8DgioovP+/UnptdIfR1fUJBD3bpdpGHZm7WttKLRNgk9u2rD1AE6dOioams73oHHJs+h6fVJ5tfYmvWd6rs5XLsKAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIwW19wAAoCUcjgA5HAFn3R8YyN9wwPmOkAOgw3E4AhR28YUKIsgAaAIhB0CH43AEKCjQoWm5hSo5UNVom1/HRmr6kLg2HhkAf0LIAdBhlRyo0rbSikb3RUVe1MajAeBvWOsFAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADCSVyFn2bJlGjFihFJSUpSWlqb77rtPe/fudWtz8uRJZWZmKjU1VSkpKZoyZYrKy8vd2pSWlmrChAlKSkpSWlqaFi5cqNraWrc2n332mTIyMpSYmKjBgwdr3bp1DcaTk5OjQYMGqU+fPho5cqS2bt3qTTkAAMBgXoWczz//XGPGjNHatWu1atUq1dbWavz48Tp27JjdZv78+frwww+1ZMkSrVmzRgcOHNDkyZPt/XV1dZo4caJqamqUm5urBQsWaP369crOzrbb7N+/XxMnTlRqaqreeust3XHHHZo9e7Y2b95st9m4caOysrI0adIkrV+/XnFxcRo/frxcLte5PB8AAMAQXoWclStXavjw4briiisUFxenBQsWqLS0VNu2bZMkVVZWKi8vTzNnzlRaWpoSExM1f/58FRYWqqioSJL06aefqqSkRE8++aTi4+M1cOBATZs2TTk5OaqurpYk5ebmqlevXpo5c6aioqI0duxYDRkyRK+88oo9llWrVunWW2/ViBEjFB0drczMTHXq1El5eXm+eWYAAECHdk7H5FRWVkqSwsLCJEnFxcWqqalRenq63SYqKko9e/a0Q05RUZFiYmIUERFht3E6naqqqlJJSYndJi0tze2xnE6n3Ud1dbW2bdvm9jgOh0Pp6ekqLCw8l5IAAIAhWnxZh/r6es2fP1/9+vVTTEyMJKm8vFzBwcHq2rWrW9vw8HCVlZXZbU4POJLsn5trU1VVpRMnTujIkSOqq6tTeHh4g8c58xghTwSc/ULGLXKqP1/3609Mr5H6zj8d7bkwfQ5Nr08yv8bWrM/TPlsccjIzM7V79269/vrrLe3Cb4SHd+lQ/foT02ukvvNDt24d9zpXps+h6fVJ5tfYnvW1KOQ89thj+uijj/Taa6+pR48e9vaIiAjV1NSooqLCbTXH5XIpMjLSbnPmWVCnzr46vc2ZZ2SVl5crNDRUnTp1ksPhUGBgYIODjF0uV4MVIE+4XJWyLK/vdlYBAT9Pqq/79Sem10h9/i0w0OHTYHLo0FHV1dX7rL+20NHnsDmm1yeZX2Nr1neq7+Z4FXIsy9Ljjz+u9957T2vWrFHv3r3d9icmJio4OFgFBQUaMmSIJGnv3r0qLS1VcnKyJCk5OVlLly6Vy+WyP27Kz89XaGiooqOj7TaffPKJW9/5+fl2HyEhIUpISFBBQYGuu+46ST9/fFZQUKCxY8d6U9I/61Kr/IK1Vr/+xPQaqe/80VGfB9Pn0PT6JPNrbM/6vDrwODMzU3/+85/11FNP6aKLLlJZWZnKysp04sQJSVKXLl00YsQILViwQFu2bFFxcbFmzZqllJQUO6A4nU5FR0fr4Ycf1jfffKPNmzdryZIlGjNmjEJCQiRJo0eP1v79+7Vo0SLt2bNHOTk52rRpk8aNG2eP5c4779TatWu1fv167dmzR3PnztXx48c1fPhw3zwzAACgQ/NqJed//ud/JEm33Xab2/asrCw7XMyaNUsOh0NTp05VdXW1nE6n5syZY7cNDAzU0qVLNXfuXI0aNUqdO3dWRkaGpk6darfp3bu3li1bpqysLK1evVo9evTQvHnzNGDAALvN0KFDdfDgQWVnZ6usrEzx8fFasWJFiz6uAgAA5vEq5OzcubPZNhdccIHmzJnjFmzO9K//+q9avnx5k/2kpqbqzTffbLLN2LFjW/TxFAAAMB/XrgIAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIwU1N4DAIAzORwBcjgCzro/MJC/zwA0j5ADwK84HAEKu/hCBRFkAJwjQg4Av+JwBCgo0KFpuYUqOVDVaJtfx0Zq+pC4Nh4ZgI6GkAPAL5UcqNK20opG90VFXtTGowHQEbEeDAAAjETIAQAARiLkAAAAI3kdcr744gvdc889cjqdio2N1fvvv++237IsPfPMM3I6nerbt6/GjRun7777zq3N4cOH9dBDD6lfv37q37+/Zs2apaNHj7q1+eabb/T73/9effr00cCBA7V8+fIGY9m0aZNuuOEG9enTRzfffLM+/vhjb8sBAACG8jrkHDt2TLGxsZozZ06j+5cvX641a9Zo7ty5Wrt2rTp37qzx48fr5MmTdps//vGPKikp0apVq7R06VJ9+eWXevTRR+39VVVVGj9+vHr27Kl169bp4Ycf1nPPPac//elPdpu//vWveuihh3TLLbfozTff1LXXXqtJkyZp165d3pYEAAAM5HXIGThwoB544AENHjy4wT7LsrR69Wrde++9uu666xQXF6dFixbpwIED9orPnj17tHnzZs2bN09JSUnq37+/Zs+erQ0bNugf//iHJOnPf/6zampqNH/+fF1xxRUaNmyYbrvtNq1atcp+rNWrV2vAgAH6wx/+oKioKN1///268sor9dprr7X0uQAAAAbx6SnkP/zwg8rKypSenm5v69Kli5KSklRYWKhhw4apsLBQXbt2VZ8+few26enpcjgc2rp1qwYPHqyioiL1799fISEhdhun06nly5fryJEjCgsLU1FRkcaNG+f2+E6ns8HHZ54IOPsXq7bIqf583a8/Mb1G6ju/NPcNypZlqb7eaqPReMb0OTS9Psn8GluzPk/79GnIKSsrkySFh4e7bQ8PD1d5ebkkqby8XJdccon7IIKCFBYWZt+/vLxcvXr1cmsTERFh7wsLC1N5ebm9rbHH8UZ4eBev79Oe/foT02ukPrNFhl6gunpLXbt2brJdXb2lwCYuM9GeTJ9D0+uTzK+xPevjywAluVyVsnz4R1pAwM+T6ut+/YnpNVJf+wkMdKhbt7b5sr+unYMU6Aho8tuVo7uH6pnRKTp06Kjq6urbZFye8Oc59AXT65PMr7E16zvVd3N8GnIiIyMlSS6XS927d7e3u1wuxcX9/BXsEREROnjwoNv9amtrdeTIEfv+ERERDVZkTv18avWmsTYul6vB6o4nLEut8gvWWv36E9NrpL7zQ1Pfrnw6f3yuTJ9D0+uTzK+xPevz6ffk9OrVS5GRkSooKLC3VVVV6euvv1ZKSookKSUlRRUVFSouLrbbbNmyRfX19erbt68kKTk5WV9++aVqamrsNvn5+br88ssVFhZmt9myZYvb4+fn5ys5OdmXJQEAgA7K65Bz9OhR7dixQzt27JD088HGO3bsUGlpqQICAnT77bfrxRdf1AcffKCdO3fq4YcfVvfu3XXddddJkqKiojRgwAA98sgj2rp1q7766is9/vjjGjZsmP7lX/5FknTzzTcrODhY//Vf/6Xdu3dr48aNWr16te688057HLfffrs2b96sl19+WXv27NGzzz6r4uJijR071hfPCwAA6OC8/riquLhYt99+u/1zVlaWJCkjI0MLFizQ3XffrePHj+vRRx9VRUWFrrrqKq1YsUIXXHCBfZ/Fixfr8ccf1x133CGHw6Hrr79es2fPtvd36dJFK1eu1GOPPabhw4erW7duuu+++zRq1Ci7Tb9+/bR48WItWbJETz/9tC677DI9//zziomJadETAQAAzOJ1yElNTdXOnTvPuj8gIEDTpk3TtGnTztrm4osv1lNPPdXk48TFxen1119vss2NN96oG2+8sekBAwCA8xLXrgIAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARvLpVcgBoDkOR4AcjoCz7g8M5G8vAL5ByAHQZhyOAIVdfKGCCDIA2gAhB0CbcTgCFBTo0LTcQpUcqGq0za9jIzV9SFwbjwyAiQg5ANpcyYEqbSutaHRfVORFbTwaAKZizRgAABiJkAMAAIxEyAEAAEbimBwA8EBzp7bX11uqr7faaDQAPEHIAYAmRIZeoLp6S127dm6yXW1dvY4cPkbQAfwIIQcAmtC1c5ACHQFNnvYe3T1Uz4xOkcMRQMgB/AghBwA80NRp7wD8EwceAwAAI7GSA8BnuC4VAH9CyAHgE1yXCoC/IeQA8AmuSwXA3xByAPgU16UC4C9YVwYAAEYi5AAAACPxcRUA+AiXfgD8CyEHAM4Rl34A/BMhB4BH+A6cs+PSD4B/IuQAaBbfgeMZLv0A+BdCDoBm8R04ADoiQg4Aj/EdOAA6EtaeAQCAkQg5AADASIQcAABgJI7JAc5zzZ0aLp3fp4f7Gl8YCLQdQg5wHnM4AtQ1jFPD2wJfGAi0PUIOcB4LCGj+1HCJ08N9gS8MBNoeIQdAs19ix+nhvsMXBgJth5ADGIxLMQA4nxFyAEN5cimG5o4PQfvw5OBky+LjLKA5hBzAUFyKoePx5uDkiiPH2mhUQMdFyAEMx6UYOg5vDk4OCGj6tH8AhBygw+J4G3NxcDLgG4QcoAPy5HgbmO1UiD1bmOVLBQFCDuCXPFml4Xib89OZx+1069b4R458qSBAyAH8jjerNBxvc/7x5rid4OBA1dXVn7UvVntgOkIO0MZYpYEvNBVwuYQE8DNCDtCGWKVBW2C1B/gZIQfwkCdX624OqzRoS6z24HxHyAE84OkKTF29pUAPghCrNGhvrPbgfEDIAXT2VZrTT9P1dAWGVRp0JL5a7amqPHHOl5ogLMHXCDnwW774eMgTAQEBCu3SqdFVmjNPz/VkBYZVGpjCk9WeX17WTY/clKCLL76wyb48WeVsLCyd+T1ABCF4o8OHnJycHK1cuVJlZWWKi4vTI488or59+7b3sCR5dpG9jvZiPTN4tNa36jYVPE7nyRunpx8hsQIDNK654N5cEPJklfNsYenMPzQ8WTXqiO+taB0dOuRs3LhRWVlZyszMVFJSkl599VWNHz9e7777rsLDw9ttXA5HgOrqrbN+SdcpvlribSuNBY/Gamzr4OGrNqzAAC3ni1VOX60ateV76/kcqNpqtf1cdOiQs2rVKt16660aMWKEJCkzM1MfffSR8vLyNGHChHYbV0BAQJsu8bZlG8n/ggcfIQHmaKsg5Kv3RF8Eqo54nTlvVtsdjgDV1bVPEOywIae6ulrbtm3TxIkT7W0Oh0Pp6ekqLCz0qi+HQ/Jl4D91ceALghzqHBLYaJtuF4Yo0BGgpR/tUemR44226fOvYRrZv7fftWmqrpB//sL7qk1Cz65nbRMVGUqbNmjjj2Oizfndxl/eW6/oHqrfp/7bOQeqbt0u8rs/aD39o7ep56dnWGfd8+soORwBPl9VC/BwASnA6iiflZzhH//4h371q18pNzdXKSkp9vZFixbpiy++0P/+7/+24+gAAEB763hrZAAAAB7osCGnW7duCgwMlMvlctvucrkUERHRTqMCAAD+osOGnJCQECUkJKigoMDeVl9fr4KCArePrwAAwPmpwx54LEl33nmnZsyYocTERPXt21evvvqqjh8/ruHDh7f30AAAQDvr0CFn6NChOnjwoLKzs1VWVqb4+HitWLGCj6sAAEDHPbsKAACgKR32mBwAAICmEHIAAICRCDkAAMBIhBwAAGAkQk4LvPjiixo9erSSkpLUv39/j+5jWZaeeeYZOZ1O9e3bV+PGjdN3333n1ubw4cN66KGH1K9fP/Xv31+zZs3S0aNHW6GC5nk7lh9++EGxsbGN3jZt2mS3a2z/hg0b2qIkNy15rm+77bYGY3/00Ufd2pSWlmrChAlKSkpSWlqaFi5cqNra2tYs5ay8rfHw4cN6/PHHNWTIEPXt21e//vWvNW/ePFVWVrq1a685zMnJ0aBBg9SnTx+NHDlSW7dubbL9pk2bdMMNN6hPnz66+eab9fHHH7vt9+Q12da8qXHt2rX6/e9/r1/+8pf65S9/qXHjxjVoP3PmzAZzNX78+NYu46y8qW/dunUNxt6nTx+3Nv42h97U19j7SWxsrNvFpf1p/r744gvdc889cjqdio2N1fvvv9/sfT777DNlZGQoMTFRgwcP1rp16xq08fZ17TULXnvmmWesVatWWVlZWdZVV13l0X2WLVtmXXXVVdZ7771n7dixw7rnnnusQYMGWSdOnLDbjB8/3vrtb39rFRUVWV988YU1ePBg68EHH2ytMprk7Vhqa2utAwcOuN2effZZKzk52aqqqrLbxcTEWHl5eW7tTn8O2kpLnuuxY8das2fPdht7ZWWlvb+2tta66aabrHHjxlnbt2+3PvroIys1NdV66qmnWrucRnlb486dO63JkydbH3zwgbVv3z4rPz/fuv76660pU6a4tWuPOdywYYOVkJBgvfHGG9bu3but2bNnW/3797fKy8sbbf/VV19Z8fHx1vLly62SkhLrv//7v62EhARr586ddhtPXpNtydsaH3zwQeu1116ztm/fbpWUlFgzZ860rrrqKuunn36y28yYMcMaP36821wdPny4rUpy4219eXl5Vr9+/dzGXlZW5tbGn+bQ2/oOHTrkVtuuXbus+Ph4Ky8vz27jT/P30UcfWU8//bT1l7/8xYqJibHee++9Jtt///33VlJSkpWVlWWVlJRYa9asseLj461PPvnEbuPtc9YShJxzkJeX51HIqa+vt6655hprxYoV9raKigorMTHReueddyzLsqySkhIrJibG2rp1q93m448/tmJjY93etNqCr8by7//+79Z//ud/um3z5MXR2lpa39ixY6158+addf9HH31kxcXFub0Rv/7661a/fv2skydP+mbwHvLVHG7cuNFKSEiwampq7G3tMYe33HKLlZmZaf9cV1dnOZ1Oa9myZY22nzZtmjVhwgS3bSNHjrQeeeQRy7I8e022NW9rPFNtba2VkpJirV+/3t42Y8YM69577/X1UFvE2/qae3/1tzk81/lbtWqVlZKSYh09etTe5k/zdzpP3gMWLVpkDRs2zG3b/fffb9111132z+f6nHmCj6vawA8//KCysjKlp6fb27p06aKkpCQVFhZKkgoLC9W1a1e35dj09HQ5HA7fL981wxdjKS4u1o4dO3TLLbc02JeZmanU1FTdcssteuONN2S18Vc1nUt9b7/9tlJTU3XTTTfpqaee0vHjx+19RUVFiomJcfsySqfTqaqqKpWUlPi+kCb46vepqqpKoaGhCgpy/97QtpzD6upqbdu2ze3143A4lJ6ebr9+zlRUVKS0tDS3bU6nU0VFRZI8e022pZbUeKbjx4+rtrZWYWFhbts///xzpaWlaciQIZozZ44OHTrk07F7oqX1HTt2TL/5zW80cOBA3Xvvvdq9e7e9z5/m0Bfzl5eXp2HDhunCCy902+4P89cSzb0GffGceaJDf+NxR1FWViZJCg8Pd9seHh6u8vJySVJ5ebkuueQSt/1BQUEKCwuz799WfDGWN954Q1FRUerXr5/b9qlTp+rqq69W586d9emnnyozM1PHjh3T7bff7rPxN6el9d10003q2bOnunfvrp07d2rx4sX69ttv9dxzz9n9nvlt26d+7ohzePDgQb3wwgsaNWqU2/a2nsNDhw6prq6u0dfP3r17G71PY3Nx+uvNk9dkW2pJjWdavHixunfv7vafxoABAzR48GD16tVL+/fv19NPP627775bf/rTnxQYGOjTGprSkvouv/xyzZ8/X7GxsaqsrNTLL7+s0aNHa8OGDerRo4dfzeG5zt/WrVu1a9cuPfHEE27b/WX+WuJs74dVVVU6ceKEjhw5cs6/854g5PzT4sWLtXz58ibbbNy4UVFRUW00It/ztMZzdeLECb3zzju67777GuybNGmS/e8rr7xSx48f18qVK33yH2Rr13f6f/axsbGKjIzUuHHj9P333+vSSy9tcb/eaKs5rKqq0sSJExUVFaXJkye77WvNOUTLvPTSS9q4caNWr16tCy64wN4+bNgw+9+nDly97rrr7NUBf5aSkuJ2seWUlBQNHTpUubm5uv/++9tvYK3gjTfeUExMjPr27eu2vSPPn78g5PzTXXfdpYyMjCbb9O7du0V9R0ZGSpJcLpe6d+9ub3e5XIqLi5P0c8I9ePCg2/1qa2t15MgR+/7nytMaz3Us7777rk6cOKHf/e53zbZNSkrSCy+8oOrqaoWEhDTbviltVd8pSUlJkqR9+/bp0ksvVURERIOPgk79RdmR5rCqqkp/+MMfdNFFF+n5559XcHBwk+19OYeN6datmwIDA+Vyudy2u1yus16nLiIiosFf86e39+Q12ZZaUuMpK1eu1EsvvaRVq1Y1O/bevXurW7du2rdvX5v+J3ku9Z0SHBys+Ph4ff/995L8aw7Ppb5jx45pw4YNmjp1arOP017z1xKNvQbLy8sVGhqqTp06yeFwnPPvhCc4JuefLrnkEkVFRTV5a+kbeK9evRQZGamCggJ7W1VVlb7++mv7L5WUlBRVVFSouLjYbrNlyxbV19c3SPct5WmN5zqWvLw8DRo0qMHHJY3ZsWOHwsLCfPKfY1vVd/rYpf//ZpucnKxdu3a5vWjz8/MVGhqq6Ojoc66vLWqsqqrS+PHjFRwcrBdffNFtVeBsfDmHjQkJCVFCQoLb66e+vl4FBQVuf+mfLjk5WVu2bHHblp+fr+TkZEmevSbbUktqlKTly5frhRde0IoVKxqcXt2Yn376SYcPH/ZZ6PZUS+s7XV1dnXbt2mWP3Z/m8Fzqe/fdd1VdXa3f/va3zT5Oe81fSzT3GvTF74RHfHYI83nk73//u7V9+3b7FOnt27db27dvdztVesiQIdZf/vIX++dly5ZZ/fv3t95//33rm2++se69995GTyH/3e9+Z3399dfWl19+aV1//fXtegp5U2P56aefrCFDhlhff/212/2+++47KzY21vr4448b9PnBBx9Ya9eutXbu3Gl99913Vk5OjpWUlGQ988wzrV7Pmbytb9++fdZzzz1n/e1vf7P2799vvf/++9a1115rjRkzxr7PqVPI77rrLmvHjh3WJ598Yl199dXtegq5NzVWVlZaI0eOtG666SZr3759bqet1tbWWpbVfnO4YcMGKzEx0Vq3bp1VUlJiPfLII1b//v3tM9mmT59uLV682G7/1VdfWVdeeaW1cuVKq6SkxMrOzm70FPLmXpNtydsaly1bZiUkJFjvvvuu21ydeh+qqqqyFixYYBUWFlr79++38vPzrYyMDOv6669v87P9WlLfs88+a23evNn6/vvvreLiYuuBBx6w+vTpY+3evdtu409z6G19p/zHf/yHdf/99zfY7m/zV1VVZf9fFxMTY61atcravn279fe//92yLMtavHixNX36dLv9qVPIFy5caJWUlFivvfZao6eQN/Wc+QIfV7VAdna21q9fb/986mOZ1atXKzU1VZL07bffun2J2t13363jx4/r0UcfVUVFha666iqtWLHC7S/lxYsX6/HHH9cdd9whh8Oh66+/XrNnz26bos7Q3Fhqamr07bffup1dJP28itOjRw85nc4GfQYFBSknJ0fz58+XJF166aWaOXOmbr311tYtphHe1hccHKyCggKtXr1ax44d0y9+8Qtdf/31bscdBQYGaunSpZo7d65GjRqlzp07KyMjw6Nl6NbgbY3btm3T119/LUkaPHiwW18ffPCBevXq1W5zOHToUB08eFDZ2dkqKytTfHy8VqxYYS9r//jjj3I4/v/CdL9+/bR48WItWbJETz/9tC677DI9//zziomJsdt48ppsS97WmJubq5qamga/X5MnT9aUKVMUGBioXbt26c0331RlZaW6d++ua665RtOmTWu1VbemeFtfRUWFHnnkEZWVlSksLEwJCQnKzc11WxX1pzn0tj5J2rt3r7766iu9/PLLDfrzt/krLi52O+4uKytLkpSRkaEFCxaorKxMP/74o72/d+/eWrZsmbKysrR69Wr16NFD8+bN04ABA+w2zT1nvhBgWW18/i4AAEAb4JgcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIz0/wD6cGmY61UJDwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Axes(0.125,0.11;0.775x0.77)\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAGdCAYAAADwjmIIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAsaElEQVR4nO3dfVBUV57G8acbJDqiiIBxXM0mIwoqKBhTLkyzbEyMKY1ThcZoaWJ0nfgezcSJsRyjohaowzjG6KxEHRKiGeLGlzGrTm0yO3GwQBMdWQtjouhOJMMk0viKr7zc/SNrbzoo0Nh024fvp4oquX363nN/F+yHe86912ZZliUAAADD2P3dAQAAgOZAyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARgr2dwfuBRUVl+XNh1vYbFJERDuvrxfuqLPvUGvfoM6+QZ19oznrfGvdDSHkSLIsNcsPenOtF+6os+9Qa9+gzr5BnX3Dn3VmuAoAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkXgKeTMKCqo/Q9bWWqqt5RG4AAA0B0JOM7DbbaqptRQe3rbedtU1tbp44SpBBwCAZkDIaQY2m01Bdptm5x1RydnK27aJ7hSq18ckym63EXIAAGgGhJxmVHK2UsfKLvm7GwAAtEhMPAYAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASB6FnOzsbI0cOVKJiYlKSkrS9OnTdfr0abc2zz33nGJiYty+Fi5c6NamrKxMkydPVr9+/ZSUlKQVK1aourrarc3BgweVlpamuLg4DR48WNu3b6/Tny1btmjQoEGKj4/XqFGjdPToUU92BwAAGMyjkPPJJ59o3Lhx2rp1q3JyclRdXa1Jkybp6tWrbu2eeeYZ7d+/3/U1d+5c12s1NTWaMmWKqqqqlJeXp+XLl2vHjh1as2aNq01paammTJmigQMH6ve//72ef/55LViwQPn5+a42e/bsUWZmpmbMmKEdO3YoNjZWkyZNUkVFRVNrAQAADOJRyNm0aZNGjBihHj16KDY2VsuXL1dZWZmOHTvm1q5169aKiopyfYWGhrpe279/v0pKSvTLX/5SvXr1UmpqqmbPnq0tW7bo5s2bkqS8vDx17dpV8+bNU/fu3fXss89qyJAheuutt1zrycnJ0TPPPKORI0cqOjpa6enpat26tbZt23YX5QAAAKYIvps3X758WZIUFhbmtvyDDz7Qrl27FBUVpUcffVTTp09XmzZtJElFRUXq2bOnIiMjXe0dDocWL16skpIS9e7dW0VFRUpKSnJbp8PhUEZGhiTp5s2bOnbsmKZMmeJ63W63Kzk5WUeOHPF4P2w2j9/i1fV5e/stxa26Ub/mR619gzr7BnX2jeasc2PX2eSQU1tbq4yMDPXv3189e/Z0LX/qqafUpUsXderUSV988YWysrL0P//zP1q7dq0kyel0ugUcSa7vy8vL621TWVmp69ev6+LFi6qpqVFERIRbm4iIiDpzhBojIqKdx+/xlvDwtn7btin8efxaGmrtG9TZN6izb/izzk0OOenp6Tp58qTeffddt+WjR492/TsmJkZRUVGaMGGCzpw5owceeKDpPW1GFRWXZVneW19wsF0dOjQuvJw/f0U1NbXe23gLYrN9+8vj7eOHuqi1b1Bn36DOvtGcdb617oY0KeQsWbJEH3/8sTZv3qzOnTvX27Zfv36SpC+//FIPPPCAIiMj61wF5XQ6JUlRUVGSvj1rc2vZd9uEhoaqdevWstvtCgoKqjPJuKKios4ZoMawLHn1AHi6Ln7J7o63jx/ujFr7BnX2DersG/6ss0cTjy3L0pIlS/Thhx/q7bffVrdu3Rp8z/HjxyX9f4BJSEjQiRMn3AJKQUGBQkNDFR0d7Wpz4MABt/UUFBQoISFBkhQSEqI+ffqosLDQ9Xptba0KCwuVmJjoyS4BAABDeRRy0tPTtWvXLv3qV79S27ZtVV5ervLycl2/fl2SdObMGa1bt07FxcX66quv9Mc//lGvvvqqHnnkEcXGxkr6dgJxdHS05s6dq88//1z5+flavXq1xo0bp5CQEEnSmDFjVFpaqpUrV+rUqVPasmWL9u7dqwkTJrj6MnHiRG3dulU7duzQqVOntHjxYl27dk0jRozwUmkAAEAg82i46ne/+52kb2/4912ZmZkaMWKEWrVqpcLCQuXm5urq1av64Q9/qCeeeELTp093tQ0KCtL69eu1ePFijR49Wm3atFFaWppmzZrlatOtWzdlZ2crMzNTubm56ty5s5YtW6aUlBRXm6FDh+rcuXNas2aNysvL1atXL23cuLFJw1UAAMA8NstiRNLp9P7E4/Dwthq2Jl/Hyi7dtk2fLu21e1aKzp+/oupqJh43hc0mRUa28/rxQ13U2jeos29QZ99ozjrfWndDeHYVAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACM5FHIyc7O1siRI5WYmKikpCRNnz5dp0+fdmtz48YNpaena+DAgUpMTNSLL74op9Pp1qasrEyTJ09Wv379lJSUpBUrVqi6utqtzcGDB5WWlqa4uDgNHjxY27dvr9OfLVu2aNCgQYqPj9eoUaN09OhRT3YHAAAYzKOQ88knn2jcuHHaunWrcnJyVF1drUmTJunq1auuNhkZGfrTn/6k1atX65133tHZs2c1c+ZM1+s1NTWaMmWKqqqqlJeXp+XLl2vHjh1as2aNq01paammTJmigQMH6ve//72ef/55LViwQPn5+a42e/bsUWZmpmbMmKEdO3YoNjZWkyZNUkVFxd3UAwAAGMKjkLNp0yaNGDFCPXr0UGxsrJYvX66ysjIdO3ZMknT58mVt27ZN8+bNU1JSkuLi4pSRkaEjR46oqKhIkrR//36VlJTol7/8pXr16qXU1FTNnj1bW7Zs0c2bNyVJeXl56tq1q+bNm6fu3bvr2Wef1ZAhQ/TWW2+5+pKTk6NnnnlGI0eOVHR0tNLT09W6dWtt27bNO5UBAAAB7a7m5Fy+fFmSFBYWJkkqLi5WVVWVkpOTXW26d++uLl26uEJOUVGRevbsqcjISFcbh8OhyspKlZSUuNokJSW5bcvhcLjWcfPmTR07dsxtO3a7XcnJyTpy5IjH+2Gzef/L39tvKV/Uj1qb9kWdqbNJX81Z58YI9uzj+P/V1tYqIyND/fv3V8+ePSVJTqdTrVq1Uvv27d3aRkREqLy83NXmuwFHkuv7htpUVlbq+vXrunjxompqahQREVFnO9+fI9QYERHtPH6Pt4SHt/Xbtk3hz+PX0lBr36DOvkGdfcOfdW5yyElPT9fJkyf17rvverM/flFRcVmW5b31BQfb1aFD48LL+fNXVFNT672NtyA227e/PN4+fqiLWvsGdfYN6uwbzVnnW+tuSJNCzpIlS/Txxx9r8+bN6ty5s2t5ZGSkqqqqdOnSJbezORUVFYqKinK1+f5VULeuvvpum+9fkeV0OhUaGqrWrVvLbrcrKCioziTjioqKOmeAGsOy5NUD4Om6+CW7O94+frgzau0b1Nk3qLNv+LPOHs3JsSxLS5Ys0Ycffqi3335b3bp1c3s9Li5OrVq1UmFhoWvZ6dOnVVZWpoSEBElSQkKCTpw44RZQCgoKFBoaqujoaFebAwcOuK27oKDAtY6QkBD16dPHbTu1tbUqLCxUYmKiJ7sEAAAM5VHISU9P165du/SrX/1Kbdu2VXl5ucrLy3X9+nVJUrt27TRy5EgtX75cBw4cUHFxsebPn6/ExERXQHE4HIqOjtbcuXP1+eefKz8/X6tXr9a4ceMUEhIiSRozZoxKS0u1cuVKnTp1Slu2bNHevXs1YcIEV18mTpyorVu3aseOHTp16pQWL16sa9euacSIEd6pDAAACGgeDVf97ne/kyQ999xzbsszMzNd4WL+/Pmy2+2aNWuWbt68KYfDoUWLFrnaBgUFaf369Vq8eLFGjx6tNm3aKC0tTbNmzXK16datm7Kzs5WZmanc3Fx17txZy5YtU0pKiqvN0KFDde7cOa1Zs0bl5eXq1auXNm7c2KThKgAAYB6bZTEi6XR6f+JxeHhbDVuTr2Nll27bpk+X9to9K0Xnz19RdTUTj5vCZpMiI9t5/fihLmrtG9TZN6izbzRnnW+tuyE8uwoAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEbyOOR8+umnmjp1qhwOh2JiYvTRRx+5vT5v3jzFxMS4fU2aNMmtzYULFzRnzhz1799fAwYM0Pz583XlyhW3Np9//rnGjh2r+Ph4paamasOGDXX6snfvXj355JOKj4/X8OHDtW/fPk93BwAAGMrjkHP16lXFxMRo0aJFd2yTkpKi/fv3u75WrVrl9vrPf/5zlZSUKCcnR+vXr9ehQ4e0cOFC1+uVlZWaNGmSunTpou3bt2vu3Llau3at3nvvPVebv/zlL5ozZ46efvpp7dy5U4899phmzJihEydOeLpLAADAQMGeviE1NVWpqan1tgkJCVFUVNRtXzt16pTy8/P1/vvvKz4+XpK0YMECTZ48WXPnztX999+vXbt2qaqqShkZGQoJCVGPHj10/Phx5eTkaPTo0ZKk3NxcpaSk6Kc//akk6aWXXlJBQYE2b96sJUuWeLpbAADAMB6HnMb45JNPlJSUpPbt2+uf/umf9NJLLyk8PFySdOTIEbVv394VcCQpOTlZdrtdR48e1eDBg1VUVKQBAwYoJCTE1cbhcGjDhg26ePGiwsLCVFRUpAkTJrht1+Fw1Bk+awybrWn76a31eXv7LcWtulG/5ketfYM6+wZ19o3mrHNj1+n1kJOSkqLBgwera9euKi0t1apVq/TCCy/ovffeU1BQkJxOpzp27OjeieBghYWFqby8XJLkdDrVtWtXtzaRkZGu18LCwuR0Ol3LbomIiJDT6fS4zxER7Tx+j7eEh7f127ZN4c/j19JQa9+gzr5BnX3Dn3X2esgZNmyY69+3Jh4//vjjrrM796KKisuyLO+tLzjYrg4dGhdezp+/opqaWu9tvAWx2b795fH28UNd1No3qLNvUGffaM4631p3Q5pluOq7unXrpvDwcH355ZdKSkpSZGSkzp0759amurpaFy9edM3jiYyMrHNG5tb3t87e3K5NRUVFnbM7jWFZ8uoB8HRd/JLdHW8fP9wZtfYN6uwb1Nk3/FnnZr9Pztdff60LFy64AkxiYqIuXbqk4uJiV5sDBw6otrZWffv2lSQlJCTo0KFDqqqqcrUpKCjQQw89pLCwMFebAwcOuG2roKBACQkJzbxHAAAgEHgccq5cuaLjx4/r+PHjkqSvvvpKx48fV1lZma5cuaIVK1aoqKhIX331lQoLCzV9+nT94z/+o1JSUiRJ3bt3V0pKil577TUdPXpUhw8f1tKlSzVs2DDdf//9kqThw4erVatW+sUvfqGTJ09qz549ys3N1cSJE139GD9+vPLz8/Xb3/5Wp06d0htvvKHi4mI9++yz3qgLAAAIcB4PVxUXF2v8+PGu7zMzMyVJaWlpWrx4sU6cOKGdO3fq8uXL6tSpk3784x9r9uzZbldKZWVlaenSpXr++edlt9v1xBNPaMGCBa7X27Vrp02bNmnJkiUaMWKEwsPDNX36dNfl45LUv39/ZWVlafXq1Vq1apUefPBBrVu3Tj179mxSIQAAgFlslsWIpNPp/YnH4eFtNWxNvo6VXbptmz5d2mv3rBSdP39F1dVMPG4Km02KjGzn9eOHuqi1b1Bn36DOvtGcdb617obw7CoAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkYL93QEAABB47Hab7Habv7tRL0IOAADwiN1uU1iHHyg4qP4BoZpaS3a7TTU1lo965o6QAwAAPGK32xQcZNfsvCMqOVt52zbRnUL1+phE2Ww2SYQcAAAQQErOVupY2SV/d+OOmHgMAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABjJ45Dz6aefaurUqXI4HIqJidFHH33k9rplWXr99dflcDjUt29fTZgwQX/961/d2ly4cEFz5sxR//79NWDAAM2fP19Xrlxxa/P5559r7Nixio+PV2pqqjZs2FCnL3v37tWTTz6p+Ph4DR8+XPv27fN0dwAAgKE8DjlXr15VTEyMFi1adNvXN2zYoHfeeUeLFy/W1q1b1aZNG02aNEk3btxwtfn5z3+ukpIS5eTkaP369Tp06JAWLlzoer2yslKTJk1Sly5dtH37ds2dO1dr167Ve++952rzl7/8RXPmzNHTTz+tnTt36rHHHtOMGTN04sQJT3cJAAAYyOOQk5qaqp/97GcaPHhwndcsy1Jubq6mTZumxx9/XLGxsVq5cqXOnj3rOuNz6tQp5efna9myZerXr58GDBigBQsWaPfu3frmm28kSbt27VJVVZUyMjLUo0cPDRs2TM8995xycnJc28rNzVVKSop++tOfqnv37nrppZfUu3dvbd68uam1AAAABvHqs6u++uorlZeXKzk52bWsXbt26tevn44cOaJhw4bpyJEjat++veLj411tkpOTZbfbdfToUQ0ePFhFRUUaMGCAQkJCXG0cDoc2bNigixcvKiwsTEVFRZowYYLb9h0OR53hs8aweflJ8Z6uz9vbbylu1Y36NT9q7RvU2Teos2/ZbP77nPVqyCkvL5ckRUREuC2PiIiQ0+mUJDmdTnXs2NG9E8HBCgsLc73f6XSqa9eubm0iIyNdr4WFhcnpdLqW3W47noiIaOfxe7wlPLyt37ZtCn8ev5aGWvsGdfYN6uwbHTr473OOp5BLqqi4LMuLT4EPDrY3+qCeP39FNTW13tt4C2KzffuflLePH+qi1r5BnX2DOt+9oCB7o/9Iv3Dhiqqrvfs5d+sYNsSrIScqKkqSVFFRoU6dOrmWV1RUKDY2VtK3Z2TOnTvn9r7q6mpdvHjR9f7IyMg6Z2RufX/r7M3t2lRUVNQ5u9MYliWv/qB7ui5+ye6Ot48f7oxa+wZ19g3q7Bv+rLNX75PTtWtXRUVFqbCw0LWssrJS//3f/63ExERJUmJioi5duqTi4mJXmwMHDqi2tlZ9+/aVJCUkJOjQoUOqqqpytSkoKNBDDz2ksLAwV5sDBw64bb+goEAJCQne3CUAABCgPA45V65c0fHjx3X8+HFJ3042Pn78uMrKymSz2TR+/Hj927/9m/74xz/qiy++0Ny5c9WpUyc9/vjjkqTu3bsrJSVFr732mo4eParDhw9r6dKlGjZsmO6//35J0vDhw9WqVSv94he/0MmTJ7Vnzx7l5uZq4sSJrn6MHz9e+fn5+u1vf6tTp07pjTfeUHFxsZ599llv1AUAAAQ4j4eriouLNX78eNf3mZmZkqS0tDQtX75cL7zwgq5du6aFCxfq0qVLevjhh7Vx40bdd999rvdkZWVp6dKlev7552W32/XEE09owYIFrtfbtWunTZs2acmSJRoxYoTCw8M1ffp0jR492tWmf//+ysrK0urVq7Vq1So9+OCDWrdunXr27NmkQgAAALPYLIsRSafT+xOPw8PbatiafB0ru3TbNn26tNfuWSk6f977E7JaCptNioxs5/Xjh7qotW9QZ9+gznfP359zt45hQ3h2FQAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgpGB/dwD1s9ttsttt9baprbVUW2v5qEcAAAQGQs49zG63KazDDxQcVP8Jt+qaWl28cJWgAwDAdxBy7mF2u03BQXbNzjuikrOVt20T3SlUr49JlN1uI+QAAPAdhJwAUHK2UsfKLtXbJqiBsz0MaQEAWhpCToCLCr1PNbWW2rdvU287hrQAAC0NISfAtW8TrCC7jSEtAAC+h5BjiMYMaQEA0JJwnxwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEbi6qoWhBsGAgBaEkKOn9UXPBoKJY3FDQMBAC0RIcdPGhs8vIEbBgIAWiJCjp80Jnj8S0yUXhkS67VtcsNAAEBLQsjxs/qCR/eotj7uDQAA5uDqKgAAYCSvh5w33nhDMTExbl9PPvmk6/UbN24oPT1dAwcOVGJiol588UU5nU63dZSVlWny5Mnq16+fkpKStGLFClVXV7u1OXjwoNLS0hQXF6fBgwdr+/bt3t6VFikoyK7g4Dt/2e02f3cRAIBGaZbhqh49eignJ8f1fVBQkOvfGRkZ2rdvn1avXq127dpp6dKlmjlzpvLy8iRJNTU1mjJliiIjI5WXl6ezZ8/q1VdfVatWrfTyyy9LkkpLSzVlyhSNGTNGWVlZKiws1IIFCxQVFaWUlJTm2CXjcQUWAMA0zRJygoKCFBUVVWf55cuXtW3bNmVlZSkpKUnSt6Fn6NChKioqUkJCgvbv36+SkhLl5OQoMjJSvXr10uzZs5WVlaWZM2cqJCREeXl56tq1q+bNmydJ6t69uw4fPqy33nqLkNNEXIEFADBNs4ScL7/8Ug6HQ/fdd58SEhI0Z84cdenSRcXFxaqqqlJycrKrbffu3dWlSxdXyCkqKlLPnj0VGRnpauNwOLR48WKVlJSod+/eKioqcoWk77bJyMhoUn9tXh6B8fb6fKmxV2DdC/t4qw/3Ql9MR619gzr7BnX2LZvNf5+zXg85ffv2VWZmph566CGVl5dr3bp1GjdunD744AM5nU61atVK7du3d3tPRESEysvLJUlOp9Mt4Ehyfd9Qm8rKSl2/fl2tW7f2qM8REe08at/ShYffW1d9cfx8h1r7BnX2DersGx06+O8zw+shJzU11fXv2NhY9evXT48++qj27t3rcfjwlYqKy7K8OPoSHGz360FtbpcuXVNNTe0dX7cs3zwewmb79j8pbx8/1EWtfYM6+wZ1vntBQfZG/8F74cIVVVff+TOjKW4dw4Y0+31y2rdvrwcffFBnzpxRcnKyqqqqdOnSJbezORUVFa45PJGRkTp69KjbOm5dffXdNt+/IsvpdCo0NLRJQcqy5NUfdFN/ae7VycnePn64M2rtG9TZN6izb/izzs0ecq5cuaLS0lJFRUUpLi5OrVq1UmFhoYYMGSJJOn36tMrKypSQkCBJSkhI0Pr161VRUaGIiAhJUkFBgUJDQxUdHe1q8+c//9ltOwUFBa51oHkwORkAEEi8HnJWrFihRx99VF26dNHZs2f1xhtvyG6366mnnlK7du00cuRILV++XGFhYQoNDdWyZcuUmJjoCigOh0PR0dGaO3euXnnlFZWXl2v16tUaN26cQkJCJEljxozRli1btHLlSo0cOVIHDhzQ3r17lZ2d7e3dwW3weAgAQCDwesj5+uuv9fLLL+vChQvq2LGjHn74YW3dulUdO3aUJM2fP192u12zZs3SzZs35XA4tGjRItf7g4KCtH79ei1evFijR49WmzZtlJaWplmzZrnadOvWTdnZ2crMzFRubq46d+6sZcuWcfn4PaShJ6jX1vpm3g4AoOXyesj59a9/Xe/r9913nxYtWuQWbL7vH/7hH7Rhw4Z61zNw4EDt3LmzKV1EM7pX5+0AAFoeHtAJr/LmvB273cZjJAAATUbIQbNozLyd+oa0bDabQtu1VnADw141tZZatQqqNywxNAYALRMhBz7X2CEtSfWeEXrkwXC99lQfhYX9oN51MDQGAC0TIQc+15ghrX+JidIrQ2LrPSPUPaotl7QDAO6IkAO/aSjAeGM9AICWi5CDFoFL2gGg5SHkwGhc0g4ALRchB0bjURQA0HIRctAiMG8HAFqe+icqAAAABCjO5AD/h8nJAGAWQg5aPCYnA4CZCDlo8TyZnNyqVZBqamrvuC7O9gDAvYOQA/yf+iYnc7YHAAIPIQdoBC5FB4DAQ8gBPHC3T1eXGNICAF8h5ABewpAWANxbCDmAl3hzAnNjcEYIAOpHyAG8zBsTmGtqLQXZbfW24YwQANSPkAP4UGPO9vxLTJReGRLLJGcAuEuEHMAP6jvb0z2qbYNtbmGSMwDcGSEHCEBMcgaAhhFygADEfXsAoGGEHCCAMaQFAHdGyAEM5cmQVuXl67Isgg4AsxByAEM1ZkjrkQfD9dpTfdShww8aXF9NrSW73aaaGsIQgMBAyAEM19CVXA0FIen/5/fYbDZJhBwAgYGQA6BRc3sAINAQcgA0GpOYAQQSQg6ABnlzEjNBCICvEHIANMibk5i5QSFaGrvdJnsDz6JrDP5A8BwhB0Cj3e0k5sY+hZ3/zGEKu92msA4/UHADQ708lLd5EHIAeJU3nsLOsBcCRUNnaYKC7AoOsnvtobz8geAZQg4An/H2sJc3bmLIhwKaqrFnaaS7fygvz6trGkIOAJ+722GvxgYhhgBwN7x5luZuefK8Os72/D9CDoB70t0GIYYAcDe8fZbGWzjb4xlCDoCAxRAA7kZ9933y5Vkab/HkbI/dbmsRP8+EHAAtFkMALZPdblNNraXw8IbPsvjyLI23NOYO5i3lxp6EHAAtHleEmaUxc2kaO9xpmpZ29pKQAwD14EaIgeVenUtzr2hpQ1qEHABoBF/dCFFqOUMJTXEvXfEUyO52SKuhn9F7BSEHALzEG8NejZkr4q17BDWGtwKVNx5tYLPZFNquNWdpmlljf1YDASEHAHygMcMEjbns3Zv3CGrsfYTuNlA1Npw0pj+SOEvTzDz5Wb3XEXIAwIfu9rJ3b90jyNeBSmpcOGlMG87S+IYJdSbkAEAA8kZYakwbbwYqb/UZaCxCDgCgXoQTBKrAmB4NAADgIUIOAAAwEiEHAAAYiZADAACMRMgBAABGCviQs2XLFg0aNEjx8fEaNWqUjh496u8uAQCAe0BAh5w9e/YoMzNTM2bM0I4dOxQbG6tJkyapoqLC310DAAB+FtAhJycnR88884xGjhyp6Ohopaenq3Xr1tq2bZu/uwYAAPwsYG8GePPmTR07dkxTpkxxLbPb7UpOTtaRI0c8WpfdLnnzOXe2/7u7eZ8u7dUmJOi2bbpHhdKGNgHR5l7sE21oQ5t7v82PIr+9CaTN9u3nrDfZGvmsV5vli8fYNoNvvvlG//zP/6y8vDwlJia6lq9cuVKffvqp/v3f/92PvQMAAP4W0MNVAAAAdxKwISc8PFxBQUF1JhlXVFQoMjLST70CAAD3ioANOSEhIerTp48KCwtdy2pra1VYWOg2fAUAAFqmgJ14LEkTJ07Uq6++qri4OPXt21dvv/22rl27phEjRvi7awAAwM8COuQMHTpU586d05o1a1ReXq5evXpp48aNDFcBAIDAvboKAACgPgE7JwcAAKA+hBwAAGAkQg4AADASIQcAABiJkNNEW7Zs0aBBgxQfH69Ro0bp6NGj9bbfu3evnnzyScXHx2v48OHat2+fj3oa2Dyp89atWzV27Fg98sgjeuSRRzRhwoQGjwu+5enP8y27d+9WTEyMpk+f3sw9NIentb506ZLS09PlcDgUFxenIUOG8P9HI3ha57feektDhgxR3759lZqaqoyMDN24ccNHvQ1Mn376qaZOnSqHw6GYmBh99NFHDb7n4MGDSktLU1xcnAYPHqzt27c3bycteGz37t1Wnz59rPfff986efKktWDBAmvAgAGW0+m8bfvDhw9bvXr1sjZs2GCVlJRYv/71r60+ffpYX3zxhY97Hlg8rfPLL79sbd682frss8+skpISa968edbDDz9sff311z7ueWDxtM63lJaWWikpKdbYsWOtadOm+ai3gc3TWt+4ccMaMWKE9cILL1iHDh2ySktLrYMHD1rHjx/3cc8Di6d13rVrlxUXF2ft2rXLKi0ttfLz860f//jHVkZGho97Hlg+/vhja9WqVdZ//ud/Wj179rQ+/PDDetufOXPG6tevn5WZmWmVlJRY77zzjtWrVy/rz3/+c7P1kZDTBE8//bSVnp7u+r6mpsZyOBxWdnb2bdvPnj3bmjx5stuyUaNGWa+99lqz9jPQeVrn76uurrYSExOtHTt2NFMPzdCUOldXV1ujR4+2tm7dar366quEnEbytNbvvvuu9dhjj1k3b970VReN4Gmd09PTrfHjx7sty8zMtMaMGdOs/TRJY0LOypUrrWHDhrkte+mll6x//dd/bbZ+MVzloZs3b+rYsWNKTk52LbPb7UpOTtaRI0du+56ioiIlJSW5LXM4HCoqKmrOrga0ptT5+65du6bq6mqFhYU1VzcDXlPrvG7dOkVERGjUqFG+6KYRmlLr//qv/1JCQoKWLFmi5ORkPfXUU1q/fr1qamp81e2A05Q6JyYm6tixY64hrdLSUu3bt0+pqak+6XNL4Y/PwoC+47E/nD9/XjU1NYqIiHBbHhERodOnT9/2PU6ns85dmCMiIuR0Oputn4GuKXX+vqysLHXq1MntPzu4a0qdDx06pPfff187d+70QQ/N0ZRal5aW6sCBAxo+fLjefPNNnTlzRunp6aqurtbMmTN90e2A05Q6Dx8+XOfPn9fYsWNlWZaqq6s1ZswYTZ061RddbjFu91kYGRmpyspKXb9+Xa1bt/b6NjmTAyO9+eab2rNnj9auXav77rvP390xRmVlpebOnaulS5eqY8eO/u6O8SzLUkREhJYuXaq4uDgNHTpUU6dOVV5enr+7ZpSDBw8qOztbixYt0vbt27V27Vrt27dP69at83fXcJc4k+Oh8PBwBQUFqaKiwm15RUXFHZ+ZFRkZWeesTX3t0bQ637Jp0ya9+eabysnJUWxsbHN2M+B5WufS0lL97W9/07Rp01zLamtrJUm9e/fWH/7wBz3wwAPN2+kA1ZSf6aioKAUHBysoKMi17Ec/+pHKy8t18+ZNhYSENGufA1FT6vz666/rJz/5iWv4NSYmRlevXtXChQs1bdo02e2cD/CG230WOp1OhYaGNstZHIkzOR4LCQlRnz59VFhY6FpWW1urwsJCJSYm3vY9CQkJOnDggNuygoICJSQkNGdXA1pT6ixJGzZs0G9+8xtt3LhR8fHxvuhqQPO0zj/60Y/0wQcfaOfOna6vQYMGaeDAgdq5c6c6d+7sy+4HlKb8TPfv319nzpxxBUlJ+utf/6qoqCgCzh00pc7Xr1+vE2RuBUuLxzt6jV8+C5ttSrPBdu/ebcXFxVnbt2+3SkpKrNdee80aMGCAVV5eblmWZb3yyitWVlaWq/3hw4et3r17W5s2bbJKSkqsNWvWcAl5I3ha5+zsbKtPnz7WH/7wB+vs2bOur8rKSn/tQkDwtM7fx9VVjedprcvKyqzExERryZIl1unTp60//elPVlJSkvWb3/zGX7sQEDyt85o1a6zExETrP/7jP6wzZ85Y+/fvtx5//HFr9uzZftqDwFBZWWl99tln1meffWb17NnTysnJsT777DPrb3/7m2VZlpWVlWW98sorrva3LiFfsWKFVVJSYm3evLnZLyFnuKoJhg4dqnPnzmnNmjUqLy9Xr169tHHjRtep0L///e9ufxX0799fWVlZWr16tVatWqUHH3xQ69atU8+ePf21CwHB0zrn5eWpqqpKs2bNclvPzJkz9eKLL/q074HE0zqj6Tyt9Q9/+ENt2rRJmZmZ+slPfqL7779f48eP1wsvvOCvXQgIntZ52rRpstlsWr16tb755ht17NhRjz76qH72s5/5axcCQnFxscaPH+/6PjMzU5KUlpam5cuXq7y8XH//+99dr3fr1k3Z2dnKzMxUbm6uOnfurGXLliklJaXZ+mizLM7FAQAA8/DnGQAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABG+l/v00juJD0UBAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "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": 17, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:40.799375Z", "start_time": "2024-05-16T13:59:36.394236Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:25:45.310227Z", "iopub.status.busy": "2024-10-30T01:25:45.309792Z", "iopub.status.idle": "2024-10-30T01:25:47.688587Z", "shell.execute_reply": "2024-10-30T01:25:47.687844Z", "shell.execute_reply.started": "2024-10-30T01:25:45.310208Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "15003\n", "good_continue_at\n", "True 324924\n", "Name: count, dtype: int64\n", "\n", " Check some basics... \n", " preference\n", "False 162462\n", "True 162462\n", "Name: count, dtype: int64 is_30b\n", "True 324924\n", "Name: count, dtype: int64 model_name\n", "chirp-v3p5-engine-t-5 324924\n", "Name: count, dtype: int64 preference model_name \n", "False chirp-v3p5-engine-t-5 162462\n", "True chirp-v3p5-engine-t-5 162462\n", "Name: count, dtype: int64\n", "task\n", "cover 210678\n", " 74896\n", "infill 39028\n", "artist_consistency 322\n", "Name: count, dtype: int64\n" ] } ], "source": [ "df[\"id\"] = df[\"str_id\"]\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", "\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[\"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_30b\"].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())\n", "\n", "df[\"post_infill_duration\"] = (df[\"duration\"] \n", " + df[\"infill_context_end_s\"] \n", " - df[\"infill_context_start_s\"] \n", " - df[\"include_future_s\"] \n", " - df[\"include_history_s\"] \n", " - df[\"infill_dur_s\"])" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:47.689562Z", "iopub.status.busy": "2024-10-30T01:25:47.689395Z", "iopub.status.idle": "2024-10-30T01:25:48.525240Z", "shell.execute_reply": "2024-10-30T01:25:48.524648Z", "shell.execute_reply.started": "2024-10-30T01:25:47.689544Z" } }, "outputs": [ { "data": { "text/plain": [ "count 32194.000000\n", "mean 185.418950\n", "std 53.664311\n", "min -5.560000\n", "25% 153.120000\n", "50% 190.240000\n", "75% 223.760000\n", "max 348.200000\n", "Name: post_infill_duration, dtype: float64" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[\"post_infill_duration\"].describe()" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:48.526055Z", "iopub.status.busy": "2024-10-30T01:25:48.525896Z", "iopub.status.idle": "2024-10-30T01:25:48.747192Z", "shell.execute_reply": "2024-10-30T01:25:48.746655Z", "shell.execute_reply.started": "2024-10-30T01:25:48.526039Z" } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df[\"post_infill_duration\"].hist(bins=np.linspace(-5, 360, 100))" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.035167Z", "start_time": "2024-05-16T13:59:40.801098Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:25:48.748289Z", "iopub.status.busy": "2024-10-30T01:25:48.747869Z", "iopub.status.idle": "2024-10-30T01:25:49.487863Z", "shell.execute_reply": "2024-10-30T01:25:49.487117Z", "shell.execute_reply.started": "2024-10-30T01:25:48.748271Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "after duration 0.999270598663072\n", "after infill duration 0.9649918134702269\n", "neg_filter_reaction_play_count 1.0\n", "neg_filter_upvote_count 0.9916\n", "neg_filter_norm_play_frac 1.0\n", "neg_filter_continues 1.0\n", "----------------\n", "pos_filter_continues 1.0\n", "pos_filter_reaction_play_count 1.0\n", "pos_filter_relative_play_count 0.9787\n", "pos_filter_cer_diff_preference 0.9231\n", "pos_filter_bad_flags 0.9997\n", "after filter on play counts 0.9372\n", "after filter on higher quality 0.2805\n", "----------------\n", "negative 155014 positive 30488\n", "----------------\n", "total pair requests 162462 --> selected pair requests 29563 frac 0.182\n" ] } ], "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 = 1\n", "# this is a filter on the concated clip\n", "concat_total_play_count = 3\n", "\n", "all_fitlers = (df[\"duration\"] >= 10) & (df[\"duration\"] <= 240)\n", "print(\"after duration\", all_fitlers.sum() / df.shape[0])\n", "infill_duration_filter = (~df[\"task\"].isin(\n", " [\n", " \"infill\",\n", " \"infill_intro\",\n", " \"infill_outro\",\n", " ]\n", " )) | (df[\"post_infill_duration\"] <= 239)\n", "print(\"after infill duration\", infill_duration_filter.sum() / df.shape[0])\n", "# negative fitlers\n", "total_negative = df[~df[\"preference\"]].shape[0]\n", "neg_filter_reaction_play_count = (~df[\"preference\"]) & (df[\"reaction_play_count\"] >= 1)\n", "print(\n", " \"neg_filter_reaction_play_count\",\n", " round(neg_filter_reaction_play_count.sum() / total_negative, 4),\n", ")\n", "neg_filter_upvote_count = (~df[\"preference\"]) & (df[\"upvote_count\"] == 0)\n", "print(\n", " \"neg_filter_upvote_count\",\n", " round(neg_filter_upvote_count.sum() / total_negative, 4),\n", ")\n", "neg_filter_norm_play_frac = (~df[\"preference\"]) & (df[\"norm_play_frac\"] <= 3.1)\n", "print(\n", " \"neg_filter_norm_play_frac\",\n", " round(neg_filter_norm_play_frac.sum() / total_negative, 4),\n", ")\n", "neg_filter_continues = (~df[\"preference\"]) & (\n", " df[\"has_continue_and_start_continue_at\"].isna()\n", ")\n", "print(\n", " \"neg_filter_continues\",\n", " round(neg_filter_continues.sum() / total_negative, 4),\n", ")\n", "\n", "neg_filter_selection_mask = (\n", " all_fitlers\n", " & infill_duration_filter\n", " & neg_filter_reaction_play_count\n", " & neg_filter_upvote_count\n", " & neg_filter_norm_play_frac\n", " & neg_filter_continues\n", ")\n", "\n", "print(\"----------------\")\n", "total_positive = df[df[\"preference\"]].shape[0]\n", "assert total_positive == total_negative\n", "pos_filter_continues = (df[\"preference\"]) & (df[\"good_continue_at\"])\n", "print(\"pos_filter_continues\", round(pos_filter_continues.sum() / total_positive, 4))\n", "pos_filter_reaction_play_count = (df[\"preference\"]) & (df[\"reaction_play_count\"] >= 1)\n", "print(\n", " \"pos_filter_reaction_play_count\",\n", " round(pos_filter_reaction_play_count.sum() / total_positive, 4),\n", ")\n", "pos_filter_relative_play_count = (df[\"preference\"]) & (df[\"play_rel_diff\"] >= 0)\n", "print(\n", " \"pos_filter_relative_play_count\",\n", " round(pos_filter_relative_play_count.sum() / total_positive, 4),\n", ")\n", "pos_filter_cer_diff_preference = (\n", " (df[\"preference\"]) & (df[\"cer_diff_preference\"] < 0.5) & (df[\"cer\"] < 0.99)\n", ")\n", "print(\n", " \"pos_filter_cer_diff_preference\",\n", " round(pos_filter_cer_diff_preference.sum() / total_positive, 4),\n", ")\n", "pos_filter_bad_flags = (\n", " (df[\"preference\"]) & (df[\"flag_count\"] == 0) & (df[\"dislike_count\"] == 0)\n", ")\n", "print(\n", " \"pos_filter_bad_flags\",\n", " round(pos_filter_bad_flags.sum() / total_positive, 4),\n", ")\n", "pos_filter_play_counts = (df[\"preference\"]) & (\n", " (\n", " (df[\"part_of_concat\"])\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\"]) & (df[\"reaction_play_count\"] >= normal_pos_play_count)\n", " # & (df[\"norm_play_frac\"] >= 2.1) # this is a bit of a luxury cut...\n", " )\n", ")\n", "print(\n", " \"after filter on play counts\",\n", " round(pos_filter_play_counts.sum() / total_positive, 4),\n", ")\n", "high_quality_tasks_filter = (\n", " (\n", " df[\"task\"].isin(\n", " [\n", " \"cover\",\n", " \"\",\n", " \"extend\",\n", " ]\n", " )\n", " )\n", " & (\n", " (df[\"upvote_count\"] >= 1)\n", " | (df[\"reaction_play_count\"] >= 10)\n", " | (df[\"concat_play_counts\"] >= 10)\n", " )\n", " & (\n", " (df[\"part_of_concat\"])\n", " | (\n", " (~df[\"part_of_concat\"])\n", " & (df[\"norm_play_frac\"] >= 5.1) # this is a bit of a luxury cut...\n", " )\n", " )\n", ")\n", "medium_quality_tasks_filter = (\n", " df[\"task\"].isin(\n", " [\n", " \"infill\",\n", " \"infill_intro\",\n", " \"infill_outro\",\n", " \"artist_consistency\",\n", " ]\n", " )\n", ") & (\n", " (df[\"upvote_count\"] >= 1)\n", " | (df[\"reaction_play_count\"] >= 3)\n", " | (df[\"concat_play_counts\"] >= 3)\n", ")\n", "pos_filter_higher_quality = (df[\"preference\"]) & (\n", " high_quality_tasks_filter | medium_quality_tasks_filter\n", ")\n", "print(\n", " \"after filter on higher quality\",\n", " round(pos_filter_higher_quality.sum() / total_positive, 4),\n", ")\n", "\n", "print(\"----------------\")\n", "pos_filter_selectin_mask = (\n", " (df[\"preference\"]) # get basics aligned\n", " & all_fitlers\n", " & infill_duration_filter\n", " & pos_filter_continues\n", " & pos_filter_reaction_play_count\n", " & pos_filter_relative_play_count\n", " & pos_filter_cer_diff_preference\n", " & pos_filter_bad_flags\n", " & pos_filter_play_counts\n", " & pos_filter_higher_quality\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", "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": 21, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.250737Z", "start_time": "2024-05-16T13:59:41.036434Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:25:49.491468Z", "iopub.status.busy": "2024-10-30T01:25:49.490969Z", "iopub.status.idle": "2024-10-30T01:25:49.691514Z", "shell.execute_reply": "2024-10-30T01:25:49.690794Z", "shell.execute_reply.started": "2024-10-30T01:25:49.491447Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "30b_t5_v15 requests 29563 clips 59126 total khrs 2.225; N gpus for 1000 iters 3.695; 4 gpus for x iters 923.844; n unique users 14684 n pro users 11642\n" ] } ], "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 / 2 / 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", "# v10 has 78866\n", "# v14 has 110402\n", "# 30b_t4_v12 requests 47755 clips 95510 total khrs 4.555; N gpus for 1000 iters 5.969; 4 gpus for x iters 1492.344; n unique users 13790 n pro users 13526\n", "# 30b_t4_v20 requests 18306 clips 36612 total khrs 1.754; N gpus for 1000 iters 2.288; 4 gpus for x iters 572.062; n unique users 6943 n pro users 6714\n", "# 30b_t5_v5 requests 21318 clips 42636 total khrs 1.938; N gpus for 1000 iters 2.665; 4 gpus for x iters 666.188; n unique users 11661 n pro users 9347\n", "# 30b_t5_v6 requests 22833 clips 45666 total khrs 2.072; N gpus for 1000 iters 2.854; 4 gpus for x iters 713.531; n unique users 12576 n pro users 9910\n", "# 30b_t5_v7 requests 33197 clips 66394 total khrs 2.846; N gpus for 1000 iters 4.150; 4 gpus for x iters 1037.406; n unique users 16665 n pro users 13050\n", "# 30b_t5_v8 requests 20907 clips 41814 total khrs 1.629; N gpus for 1000 iters 2.613; 4 gpus for x iters 653.344; n unique users 11102 n pro users 9052\n", "# 30b_t5_v9 requests 24645 clips 49290 total khrs 1.918; N gpus for 1000 iters 3.081; 4 gpus for x iters 770.156; n unique users 12661 n pro users 10229\n", "# 30b_t5_v11 requests 21975 clips 43950 total khrs 1.508; N gpus for 1000 iters 2.747; 4 gpus for x iters 686.719; n unique users 11173 n pro users 9270\n", "# 30b_t5_v12 requests 21436 clips 42872 total khrs 1.582; N gpus for 1000 iters 2.679; 4 gpus for x iters 669.875; n unique users 11553 n pro users 9374\n", "# 30b_t5_v13 requests 25912 clips 51824 total khrs 1.922; N gpus for 1000 iters 3.239; 4 gpus for x iters 809.750; n unique users 13429 n pro users 10737\n", "# 30b_t5_v14 requests 27687 clips 55374 total khrs 2.036; N gpus for 1000 iters 3.461; 4 gpus for x iters 865.219; n unique users 14196 n pro users 11227\n", "# 30b_t5_v15 requests 29563 clips 59126 total khrs 2.225; N gpus for 1000 iters 3.695; 4 gpus for x iters 923.844; n unique users 14684 n pro users 11642" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.277006Z", "start_time": "2024-05-16T13:59:41.252105Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:25:49.692417Z", "iopub.status.busy": "2024-10-30T01:25:49.692240Z", "iopub.status.idle": "2024-10-30T01:25:49.728644Z", "shell.execute_reply": "2024-10-30T01:25:49.728013Z", "shell.execute_reply.started": "2024-10-30T01:25:49.692399Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "positive in playlist (8840, 128)\n", "task\n", "cover 28406\n", "infill 18526\n", " 11932\n", "artist_consistency 262\n", "Name: count, dtype: int64\n" ] } ], "source": [ "test_mask = (df_slice[\"preference\"]) & (\n", " (df_slice[\"is_in_playlist\"]) | (df_slice[\"concat_in_playlist\"])\n", ")\n", "print(\"positive in playlist\", df_slice[test_mask].shape)\n", "print(df_slice[\"task\"].value_counts())" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:49.729423Z", "iopub.status.busy": "2024-10-30T01:25:49.729258Z", "iopub.status.idle": "2024-10-30T01:25:49.963478Z", "shell.execute_reply": "2024-10-30T01:25:49.962934Z", "shell.execute_reply.started": "2024-10-30T01:25:49.729407Z" } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df_slice[\"post_infill_duration\"].hist(bins=np.linspace(-5, 360, 100))" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.323409Z", "start_time": "2024-05-16T13:59:41.278278Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:25:49.964282Z", "iopub.status.busy": "2024-10-30T01:25:49.964132Z", "iopub.status.idle": "2024-10-30T01:25:49.978445Z", "shell.execute_reply": "2024-10-30T01:25:49.977938Z", "shell.execute_reply.started": "2024-10-30T01:25:49.964267Z" } }, "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": 25, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.392244Z", "start_time": "2024-05-16T13:59:41.324472Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:25:49.979203Z", "iopub.status.busy": "2024-10-30T01:25:49.979053Z", "iopub.status.idle": "2024-10-30T01:25:50.017292Z", "shell.execute_reply": "2024-10-30T01:25:50.016778Z", "shell.execute_reply.started": "2024-10-30T01:25:49.979189Z" } }, "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": 26, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:50.018155Z", "iopub.status.busy": "2024-10-30T01:25:50.017852Z", "iopub.status.idle": "2024-10-30T01:25:50.057883Z", "shell.execute_reply": "2024-10-30T01:25:50.057378Z", "shell.execute_reply.started": "2024-10-30T01:25:50.018139Z" } }, "outputs": [], "source": [ "# df_slice_2 = pd.read_csv(\"/home/tony/Data/Preference/30b_v1/interesting_clips_v4_t_1_20240808_slice.csv\")\n", "# df_total = pd.concat([df_slice, df_slice_2])\n", "# print(df_total.shape)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:50.058894Z", "iopub.status.busy": "2024-10-30T01:25:50.058474Z", "iopub.status.idle": "2024-10-30T01:25:50.097531Z", "shell.execute_reply": "2024-10-30T01:25:50.097026Z", "shell.execute_reply.started": "2024-10-30T01:25:50.058877Z" } }, "outputs": [], "source": [ "# df_slice_prev = pd.read_pickle(\n", "# \"/home/tony/Data/Preference/30b_v2/interesting_clips_v4_t_3_v13_20240902_slice.pkl\"\n", "# )\n", "# df_slice_prev = df_slice_prev[\n", "# (\n", "# (df_slice_prev[\"task\"] != \"infill\")\n", "# & (df_slice_prev[\"task\"] != \"cover\")\n", "# & (df_slice_prev[\"task\"] != \"artist_consistency\")\n", "# )\n", "# ].copy()\n", "# df_slice = pd.concat([df_slice, df_slice_prev])\n", "# print(df_slice.shape)\n", "# print(df_slice[\"task\"].value_counts())" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:25:50.098190Z", "iopub.status.busy": "2024-10-30T01:25:50.098053Z", "iopub.status.idle": "2024-10-30T01:25:50.134557Z", "shell.execute_reply": "2024-10-30T01:25:50.134055Z", "shell.execute_reply.started": "2024-10-30T01:25:50.098177Z" } }, "outputs": [], "source": [ "# df_slice[(df_slice[\"preference\"]) & ((df_slice[\"task\"].str.strip() == \"\") | (df_slice[\"task\"].str.strip() == \"cover\"))].to_pickle(\n", "# \"/home/tony/Data/Preference/30b_v5/interesting_clips_v4_t_5_20241018_full_with_cer_pos_gen.pkl\"\n", "# )\n", "# df_slice[(df_slice[\"preference\"]) & ((df_slice[\"task\"].str.strip() == \"\") | (df_slice[\"task\"].str.strip() == \"cover\"))].shape" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T14:00:20.866354Z", "start_time": "2024-05-16T14:00:12.443344Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:25:50.135256Z", "iopub.status.busy": "2024-10-30T01:25:50.135115Z", "iopub.status.idle": "2024-10-30T01:25:50.447576Z", "shell.execute_reply": "2024-10-30T01:25:50.446877Z", "shell.execute_reply.started": "2024-10-30T01:25:50.135243Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(59126, 128)\n", "task\n", "cover 28406\n", "infill 18526\n", " 11932\n", "artist_consistency 262\n", "Name: count, dtype: int64\n" ] }, { "ename": "NameError", "evalue": "name 'BREAK' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[29], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(df_slice\u001b[38;5;241m.\u001b[39mshape)\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(df_slice[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtask\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mvalue_counts())\n\u001b[0;32m----> 4\u001b[0m \u001b[43mBREAK\u001b[49m\n", "\u001b[0;31mNameError\u001b[0m: name 'BREAK' is not defined" ] } ], "source": [ "# df_slice.to_pickle(\"/home/tony/Data/Preference/30b_v3/interesting_clips_v4_t_4_v3_20240916_full_with_cer.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": 30, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.932296Z", "start_time": "2024-05-16T13:59:41.932287Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:36:12.752799Z", "iopub.status.busy": "2024-10-30T01:36:12.752346Z", "iopub.status.idle": "2024-10-30T01:36:13.668446Z", "shell.execute_reply": "2024-10-30T01:36:13.667689Z", "shell.execute_reply.started": "2024-10-30T01:36:12.752778Z" } }, "outputs": [], "source": [ "# don't have continue at\n", "df_slice[\"request_id\"] = df_slice[\"request_id\"].astype(str)\n", "# df_slice[df_slice[\"continue_at\"].isna()][\"request_id\"].nunique(), df_slice[\"request_id\"].nunique()" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:36:13.669782Z", "iopub.status.busy": "2024-10-30T01:36:13.669601Z", "iopub.status.idle": "2024-10-30T01:36:13.846088Z", "shell.execute_reply": "2024-10-30T01:36:13.845347Z", "shell.execute_reply.started": "2024-10-30T01:36:13.669764Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(59126, 128)\n", "(59126, 128)\n", "(59126, 128)\n" ] } ], "source": [ "print(df_slice.shape)\n", "df_slice = df_slice[df_slice[\"request_id\"].apply(lambda x: len(x) > 3)]\n", "print(df_slice.shape)\n", "# df_slice = df_slice[df_slice[\"is_pro_user\"]].copy()\n", "print(df_slice.shape)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.932966Z", "start_time": "2024-05-16T13:59:41.932957Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:36:13.847181Z", "iopub.status.busy": "2024-10-30T01:36:13.847009Z", "iopub.status.idle": "2024-10-30T01:36:13.871700Z", "shell.execute_reply": "2024-10-30T01:36:13.871051Z", "shell.execute_reply.started": "2024-10-30T01:36:13.847164Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "29563\n" ] } ], "source": [ "final_filtered_requests = df_slice[\"request_id\"].astype(str).unique()\n", "# final_filtered_requests = df_slice[df_slice[\"is_pro_user\"]][\"request_id\"].astype(str).unique()\n", "print(len(final_filtered_requests))" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.933558Z", "start_time": "2024-05-16T13:59:41.933550Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:36:13.872517Z", "iopub.status.busy": "2024-10-30T01:36:13.872363Z", "iopub.status.idle": "2024-10-30T01:36:13.905823Z", "shell.execute_reply": "2024-10-30T01:36:13.905300Z", "shell.execute_reply.started": "2024-10-30T01:36:13.872502Z" } }, "outputs": [], "source": [ "# df_slice.to_csv(\"/home/tony/Data/Preference/30b_v2/interesting_clips_v4_t_3_20240902_slice.csv\", index=False)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:36:13.907261Z", "iopub.status.busy": "2024-10-30T01:36:13.907108Z", "iopub.status.idle": "2024-10-30T01:36:13.946806Z", "shell.execute_reply": "2024-10-30T01:36:13.946283Z", "shell.execute_reply.started": "2024-10-30T01:36:13.907247Z" } }, "outputs": [], "source": [ "# df_slice[\"continue_at\"] = -1" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.934277Z", "start_time": "2024-05-16T13:59:41.934268Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:36:13.947522Z", "iopub.status.busy": "2024-10-30T01:36:13.947379Z", "iopub.status.idle": "2024-10-30T01:36:14.137510Z", "shell.execute_reply": "2024-10-30T01:36:14.136790Z", "shell.execute_reply.started": "2024-10-30T01:36:13.947508Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "29267 296\n", "(58534, 128) (592, 128)\n" ] } ], "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\"].astype(str).isin(set(train_requests))].copy()\n", "val_df = df_slice[df_slice[\"request_id\"].astype(str).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": "markdown", "metadata": {}, "source": [ "# Actually make" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.934954Z", "start_time": "2024-05-16T13:59:41.934946Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:36:14.138416Z", "iopub.status.busy": "2024-10-30T01:36:14.138248Z", "iopub.status.idle": "2024-10-30T01:36:14.155071Z", "shell.execute_reply": "2024-10-30T01:36:14.154514Z", "shell.execute_reply.started": "2024-10-30T01:36:14.138399Z" } }, "outputs": [], "source": [ "# val_df[[\"request_id\", \"metadata\", \"updated_at\", \"user_id\", \"preference\"]].head()" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.935620Z", "start_time": "2024-05-16T13:59:41.935613Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:36:14.155871Z", "iopub.status.busy": "2024-10-30T01:36:14.155712Z", "iopub.status.idle": "2024-10-30T01:36:16.220805Z", "shell.execute_reply": "2024-10-30T01:36:16.220079Z", "shell.execute_reply.started": "2024-10-30T01:36:14.155856Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████| 58534/58534 [00:02<00:00, 29046.59it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2,202 hours of 58534 clips, 3.658375 nodes, 914.59375 iters\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "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", " total_duration += row[\"duration\"]\n", " except Exception as E:\n", " print(i, row)\n", " print(E)\n", " raise ValueError()\n", "\n", "print(\n", " f\"{round(total_duration / 60 / 60):,} hours of {train_df.shape[0]} clips, {train_df.shape[0] / 8 / 2 / 1000} nodes, {train_df.shape[0] / 8 / 2 / 4} iters\"\n", ")" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.936268Z", "start_time": "2024-05-16T13:59:41.936260Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:36:16.221710Z", "iopub.status.busy": "2024-10-30T01:36:16.221536Z", "iopub.status.idle": "2024-10-30T01:36:25.139716Z", "shell.execute_reply": "2024-10-30T01:36:25.139006Z", "shell.execute_reply.started": "2024-10-30T01:36:16.221692Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 592/592 [00:08<00:00, 66.62it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Total 592 clips, 0 different prompts\n", "18 hours of False\n", "17 hours of True\n", "cover: 250.3 hours\n", "infill: 151.2 hours\n", "gen: 111.2 hours\n", "artist_consistency: 1.7 hours\n", "Done\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "make_dataset(val_df, OUT_DATA_DIR, is_val=True, npz_dir=NPZ_DIR)" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:36:25.140594Z", "iopub.status.busy": "2024-10-30T01:36:25.140425Z", "iopub.status.idle": "2024-10-30T01:36:25.157011Z", "shell.execute_reply": "2024-10-30T01:36:25.156463Z", "shell.execute_reply.started": "2024-10-30T01:36:25.140577Z" } }, "outputs": [], "source": [ "# test_npz = np.load(\"/app/suno/data/dpo/30b_npz/26d19085-18da-4701-af43-122684543891.npz\")\n", "# for k in test_npz.keys():\n", "# print(k)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.936964Z", "start_time": "2024-05-16T13:59:41.936957Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:36:25.157813Z", "iopub.status.busy": "2024-10-30T01:36:25.157659Z", "iopub.status.idle": "2024-10-30T01:50:46.801446Z", "shell.execute_reply": "2024-10-30T01:50:46.800898Z", "shell.execute_reply.started": "2024-10-30T01:36:25.157798Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ " 2%|██▋ | 1463/58534 [00:20<13:24, 70.90it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 14652: 6024 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 9%|██████████ | 5509/58534 [01:18<12:07, 72.91it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 58837: 6036 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 10%|███████████ | 6055/58534 [01:25<12:03, 72.53it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 65054: 6017 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 13%|██████████████▏ | 7777/58534 [01:49<11:37, 72.82it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 83093: 6017 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 22%|███████████████████████ | 12748/58534 [03:00<10:50, 70.41it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 136943: 6017 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 24%|█████████████████████████ | 13843/58534 [03:16<10:49, 68.79it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 148439: 6022 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 29%|███████████████████████████████▏ | 17224/58534 [04:03<09:47, 70.34it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 184716: 6059 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 36%|█████████████████████████████████████▉ | 20977/58534 [04:58<09:03, 69.16it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 225474: 6069 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 45%|███████████████████████████████████████████████▌ | 26281/58534 [06:11<08:07, 66.13it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 282745: 6027 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 48%|██████████████████████████████████████████████████▍ | 27862/58534 [06:35<07:42, 66.39it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 300242: 6055 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 68%|███████████████████████████████████████████████████████████████████████▋ | 39595/58534 [09:27<04:41, 67.28it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 426476: 6035 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 77%|█████████████████████████████████████████████████████████████████████████████████▊ | 45158/58534 [10:52<03:06, 71.66it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 486014: 6080 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 84%|████████████████████████████████████████████████████████████████████████████████████████▉ | 49089/58534 [11:50<02:51, 55.10it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 529756: 6017 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 88%|█████████████████████████████████████████████████████████████████████████████████████████████ | 51395/58534 [12:25<01:47, 66.14it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 553028: 6035 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 92%|█████████████████████████████████████████████████████████████████████████████████████████████████▊ | 54031/58534 [13:06<01:17, 57.73it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 580866: 6063 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 98%|███████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 57333/58534 [14:00<00:18, 66.46it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Overflow at 614970: 6017 > 6016\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████| 58534/58534 [14:21<00:00, 67.94it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Total 58480 clips, 19 different prompts\n", "1,717 hours of False\n", "1,702 hours of True\n", "infill: 15902.3 hours\n", "cover: 24433.9 hours\n", "gen: 10257.4 hours\n", "artist_consistency: 224.2 hours\n", "Error infill: 52\n", "Error artist_consistency: 2\n", "Done\n" ] } ], "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": 41, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.937879Z", "start_time": "2024-05-16T13:59:41.937870Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:46.802179Z", "iopub.status.busy": "2024-10-30T01:50:46.802020Z", "iopub.status.idle": "2024-10-30T01:50:47.703689Z", "shell.execute_reply": "2024-10-30T01:50:47.703179Z", "shell.execute_reply.started": "2024-10-30T01:50:46.802163Z" } }, "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": 42, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.938629Z", "start_time": "2024-05-16T13:59:41.938621Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:47.704387Z", "iopub.status.busy": "2024-10-30T01:50:47.704239Z", "iopub.status.idle": "2024-10-30T01:50:47.723089Z", "shell.execute_reply": "2024-10-30T01:50:47.722633Z", "shell.execute_reply.started": "2024-10-30T01:50:47.704372Z" } }, "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": 43, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.939205Z", "start_time": "2024-05-16T13:59:41.939198Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:47.725194Z", "iopub.status.busy": "2024-10-30T01:50:47.724832Z", "iopub.status.idle": "2024-10-30T01:50:47.762472Z", "shell.execute_reply": "2024-10-30T01:50:47.762051Z", "shell.execute_reply.started": "2024-10-30T01:50:47.725179Z" } }, "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": 44, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.939977Z", "start_time": "2024-05-16T13:59:41.939969Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:47.763229Z", "iopub.status.busy": "2024-10-30T01:50:47.763094Z", "iopub.status.idle": "2024-10-30T01:50:47.802136Z", "shell.execute_reply": "2024-10-30T01:50:47.801712Z", "shell.execute_reply.started": "2024-10-30T01:50:47.763215Z" } }, "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": 45, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.940610Z", "start_time": "2024-05-16T13:59:41.940603Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:47.802750Z", "iopub.status.busy": "2024-10-30T01:50:47.802613Z", "iopub.status.idle": "2024-10-30T01:50:47.841827Z", "shell.execute_reply": "2024-10-30T01:50:47.841406Z", "shell.execute_reply.started": "2024-10-30T01:50:47.802737Z" } }, "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": 46, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.941167Z", "start_time": "2024-05-16T13:59:41.941159Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:47.842396Z", "iopub.status.busy": "2024-10-30T01:50:47.842264Z", "iopub.status.idle": "2024-10-30T01:50:47.881463Z", "shell.execute_reply": "2024-10-30T01:50:47.881043Z", "shell.execute_reply.started": "2024-10-30T01:50:47.842383Z" } }, "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": 47, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.941801Z", "start_time": "2024-05-16T13:59:41.941793Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:47.882085Z", "iopub.status.busy": "2024-10-30T01:50:47.881948Z", "iopub.status.idle": "2024-10-30T01:50:47.921111Z", "shell.execute_reply": "2024-10-30T01:50:47.920658Z", "shell.execute_reply.started": "2024-10-30T01:50:47.882072Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "296 0\n" ] } ], "source": [ "def validation_on_metas(input_metas):\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": 48, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.942520Z", "start_time": "2024-05-16T13:59:41.942511Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:47.921739Z", "iopub.status.busy": "2024-10-30T01:50:47.921602Z", "iopub.status.idle": "2024-10-30T01:50:47.976585Z", "shell.execute_reply": "2024-10-30T01:50:47.976156Z", "shell.execute_reply.started": "2024-10-30T01:50:47.921725Z" } }, "outputs": [], "source": [ "train_info = read_json(os.path.join(OUT_DATA_DIR, f\"info_tr.json\"))" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.943072Z", "start_time": "2024-05-16T13:59:41.943065Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:47.977204Z", "iopub.status.busy": "2024-10-30T01:50:47.977068Z", "iopub.status.idle": "2024-10-30T01:50:48.011424Z", "shell.execute_reply": "2024-10-30T01:50:48.010993Z", "shell.execute_reply.started": "2024-10-30T01:50:47.977191Z" } }, "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": 50, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.944246Z", "start_time": "2024-05-16T13:59:41.944237Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:48.012058Z", "iopub.status.busy": "2024-10-30T01:50:48.011915Z", "iopub.status.idle": "2024-10-30T01:50:48.053928Z", "shell.execute_reply": "2024-10-30T01:50:48.053489Z", "shell.execute_reply.started": "2024-10-30T01:50:48.012044Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "total samples 58480 (58534, 128)\n" ] } ], "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": 51, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.945249Z", "start_time": "2024-05-16T13:59:41.945241Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:48.054529Z", "iopub.status.busy": "2024-10-30T01:50:48.054393Z", "iopub.status.idle": "2024-10-30T01:50:48.095160Z", "shell.execute_reply": "2024-10-30T01:50:48.094715Z", "shell.execute_reply.started": "2024-10-30T01:50:48.054515Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 epoch per batch 4, total 913.75\n" ] } ], "source": [ "print(\"1 epoch per batch 4, total\", total_iters / 8 / 2 / 4)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.945972Z", "start_time": "2024-05-16T13:59:41.945964Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:48.095747Z", "iopub.status.busy": "2024-10-30T01:50:48.095612Z", "iopub.status.idle": "2024-10-30T01:50:48.560058Z", "shell.execute_reply": "2024-10-30T01:50:48.559495Z", "shell.execute_reply.started": "2024-10-30T01:50:48.095734Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Submitted batch job 1087\n" ] } ], "source": [ "!cd /home/tony/Work/tony/slurm/30b_dpo && sbatch sbatch_ipo_30b" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:50:48.560924Z", "iopub.status.busy": "2024-10-30T01:50:48.560765Z", "iopub.status.idle": "2024-10-30T01:50:48.588884Z", "shell.execute_reply": "2024-10-30T01:50:48.588418Z", "shell.execute_reply.started": "2024-10-30T01:50:48.560909Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Cache kept!\n" ] } ], "source": [ "import shutil\n", "\n", "# Basic file copy\n", "shutil.copy(\n", " \"/home/tony/Work/tony/Preference/make_dataset_13b_v4_t5.ipynb\",\n", " os.path.join(OUT_DATA_DIR, \"make_dataset.ipynb\"),\n", ")\n", "print(\"Cache kept!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# some gymathtics loading prev data" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "ExecuteTime": { "end_time": "2024-05-16T13:59:41.946562Z", "start_time": "2024-05-16T13:59:41.946555Z" }, "execution": { "iopub.execute_input": "2024-10-30T01:50:48.589539Z", "iopub.status.busy": "2024-10-30T01:50:48.589403Z", "iopub.status.idle": "2024-10-30T01:50:48.617469Z", "shell.execute_reply": "2024-10-30T01:50:48.617045Z", "shell.execute_reply.started": "2024-10-30T01:50:48.589525Z" } }, "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": 55, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:50:48.618283Z", "iopub.status.busy": "2024-10-30T01:50:48.618147Z", "iopub.status.idle": "2024-10-30T01:50:48.657794Z", "shell.execute_reply": "2024-10-30T01:50:48.657368Z", "shell.execute_reply.started": "2024-10-30T01:50:48.618269Z" } }, "outputs": [], "source": [ "# x_data = train_df[train_df[\"preference\"]][\"similarity\"]\n", "# y_data = train_df[~train_df[\"preference\"]][\"similarity\"]\n", "# from matplotlib.colors import LogNorm\n", "\n", "# fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 10))\n", "\n", "# # 2D Histogram\n", "# h = ax1.hist2d(\n", "# x_data,\n", "# y_data,\n", "# bins=(50, 50),\n", "# cmap=\"coolwarm\",\n", "# range=[[0, 1], [0, 1]],\n", "# norm=LogNorm(),\n", "# )\n", "\n", "# ax1.set_xlabel(\"Semantic Distance (Preferred)\")\n", "# ax1.set_ylabel(\"Semantic Distance (Non-Preferred)\")\n", "# ax1.set_title(\n", "# \"2D Histogram of Semantic Distances: Preferred vs Non-Preferred (Log Scale)\"\n", "# )\n", "\n", "# cbar1 = plt.colorbar(h[3], ax=ax1)\n", "# cbar1.set_label(\"Number of Request IDs (Log Scale)\")\n", "\n", "# # Scatter plot\n", "# ax2.scatter(x_data, y_data, alpha=0.1, s=1)\n", "# ax2.set_xlabel(\"Semantic Distance (Preferred)\")\n", "# ax2.set_ylabel(\"Semantic Distance (Non-Preferred)\")\n", "# ax2.set_title(\"Scatter Plot of Semantic Distances: Preferred vs Non-Preferred\")\n", "# ax2.set_xlim(0, 1)\n", "# ax2.set_ylim(0, 1)\n", "\n", "# plt.tight_layout()\n", "# plt.show()" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:50:48.658441Z", "iopub.status.busy": "2024-10-30T01:50:48.658298Z", "iopub.status.idle": "2024-10-30T01:50:48.696807Z", "shell.execute_reply": "2024-10-30T01:50:48.696390Z", "shell.execute_reply.started": "2024-10-30T01:50:48.658427Z" } }, "outputs": [], "source": [ "# train_metas = read_jsonl(os.path.join(OUT_DATA_DIR, f\"meta_tr.jsonl\"))" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "execution": { "iopub.execute_input": "2024-10-30T01:50:48.697460Z", "iopub.status.busy": "2024-10-30T01:50:48.697327Z", "iopub.status.idle": "2024-10-30T01:50:48.736076Z", "shell.execute_reply": "2024-10-30T01:50:48.735663Z", "shell.execute_reply.started": "2024-10-30T01:50:48.697447Z" } }, "outputs": [ { "data": { "text/plain": [ "dict_keys(['perference_0', 'perference_1'])" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "train_info.keys()" ] }, { "cell_type": "code", "execution_count": null, "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.15" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }