{ "cells": [ { "cell_type": "markdown", "id": "e8292308", "metadata": {}, "source": [ "# Project B: TTS Evaluation Notebook\n", "Evaluates pyttsx3, Kokoro (flat + tuned), and edge_tts across 6 standardized coaching scripts.\n", "Rubric: intelligibility, naturalness, pacing, friendliness, consistency (1-3 anchored scale)." ] }, { "cell_type": "code", "execution_count": 1, "id": "a2763250", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'output_path': '../audio_outputs/test_pyttsx3.wav', 'latency_seconds': 0.127, 'engine': 'pyttsx3'}\n" ] } ], "source": [ "import sys\n", "sys.path.append(\"../src\")\n", "\n", "from pyttsx3_client import synthesize\n", "\n", "result = synthesize(\n", " text=\"You did such a great job speaking today!\",\n", " output_path=\"../audio_outputs/test_pyttsx3.wav\"\n", ")\n", "\n", "print(result)" ] }, { "cell_type": "code", "execution_count": 2, "id": "42a334c5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Done: script 1 — 0.081s\n", "Done: script 2 — 0.083s\n", "Done: script 3 — 0.109s\n", "Done: script 4 — 0.102s\n", "Done: script 5 — 0.092s\n", "Done: script 6 — 0.093s\n", "\n", "All done!\n" ] } ], "source": [ "import sys\n", "sys.path.append(\"..\")\n", "\n", "from pyttsx3_client import synthesize\n", "from config.tts_scripts import SCRIPTS\n", "\n", "# make sure audio_outputs exists\n", "import os\n", "os.makedirs(\"../audio_outputs\", exist_ok=True)\n", "\n", "results = []\n", "\n", "for script in SCRIPTS:\n", " output_path = f\"../audio_outputs/pyttsx3_script{script['id']}_{script['band'].replace('-','')}_{ script['scenario']}.wav\"\n", " result = synthesize(\n", " text=script[\"text\"],\n", " output_path=output_path\n", " )\n", " result[\"script_id\"] = script[\"id\"]\n", " result[\"band\"] = script[\"band\"]\n", " result[\"scenario\"] = script[\"scenario\"]\n", " results.append(result)\n", " print(f\"Done: script {script['id']} — {result['latency_seconds']}s\")\n", "\n", "print(\"\\nAll done!\")" ] }, { "cell_type": "code", "execution_count": 3, "id": "1415604b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " script_id band scenario latency_seconds engine\n", "0 1 K-2 praise 0.081 pyttsx3\n", "1 2 K-2 correction 0.083 pyttsx3\n", "2 3 3-5 instruction 0.109 pyttsx3\n", "3 4 6-8 correction 0.102 pyttsx3\n", "4 5 9-12 correction 0.092 pyttsx3\n", "5 6 6-8 SEL 0.093 pyttsx3\n" ] } ], "source": [ "import pandas as pd\n", "\n", "df = pd.DataFrame(results)\n", "print(df[[\"script_id\", \"band\", \"scenario\", \"latency_seconds\", \"engine\"]])\n", "pd.DataFrame(results).to_csv(\"../results/pyttsx3_latency.csv\", index=False)\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "6ec5f077", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING: Defaulting repo_id to hexgrad/Kokoro-82M. Pass repo_id='hexgrad/Kokoro-82M' to suppress this warning.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "d:\\Bantrly\\code\\Project B\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\rnn.py:1013: UserWarning: dropout option adds dropout after all but last recurrent layer, so non-zero dropout expects num_layers greater than 1, but got dropout=0.2 and num_layers=1\n", " super().__init__(\"LSTM\", *args, **kwargs)\n", "d:\\Bantrly\\code\\Project B\\.venv\\Lib\\site-packages\\torch\\nn\\utils\\weight_norm.py:144: FutureWarning: `torch.nn.utils.weight_norm` is deprecated in favor of `torch.nn.utils.parametrizations.weight_norm`.\n", " WeightNorm.apply(module, name, dim)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "{'output_path': '../audio_outputs/test_kokoro.wav', 'latency_seconds': 0.969, 'engine': 'kokoro', 'voice': 'af_heart'}\n" ] } ], "source": [ "import sys\n", "sys.path.append(\"..\")\n", "from src.kokoro_client import synthesize as kokoro_synthesize\n", "\n", "result = kokoro_synthesize(\n", " text=\"You did such a great job speaking today!\",\n", " output_path=\"../audio_outputs/test_kokoro.wav\"\n", ")\n", "\n", "print(result)" ] }, { "cell_type": "code", "execution_count": 5, "id": "d0c0800c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Done: script 1 — 1.229s\n", "Done: script 2 — 1.483s\n", "Done: script 3 — 2.283s\n", "Done: script 4 — 2.85s\n", "Done: script 5 — 2.876s\n", "Done: script 6 — 2.318s\n", "\n", "All done!\n" ] } ], "source": [ "from config.tts_scripts import SCRIPTS\n", "\n", "kokoro_results = []\n", "\n", "for script in SCRIPTS:\n", " output_path = f\"../audio_outputs/kokoro_script{script['id']}_{script['band'].replace('-','')}_{ script['scenario']}.wav\"\n", " result = kokoro_synthesize(\n", " text=script[\"text\"],\n", " output_path=output_path\n", " )\n", " result[\"script_id\"] = script[\"id\"]\n", " result[\"band\"] = script[\"band\"]\n", " result[\"scenario\"] = script[\"scenario\"]\n", " kokoro_results.append(result)\n", " print(f\"Done: script {script['id']} — {result['latency_seconds']}s\")\n", "\n", "print(\"\\nAll done!\")" ] }, { "cell_type": "code", "execution_count": 6, "id": "496c0407", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " script_id band scenario latency_seconds voice engine\n", "0 1 K-2 praise 1.229 af_heart kokoro\n", "1 2 K-2 correction 1.483 af_heart kokoro\n", "2 3 3-5 instruction 2.283 af_heart kokoro\n", "3 4 6-8 correction 2.850 af_heart kokoro\n", "4 5 9-12 correction 2.876 af_heart kokoro\n", "5 6 6-8 SEL 2.318 af_heart kokoro\n" ] } ], "source": [ "df_kokoro = pd.DataFrame(kokoro_results)\n", "print(df_kokoro[[\"script_id\", \"band\", \"scenario\", \"latency_seconds\", \"voice\", \"engine\"]])\n", "pd.DataFrame(kokoro_results).to_csv(\"../results/kokoro_flat_latency.csv\", index=False)" ] }, { "cell_type": "code", "execution_count": 7, "id": "ee71f281", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "am_casual.pt\n", "af_heart.pt\n", "af_nova.pt\n", "am_echo.pt\n", "bf_emma.pt\n" ] } ], "source": [ "import os\n", "from pathlib import Path\n", "\n", "# kokoro downloads voices to huggingface cache\n", "cache_dir = Path.home() / \".cache\" / \"huggingface\" / \"hub\"\n", "voice_files = list(cache_dir.rglob(\"*.pt\"))\n", "for v in voice_files:\n", " print(v.name)" ] }, { "cell_type": "code", "execution_count": 8, "id": "ce2baa1b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✓ af_heart — 0.576s\n", "✓ af_nova — 0.874s\n", "✗ am_casual — 404 Client Error. (Request ID: Root=1-69d7fdf1-68c8dc7928aa0f2b7f528414;25dd7091-9c35-4d12-bc89-88c60529cd26)\n", "\n", "Entry Not Found for url: https://huggingface.co/hexgrad/Kokoro-82M/resolve/main/voices/am_casual.pt.\n", "✓ am_echo — 0.701s\n", "✓ bf_emma — 0.736s\n" ] } ], "source": [ "# trigger downloads for voices we want to evaluate across grade bands\n", "test_voices = [\n", " \"af_heart\", # American female warm — good for K-2\n", " \"af_nova\", # American female professional\n", " \"am_casual\", # American male casual — good for 6-8?\n", " \"am_echo\", # American male\n", " \"bf_emma\", # British female\n", "]\n", "\n", "for voice in test_voices:\n", " try:\n", " result = kokoro_synthesize(\n", " text=\"Let's work on your speaking today.\",\n", " output_path=f\"../audio_outputs/voice_test_{voice}.wav\",\n", " voice=voice\n", " )\n", " print(f\"✓ {voice} — {result['latency_seconds']}s\")\n", " except Exception as e:\n", " print(f\"✗ {voice} — {e}\")" ] }, { "cell_type": "code", "execution_count": 9, "id": "969e1e74", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'output_path': '../audio_outputs/test_edge.mp3', 'latency_seconds': 0.705, 'engine': 'edge_tts', 'voice': 'en-US-JennyNeural'}\n" ] } ], "source": [ "import sys\n", "sys.path.append(\"..\")\n", "from src.edge_tts_client import synthesize as edge_synthesize\n", "\n", "result = await edge_synthesize(\n", " text=\"You did such a great job speaking today!\",\n", " output_path=\"../audio_outputs/test_edge.mp3\"\n", ")\n", "print(result)" ] }, { "cell_type": "code", "execution_count": 10, "id": "17b3be38", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Done: script 1 — 0.452s\n", "Done: script 2 — 0.482s\n", "Done: script 3 — 0.509s\n", "Done: script 4 — 0.622s\n", "Done: script 5 — 0.606s\n", "Done: script 6 — 0.465s\n", "\n", "All done!\n" ] } ], "source": [ "import sys\n", "sys.path.append(\"..\")\n", "from config.tts_scripts import SCRIPTS\n", "\n", "edge_results = []\n", "\n", "for script in SCRIPTS:\n", " output_path = f\"../audio_outputs/edge_script{script['id']}_{script['band'].replace('-','')}_{ script['scenario']}.mp3\"\n", " result = await edge_synthesize(\n", " text=script[\"text\"],\n", " output_path=output_path,\n", " )\n", " result[\"script_id\"] = script[\"id\"]\n", " result[\"band\"] = script[\"band\"]\n", " result[\"scenario\"] = script[\"scenario\"]\n", " edge_results.append(result)\n", " print(f\"Done: script {script['id']} — {result['latency_seconds']}s\")\n", "\n", "print(\"\\nAll done!\")" ] }, { "cell_type": "code", "execution_count": 11, "id": "8a7d164c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " script_id band scenario latency_seconds voice engine\n", "0 1 K-2 praise 0.452 en-US-JennyNeural edge_tts\n", "1 2 K-2 correction 0.482 en-US-JennyNeural edge_tts\n", "2 3 3-5 instruction 0.509 en-US-JennyNeural edge_tts\n", "3 4 6-8 correction 0.622 en-US-JennyNeural edge_tts\n", "4 5 9-12 correction 0.606 en-US-JennyNeural edge_tts\n", "5 6 6-8 SEL 0.465 en-US-JennyNeural edge_tts\n" ] } ], "source": [ "import pandas as pd\n", "df_edge = pd.DataFrame(edge_results)\n", "print(df_edge[[\"script_id\", \"band\", \"scenario\", \"latency_seconds\", \"voice\", \"engine\"]])\n", "pd.DataFrame(edge_results).to_csv(\"../results/edge_tts_latency.csv\", index=False)" ] }, { "cell_type": "code", "execution_count": 12, "id": "43358169", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "K-2 at speed 0.85: 1.299s\n", "9-12 at speed 1.1: 2.466s\n" ] } ], "source": [ "\n", "from src.kokoro_client import synthesize as kokoro_synthesize\n", "\n", "speed_tests = [\n", " {\"band\": \"K-2\", \"speed\": 0.85, \"script_id\": 1},\n", " {\"band\": \"9-12\", \"speed\": 1.1, \"script_id\": 5},\n", "]\n", "\n", "for test in speed_tests:\n", " script = next(s for s in SCRIPTS if s[\"id\"] == test[\"script_id\"])\n", " result = kokoro_synthesize(\n", " text=script[\"text\"],\n", " output_path=f\"../audio_outputs/kokoro_speed_{test['band'].replace('-','')}_{ test['speed']}.wav\",\n", " voice=\"af_heart\" if test[\"band\"] == \"K-2\" else \"am_echo\",\n", " speed=test[\"speed\"]\n", " )\n", " print(f\"{test['band']} at speed {test['speed']}: {result['latency_seconds']}s\")" ] }, { "cell_type": "code", "execution_count": 13, "id": "f64c91d8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " avg_latency min_latency max_latency\n", "engine \n", "edge_tts 0.523 0.452 0.622\n", "kokoro 2.173 1.229 2.876\n", "pyttsx3 0.093 0.081 0.109\n" ] } ], "source": [ "import pandas as pd\n", "\n", "# combine all results\n", "all_results = (\n", " [{**r, \"engine\": \"pyttsx3\"} for r in results] +\n", " [{**r} for r in kokoro_results] +\n", " [{**r} for r in edge_results]\n", ")\n", "\n", "df_all = pd.DataFrame(all_results)\n", "\n", "# summary table — average latency per engine\n", "summary = df_all.groupby(\"engine\").agg(\n", " avg_latency=(\"latency_seconds\", \"mean\"),\n", " min_latency=(\"latency_seconds\", \"min\"),\n", " max_latency=(\"latency_seconds\", \"max\"),\n", ").round(3)\n", "\n", "print(summary)" ] }, { "cell_type": "code", "execution_count": 14, "id": "912fdd3f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " engine total_score avg_latency_seconds cost runs_locally\n", " pyttsx3 8 0.093 $0 (local) Yes\n", " kokoro 15 2.173 $0 (local) Yes\n", "edge_tts 13 0.523 $0 (free tier) No (internet)\n" ] } ], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "# anchored rubric scores (1-3) based on manual listening evaluation\n", "# 1 = poor, 2 = acceptable, 3 = good (see anchor definitions in report)\n", "rubric = pd.DataFrame([\n", " {\"engine\": \"pyttsx3\", \"intelligibility\": 2, \"naturalness\": 1, \"pacing\": 2, \"friendliness\": 1, \"consistency\": 2},\n", " {\"engine\": \"kokoro\", \"intelligibility\": 3, \"naturalness\": 3, \"pacing\": 3, \"friendliness\": 3, \"consistency\": 3},\n", " {\"engine\": \"edge_tts\", \"intelligibility\": 3, \"naturalness\": 2, \"pacing\": 3, \"friendliness\": 2, \"consistency\": 3},\n", "])\n", "\n", "rubric[\"total_score\"] = rubric[[\"intelligibility\", \"naturalness\", \"pacing\", \"friendliness\", \"consistency\"]].sum(axis=1)\n", "rubric[\"max_score\"] = 15\n", "\n", "latency = df_all.groupby(\"engine\")[\"latency_seconds\"].mean().round(3).reset_index()\n", "latency.columns = [\"engine\", \"avg_latency_seconds\"]\n", "\n", "final = rubric.merge(latency, on=\"engine\")\n", "final[\"cost\"] = final[\"engine\"].map({\n", " \"pyttsx3\": \"$0 (local)\",\n", " \"kokoro\": \"$0 (local)\",\n", " \"edge_tts\": \"$0 (free tier)\",\n", "})\n", "final[\"runs_locally\"] = final[\"engine\"].map({\n", " \"pyttsx3\": \"Yes\",\n", " \"kokoro\": \"Yes\",\n", " \"edge_tts\": \"No (internet)\",\n", "})\n", "\n", "print(final[[\"engine\", \"total_score\", \"avg_latency_seconds\", \"cost\", \"runs_locally\"]].to_string(index=False))\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "504d5a01", "metadata": {}, "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": [ "Saved.\n" ] } ], "source": [ "# rubric heatmap\n", "metrics = [\"intelligibility\", \"naturalness\", \"pacing\", \"friendliness\", \"consistency\"]\n", "heatmap_data = rubric.set_index(\"engine\")[metrics]\n", "\n", "plt.figure(figsize=(9, 4))\n", "sns.heatmap(heatmap_data, annot=True, fmt=\".0f\", cmap=\"YlGn\", vmin=1, vmax=3, linewidths=0.5)\n", "plt.title(\"TTS Rubric Scores by Engine (1-3)\")\n", "plt.tight_layout()\n", "plt.savefig(\"../results/tts_rubric_heatmap.png\", dpi=150)\n", "plt.show()\n", "\n", "# bar chart\n", "rubric_melted = rubric.melt(id_vars=\"engine\", value_vars=metrics, var_name=\"metric\", value_name=\"score\")\n", "\n", "plt.figure(figsize=(10, 5))\n", "sns.barplot(data=rubric_melted, x=\"metric\", y=\"score\", hue=\"engine\")\n", "plt.ylim(0, 3.5)\n", "plt.title(\"TTS System Comparison — Rubric Scores\")\n", "plt.ylabel(\"Score (1-3)\")\n", "plt.tight_layout()\n", "plt.savefig(\"../results/tts_rubric_comparison.png\", dpi=150)\n", "plt.show()\n", "\n", "final.to_csv(\"../results/tts_results.csv\", index=False)\n", "print(\"Saved.\")" ] }, { "cell_type": "code", "execution_count": 16, "id": "3689ba57", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Done: script 1 (K-2) — 1.318s\n", "Done: script 2 (K-2) — 1.444s\n", "Done: script 3 (3-5) — 2.253s\n", "Done: script 4 (6-8) — 2.659s\n", "Done: script 5 (9-12) — 2.341s\n", "Done: script 6 (6-8) — 2.074s\n", "\n", "All done!\n" ] } ], "source": [ "import sys\n", "sys.path.append(\"..\")\n", "from src.kokoro_client import synthesize as kokoro_synthesize\n", "from config.tts_scripts import SCRIPTS\n", "import pandas as pd\n", "\n", "# grade-band tuned voice + speed config\n", "band_config = {\n", " \"K-2\": {\"voice\": \"af_heart\", \"speed\": 0.85},\n", " \"3-5\": {\"voice\": \"af_heart\", \"speed\": 0.95},\n", " \"6-8\": {\"voice\": \"af_heart\", \"speed\": 1.0},\n", " \"9-12\": {\"voice\": \"am_echo\", \"speed\": 1.1},\n", "}\n", "\n", "kokoro_tuned_results = []\n", "\n", "for script in SCRIPTS:\n", " config = band_config[script[\"band\"]]\n", " output_path = f\"../audio_outputs/kokoro_tuned_script{script['id']}_{script['band'].replace('-','')}.wav\"\n", " result = kokoro_synthesize(\n", " text=script[\"text\"],\n", " output_path=output_path,\n", " voice=config[\"voice\"],\n", " speed=config[\"speed\"]\n", " )\n", " result[\"script_id\"] = script[\"id\"]\n", " result[\"band\"] = script[\"band\"]\n", " result[\"scenario\"] = script[\"scenario\"]\n", " kokoro_tuned_results.append(result)\n", " print(f\"Done: script {script['id']} ({script['band']}) — {result['latency_seconds']}s\")\n", "\n", "print(\"\\nAll done!\")\n" ] }, { "cell_type": "code", "execution_count": 17, "id": "104d2650", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " script_id band scenario latency_seconds voice engine\n", "0 1 K-2 praise 1.318 af_heart kokoro\n", "1 2 K-2 correction 1.444 af_heart kokoro\n", "2 3 3-5 instruction 2.253 af_heart kokoro\n", "3 4 6-8 correction 2.659 af_heart kokoro\n", "4 5 9-12 correction 2.341 am_echo kokoro\n", "5 6 6-8 SEL 2.074 af_heart kokoro\n" ] } ], "source": [ "import pandas as pd\n", "df_kokoro_tuned = pd.DataFrame(kokoro_tuned_results)\n", "print(df_kokoro_tuned[[\"script_id\", \"band\", \"scenario\", \"latency_seconds\", \"voice\", \"engine\"]])\n", "pd.DataFrame(kokoro_tuned_results).to_csv(\"../results/kokoro_tuned_latency.csv\", index=False)" ] }, { "cell_type": "code", "execution_count": 18, "id": "439a2902", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "=== LATENCY SUMMARY ===\n", " avg min max\n", "engine \n", "edge_tts 0.523 0.452 0.622\n", "kokoro_flat 2.173 1.229 2.876\n", "kokoro_tuned 2.015 1.318 2.659\n", "pyttsx3 0.093 0.081 0.109\n" ] } ], "source": [ "import pandas as pd\n", "\n", "pyttsx3_data = pd.read_csv(\"../results/pyttsx3_latency.csv\")\n", "kokoro_data = pd.read_csv(\"../results/kokoro_flat_latency.csv\")\n", "edge_data = pd.read_csv(\"../results/edge_tts_latency.csv\")\n", "kokoro_tuned_data = pd.read_csv(\"../results/kokoro_tuned_latency.csv\")\n", "\n", "# normalize engine names\n", "kokoro_data[\"engine\"] = \"kokoro_flat\"\n", "kokoro_tuned_data[\"engine\"] = \"kokoro_tuned\"\n", "\n", "df_all = pd.concat([pyttsx3_data, kokoro_data, edge_data, kokoro_tuned_data], ignore_index=True)\n", "\n", "latency_summary = df_all.groupby(\"engine\")[\"latency_seconds\"].agg(\n", " avg=\"mean\", min=\"min\", max=\"max\"\n", ").round(3)\n", "\n", "print(\"=== LATENCY SUMMARY ===\")\n", "print(latency_summary)" ] }, { "cell_type": "code", "execution_count": 20, "id": "e20acf84", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "=== FINAL COMPARISON TABLE ===\n", " engine total_score avg_latency_s cost local internet_required\n", " pyttsx3 8 0.093 $0 True False\n", " kokoro_flat 15 2.173 $0 True False\n", "kokoro_tuned 15 2.015 $0 True False\n", " edge_tts 13 0.523 $0 False True\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\aanki\\AppData\\Local\\Temp\\ipykernel_49132\\1101364454.py:55: FutureWarning: \n", "\n", "The `ci` parameter is deprecated. Use `errorbar=None` for the same effect.\n", "\n", " sns.barplot(data=df_all, x=\"engine\", y=\"latency_seconds\", ci=None, palette=\"Blues_d\")\n", "C:\\Users\\aanki\\AppData\\Local\\Temp\\ipykernel_49132\\1101364454.py:55: FutureWarning: \n", "\n", "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", "\n", " sns.barplot(data=df_all, x=\"engine\", y=\"latency_seconds\", ci=None, palette=\"Blues_d\")\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Saved to results/tts_results.csv\n" ] } ], "source": [ "# ---- qualitative rubric (from manual listening, 1-3 per metric) ----\n", "# anchor definitions in report Table X\n", "rubric = pd.DataFrame([\n", " {\n", " \"engine\": \"pyttsx3\",\n", " \"intelligibility\": 2, \"naturalness\": 1, \"pacing\": 2,\n", " \"friendliness\": 1, \"consistency\": 2,\n", " \"cost\": \"$0\", \"local\": True, \"internet_required\": False,\n", " },\n", " {\n", " \"engine\": \"kokoro_flat\",\n", " \"intelligibility\": 3, \"naturalness\": 3, \"pacing\": 3,\n", " \"friendliness\": 3, \"consistency\": 3,\n", " \"cost\": \"$0\", \"local\": True, \"internet_required\": False,\n", " },\n", " {\n", " \"engine\": \"kokoro_tuned\",\n", " \"intelligibility\": 3, \"naturalness\": 3, \"pacing\": 3,\n", " \"friendliness\": 3, \"consistency\": 3,\n", " \"cost\": \"$0\", \"local\": True, \"internet_required\": False,\n", " },\n", " {\n", " \"engine\": \"edge_tts\",\n", " \"intelligibility\": 3, \"naturalness\": 2, \"pacing\": 3,\n", " \"friendliness\": 2, \"consistency\": 3,\n", " \"cost\": \"$0\", \"local\": False, \"internet_required\": True,\n", " },\n", "])\n", "\n", "rubric[\"total_score\"] = rubric[[\"intelligibility\", \"naturalness\", \"pacing\", \"friendliness\", \"consistency\"]].sum(axis=1)\n", "\n", "# merge with latency\n", "latency_avg = df_all.groupby(\"engine\")[\"latency_seconds\"].mean().round(3).reset_index()\n", "latency_avg.columns = [\"engine\", \"avg_latency_s\"]\n", "\n", "final = rubric.merge(latency_avg, on=\"engine\")\n", "\n", "# ---- print final table ----\n", "print(\"=== FINAL COMPARISON TABLE ===\")\n", "print(final[[\"engine\", \"total_score\", \"avg_latency_s\", \"cost\", \"local\", \"internet_required\"]].to_string(index=False))\n", "\n", "# ---- rubric heatmap ----\n", "metrics = [\"intelligibility\", \"naturalness\", \"pacing\", \"friendliness\", \"consistency\"]\n", "heatmap_data = rubric.set_index(\"engine\")[metrics]\n", "\n", "plt.figure(figsize=(9, 4))\n", "sns.heatmap(heatmap_data, annot=True, fmt=\".0f\", cmap=\"YlGn\", vmin=1, vmax=3, linewidths=0.5)\n", "plt.title(\"TTS Rubric Scores by Engine (1-3)\")\n", "plt.tight_layout()\n", "plt.savefig(\"../results/tts_rubric_heatmap.png\", dpi=150)\n", "plt.show()\n", "\n", "# ---- latency bar chart ----\n", "plt.figure(figsize=(8, 4))\n", "sns.barplot(data=df_all, x=\"engine\", y=\"latency_seconds\", ci=None, palette=\"Blues_d\")\n", "plt.title(\"Average Latency by TTS Engine\")\n", "plt.ylabel(\"Latency (seconds)\")\n", "plt.tight_layout()\n", "plt.savefig(\"../results/tts_latency_comparison.png\", dpi=150)\n", "plt.show()\n", "\n", "# ---- save to csv ----\n", "final.to_csv(\"../results/tts_results.csv\", index=False)\n", "print(\"\\nSaved to results/tts_results.csv\")" ] }, { "cell_type": "code", "execution_count": 20, "id": "11d03bad", "metadata": {}, "outputs": [], "source": [ "import librosa\n", "import numpy as np\n", "\n", "def mcd(audio1_path: str, audio2_path: str) -> float:\n", " \"\"\"\n", " Compute Mel Cepstral Distortion between two audio files.\n", " Lower = more similar = more consistent output.\n", " \n", " Args:\n", " audio1_path: path to first .wav or .mp3 file\n", " audio2_path: path to second .wav or .mp3 file\n", " \n", " Returns:\n", " float: MCD score (lower is better)\n", " \"\"\"\n", " y1, sr1 = librosa.load(audio1_path, sr=None)\n", " y2, sr2 = librosa.load(audio2_path, sr=None)\n", "\n", " # resample to common rate if needed\n", " if sr1 != sr2:\n", " y2 = librosa.resample(y2, orig_sr=sr2, target_sr=sr1)\n", "\n", " # extract MFCC (13 coefficients, standard for MCD)\n", " mfcc1 = librosa.feature.mfcc(y=y1, sr=sr1, n_mfcc=13)\n", " mfcc2 = librosa.feature.mfcc(y=y2, sr=sr2, n_mfcc=13)\n", "\n", " # align lengths by trimming to shorter\n", " min_len = min(mfcc1.shape[1], mfcc2.shape[1])\n", " mfcc1 = mfcc1[:, :min_len]\n", " mfcc2 = mfcc2[:, :min_len]\n", "\n", " # MCD formula\n", " diff = mfcc1 - mfcc2\n", " mcd_score = np.mean(np.sqrt(2 * np.sum(diff ** 2, axis=0)))\n", " return round(float(mcd_score), 4)" ] }, { "cell_type": "code", "execution_count": 21, "id": "6487b5f2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " pyttsx3 script1 run0 done\n", " pyttsx3 script1 run1 done\n", " pyttsx3 script1 run2 done\n", "pyttsx3 script1 avg MCD: 0.0\n", " kokoro script1 run0 done\n", " kokoro script1 run1 done\n", " kokoro script1 run2 done\n", "kokoro script1 avg MCD: 3.9358\n", " edge_tts script1 run0 done\n", " edge_tts script1 run1 done\n", " edge_tts script1 run2 done\n", "edge_tts script1 avg MCD: 0.0\n", " pyttsx3 script3 run0 done\n", " pyttsx3 script3 run1 done\n", " pyttsx3 script3 run2 done\n", "pyttsx3 script3 avg MCD: 0.0\n", " kokoro script3 run0 done\n", " kokoro script3 run1 done\n", " kokoro script3 run2 done\n", "kokoro script3 avg MCD: 4.3446\n", " edge_tts script3 run0 done\n", " edge_tts script3 run1 done\n", " edge_tts script3 run2 done\n", "edge_tts script3 avg MCD: 0.0\n", " pyttsx3 script5 run0 done\n", " pyttsx3 script5 run1 done\n", " pyttsx3 script5 run2 done\n", "pyttsx3 script5 avg MCD: 0.0\n", " kokoro script5 run0 done\n", " kokoro script5 run1 done\n", " kokoro script5 run2 done\n", "kokoro script5 avg MCD: 4.0969\n", " edge_tts script5 run0 done\n", " edge_tts script5 run1 done\n", " edge_tts script5 run2 done\n", "edge_tts script5 avg MCD: 0.0\n", "\n", "Done!\n" ] } ], "source": [ "import time\n", "\n", "consistency_scripts = [1, 3, 5] # short, medium, long\n", "n_runs = 3\n", "\n", "consistency_results = []\n", "\n", "for script_id in consistency_scripts:\n", " script = next(s for s in SCRIPTS if s[\"id\"] == script_id)\n", " \n", " for engine_name in [\"pyttsx3\", \"kokoro\", \"edge_tts\"]:\n", " paths = []\n", " \n", " for run in range(n_runs):\n", " out_path = f\"../audio_outputs/consistency_{engine_name}_script{script_id}_run{run}.{'mp3' if engine_name == 'edge_tts' else 'wav'}\"\n", " \n", " if engine_name == \"pyttsx3\":\n", " from src.pyttsx3_client import synthesize as pyttsx3_synthesize\n", " pyttsx3_synthesize(text=script[\"text\"], output_path=out_path)\n", " elif engine_name == \"kokoro\":\n", " kokoro_synthesize(text=script[\"text\"], output_path=out_path, voice=\"af_heart\", speed=1.0)\n", " elif engine_name == \"edge_tts\":\n", " import asyncio\n", " from src.edge_tts_client import synthesize as edge_synthesize\n", " await edge_synthesize(text=script[\"text\"], output_path=out_path)\n", " \n", " paths.append(out_path)\n", " print(f\" {engine_name} script{script_id} run{run} done\")\n", " \n", " # compute MCD between run 0 and run 1, run 0 and run 2\n", " mcd_01 = mcd(paths[0], paths[1])\n", " mcd_02 = mcd(paths[0], paths[2])\n", " avg_mcd = round((mcd_01 + mcd_02) / 2, 4)\n", " \n", " consistency_results.append({\n", " \"engine\": engine_name,\n", " \"script_id\": script_id,\n", " \"mcd_01\": mcd_01,\n", " \"mcd_02\": mcd_02,\n", " \"avg_mcd\": avg_mcd,\n", " })\n", " print(f\"{engine_name} script{script_id} avg MCD: {avg_mcd}\")\n", "\n", "print(\"\\nDone!\")" ] }, { "cell_type": "code", "execution_count": 22, "id": "015280e6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "=== CONSISTENCY SUMMARY (MCD, lower = more consistent) ===\n", " mean min max\n", "engine \n", "edge_tts 0.0000 0.0000 0.0000\n", "kokoro 4.1258 3.9358 4.3446\n", "pyttsx3 0.0000 0.0000 0.0000\n" ] } ], "source": [ "df_consistency = pd.DataFrame(consistency_results)\n", "\n", "summary_consistency = df_consistency.groupby(\"engine\")[\"avg_mcd\"].agg(\n", " mean=\"mean\", min=\"min\", max=\"max\"\n", ").round(4)\n", "\n", "print(\"=== CONSISTENCY SUMMARY (MCD, lower = more consistent) ===\")\n", "print(summary_consistency)" ] }, { "cell_type": "code", "execution_count": 23, "id": "e37e34d0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Saved.\n" ] } ], "source": [ "df_consistency.to_csv(\"../results/tts_consistency_results.csv\", index=False)\n", "print(\"Saved.\")" ] }, { "cell_type": "code", "execution_count": 24, "id": "31edcdec", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pivot = df_consistency.pivot_table(index=\"engine\", columns=\"script_id\", values=\"avg_mcd\")\n", "\n", "plt.figure(figsize=(7, 3))\n", "sns.heatmap(pivot, annot=True, fmt=\".2f\", cmap=\"YlOrRd_r\", linewidths=0.5)\n", "plt.title(\"MCD Consistency Scores by Engine and Script (lower = more consistent)\")\n", "plt.tight_layout()\n", "plt.savefig(\"../results/tts_consistency_heatmap.png\", dpi=150)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 1, "id": "d8cf9095", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING: Defaulting repo_id to hexgrad/Kokoro-82M. Pass repo_id='hexgrad/Kokoro-82M' to suppress this warning.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "d:\\Bantrly\\code\\Project B\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\rnn.py:1013: UserWarning: dropout option adds dropout after all but last recurrent layer, so non-zero dropout expects num_layers greater than 1, but got dropout=0.2 and num_layers=1\n", " super().__init__(\"LSTM\", *args, **kwargs)\n", "d:\\Bantrly\\code\\Project B\\.venv\\Lib\\site-packages\\torch\\nn\\utils\\weight_norm.py:144: FutureWarning: `torch.nn.utils.weight_norm` is deprecated in favor of `torch.nn.utils.parametrizations.weight_norm`.\n", " WeightNorm.apply(module, name, dim)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "{'output_path': '../audio_outputs/manager_test_k2.wav', 'latency_seconds': 0.785, 'engine': 'kokoro', 'voice': 'af_heart', 'band': 'K-2'}\n" ] } ], "source": [ "import sys\n", "sys.path.append(\"..\")\n", "from src.tts_manager import synthesize_for_band\n", "\n", "result = synthesize_for_band(\n", " text=\"You did such a great job speaking today!\",\n", " band=\"K-2\",\n", " output_path=\"../audio_outputs/manager_test_k2\"\n", ")\n", "print(result)" ] }, { "cell_type": "code", "execution_count": 1, "id": "f7a7b3b1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING: Defaulting repo_id to hexgrad/Kokoro-82M. Pass repo_id='hexgrad/Kokoro-82M' to suppress this warning.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "d:\\Bantrly\\code\\Project B\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\rnn.py:1013: UserWarning: dropout option adds dropout after all but last recurrent layer, so non-zero dropout expects num_layers greater than 1, but got dropout=0.2 and num_layers=1\n", " super().__init__(\"LSTM\", *args, **kwargs)\n", "d:\\Bantrly\\code\\Project B\\.venv\\Lib\\site-packages\\torch\\nn\\utils\\weight_norm.py:144: FutureWarning: `torch.nn.utils.weight_norm` is deprecated in favor of `torch.nn.utils.parametrizations.weight_norm`.\n", " WeightNorm.apply(module, name, dim)\n", "Engine kokoro failed: simulated GPU OOM. Trying next.\n", "Kokoro unavailable, using fallback: edge_tts\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "{'output_path': '../audio_outputs/manager_test_fallback2.mp3', 'latency_seconds': 0.726, 'engine': 'edge_tts', 'voice': 'en-US-JennyNeural', 'band': 'K-2'}\n" ] } ], "source": [ "# test fallback by passing an invalid voice to trigger kokoro failure\n", "import sys\n", "sys.path.append(\"..\")\n", "from src.tts_manager import synthesize_for_band, FALLBACK_CHAIN\n", "import unittest.mock as mock\n", "\n", "# temporarily break kokoro to test fallback\n", "with mock.patch(\"src.tts_manager.kokoro_synthesize\", side_effect=RuntimeError(\"simulated GPU OOM\")):\n", " result = synthesize_for_band(\n", " text=\"You did such a great job speaking today!\",\n", " band=\"K-2\",\n", " output_path=\"../audio_outputs/manager_test_fallback2\"\n", " )\n", " print(result)" ] }, { "cell_type": "code", "execution_count": null, "id": "a87d4705", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": ".venv", "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.12.5" } }, "nbformat": 4, "nbformat_minor": 5 }