From 749fed355bb6ff88e87ffc802ac51fd743842412 Mon Sep 17 00:00:00 2001 From: rdingjin Date: Tue, 26 May 2026 14:06:02 +0000 Subject: [PATCH] =?UTF-8?q?4.=20CantonS=20=E2=88=86Sleep=20Red=20vs=20Gree?= =?UTF-8?q?n?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 4.CantonS_RedvsGreen.ipynb | 319 +++++++++++++++++++++++++++++++++++++ 1 file changed, 319 insertions(+) create mode 100644 4.CantonS_RedvsGreen.ipynb diff --git a/4.CantonS_RedvsGreen.ipynb b/4.CantonS_RedvsGreen.ipynb new file mode 100644 index 0000000..03736af --- /dev/null +++ b/4.CantonS_RedvsGreen.ipynb @@ -0,0 +1,319 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "6292486f-f8e8-47ab-812f-ebe9f5214f56", + "metadata": {}, + "outputs": [], + "source": [ + "# COMPARE RED VS GREEN STIMULUS IN CANTONS" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "30307c96-a288-4ab0-9554-68ec28ad686d", + "metadata": {}, + "outputs": [], + "source": [ + "import ethoscopy as etho\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from scipy.stats import ttest_ind" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ffa045e8-3154-435e-89d5-819f1dec42fd", + "metadata": {}, + "outputs": [], + "source": [ + "# 1. LOAD THE SAVED PICKLE FILES\n", + "\n", + "df_red_raw = pd.read_pickle('/home/rdingjin/Optic_2026-04-01/phase2.pkl')\n", + "df_green_raw = pd.read_pickle('/home/rdingjin/CantonS_2026-05-01/phase3.pkl')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9c34a8ba-a969-4824-87da-53599529e8b9", + "metadata": {}, + "outputs": [], + "source": [ + "# 2. HELPER FUNCTION TO CALCULATE DELTA SLEEP\n", + "\n", + "def calculate_delta_sleep(df, base_start, base_end, stim_start, stim_end):\n", + " \"\"\"Automates baseline vs stimulus pipeline and returns Delta Sleep\"\"\"\n", + " \n", + " # --- BASELINE ---\n", + " base_df = df.t_filter(start_time=base_start, end_time=base_end).copy()\n", + " \n", + " sleep_hours_base = (base_df.groupby('id')['asleep'].sum() * 10) / 3600\n", + " base_overall = (sleep_hours_base / ((base_end - base_start) / 24)).reset_index(name='Base_Sleep_24h')\n", + " \n", + " base_df['zt_hour'] = (base_df['t'] / 3600) % 24\n", + " base_df['Phase'] = np.where(base_df['zt_hour'] < 12, 'Day', 'Night')\n", + " base_phase = base_df.groupby(['id', 'Phase']).agg(\n", + " total_sleep_epochs=('asleep', 'sum'), total_tracking_epochs=('t', 'count')\n", + " ).reset_index()\n", + " \n", + " base_phase['Sleep_Hours'] = (base_phase['total_sleep_epochs'] * 10) / 3600\n", + " base_phase['Tracking_Hours'] = (base_phase['total_tracking_epochs'] * 10) / 3600\n", + " base_phase['Base_Sleep_12h'] = (base_phase['Sleep_Hours'] / base_phase['Tracking_Hours']) * 12\n", + " base_pivot = base_phase.pivot(index='id', columns='Phase', values='Base_Sleep_12h').reset_index()\n", + " base_pivot.columns = ['id', 'Base_Day_12h', 'Base_Night_12h']\n", + " baseline_stats = pd.merge(base_overall, base_pivot, on='id')\n", + " \n", + " # --- STIMULUS ---\n", + " stim_df = df.t_filter(start_time=stim_start, end_time=stim_end).copy()\n", + " \n", + " sleep_hours_stim = (stim_df.groupby('id')['asleep'].sum() * 10) / 3600\n", + " stim_overall = (sleep_hours_stim / ((stim_end - stim_start) / 24)).reset_index(name='Stim_Sleep_24h')\n", + " \n", + " stim_df['zt_hour'] = (stim_df['t'] / 3600) % 24\n", + " stim_df['Phase'] = np.where(stim_df['zt_hour'] < 12, 'Day', 'Night')\n", + " stim_phase = stim_df.groupby(['id', 'Phase']).agg(\n", + " total_sleep_epochs=('asleep', 'sum'), total_tracking_epochs=('t', 'count')\n", + " ).reset_index()\n", + " \n", + " stim_phase['Sleep_Hours'] = (stim_phase['total_sleep_epochs'] * 10) / 3600\n", + " stim_phase['Tracking_Hours'] = (stim_phase['total_tracking_epochs'] * 10) / 3600\n", + " stim_phase['Stim_Sleep_12h'] = (stim_phase['Sleep_Hours'] / stim_phase['Tracking_Hours']) * 12\n", + " stim_pivot = stim_phase.pivot(index='id', columns='Phase', values='Stim_Sleep_12h').reset_index()\n", + " stim_pivot.columns = ['id', 'Stim_Day_12h', 'Stim_Night_12h']\n", + " stim_stats = pd.merge(stim_overall, stim_pivot, on='id')\n", + " \n", + " # --- MERGE & CALCULATE DELTA ---\n", + " combined = pd.merge(baseline_stats, stim_stats, on='id')\n", + " \n", + " unique_meta = df.meta['machine_name'][~df.meta.index.duplicated(keep='first')]\n", + " combined['Machine'] = combined['id'].map(unique_meta)\n", + " combined['Tube'] = combined['id'].apply(lambda x: str(x).split('|')[-1])\n", + " combined['Fly_Label'] = combined['Machine'] + \" - Fly \" + combined['Tube']\n", + " \n", + " combined['Delta_24h'] = combined['Stim_Sleep_24h'] - combined['Base_Sleep_24h']\n", + " combined['Delta_Day'] = combined['Stim_Day_12h'] - combined['Base_Day_12h']\n", + " combined['Delta_Night'] = combined['Stim_Night_12h'] - combined['Base_Night_12h']\n", + " \n", + " return combined[['Fly_Label', 'Delta_24h', 'Delta_Day', 'Delta_Night']].dropna()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3b7caa58-7f73-42ef-9df1-83cc6dd21ef3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing Red Light Data...\n", + "Processing Green Light Data...\n" + ] + } + ], + "source": [ + "# 3. PROCESS GROUPS AND COMBINE\n", + "\n", + "print(\"Processing Red Light Data...\")\n", + "delta_red = calculate_delta_sleep(df_red_raw, base_start=0, base_end=48, stim_start=48, stim_end=72)\n", + "delta_red['Condition'] = 'Red'\n", + "\n", + "print(\"Processing Green Light Data...\")\n", + "delta_green = calculate_delta_sleep(df_green_raw, base_start=0, base_end=72, stim_start=72, stim_end=96)\n", + "delta_green['Condition'] = 'Green'\n", + "\n", + "# Merge them into a single Master table\n", + "master_delta = pd.concat([delta_red, delta_green], ignore_index=True)\n", + "\n", + "# Melt the data for plotting and stats (24h, Day, Night stacked)\n", + "melted_delta = master_delta.melt(\n", + " id_vars=['Fly_Label', 'Condition'],\n", + " value_vars=['Delta_24h', 'Delta_Day', 'Delta_Night'],\n", + " var_name='Phase', \n", + " value_name='Sleep_Change'\n", + ")\n", + "# Clean up phase names\n", + "melted_delta['Phase'] = melted_delta['Phase'].map({'Delta_24h': '24h Total', 'Delta_Day': 'Day', 'Delta_Night': 'Night'})" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1af708c4-5cc8-4b02-a28d-e5a219007f6e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "==================================================\n", + "--- SCIPY T-TESTS (Red vs Green Delta) ---\n", + "==================================================\n", + "24h Total Phase Comparison:\n", + " Red Δ Mean: 1.61 hours\n", + " Green Δ Mean: -3.73 hours\n", + " P-value: 2.5958e-07\n", + "\n", + "Day Phase Comparison:\n", + " Red Δ Mean: 1.13 hours\n", + " Green Δ Mean: -1.69 hours\n", + " P-value: 8.3423e-07\n", + "\n", + "Night Phase Comparison:\n", + " Red Δ Mean: 0.09 hours\n", + " Green Δ Mean: -2.76 hours\n", + " P-value: 4.9990e-05\n", + "\n" + ] + } + ], + "source": [ + "# 4. STATISTICAL COMPARISON \n", + "\n", + "print(\"\\n\" + \"=\"*50)\n", + "print(\"--- SCIPY T-TESTS (Red vs Green Delta) ---\")\n", + "print(\"=\"*50)\n", + "\n", + "p_values = {}\n", + "phases = ['24h Total', 'Day', 'Night']\n", + "\n", + "for phase in phases:\n", + " group_red = melted_delta[(melted_delta['Phase'] == phase) & (melted_delta['Condition'] == 'Red')]['Sleep_Change']\n", + " group_green = melted_delta[(melted_delta['Phase'] == phase) & (melted_delta['Condition'] == 'Green')]['Sleep_Change']\n", + " \n", + " # Run Independent T-Test\n", + " t_stat, p_val = ttest_ind(group_red, group_green)\n", + " p_values[phase] = p_val\n", + " \n", + " print(f\"{phase} Phase Comparison:\")\n", + " print(f\" Red Δ Mean: {group_red.mean():.2f} hours\")\n", + " print(f\" Green Δ Mean: {group_green.mean():.2f} hours\")\n", + " print(f\" P-value: {p_val:.4e}\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "f31cbe1e-e965-4eef-a01e-a74cfdf2551d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_49373/2116923427.py:14: FutureWarning: \n", + "\n", + "Setting a gradient palette using color= is deprecated and will be removed in v0.14.0. Set `palette='dark:black'` for the same effect.\n", + "\n", + " sns.stripplot(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 5. FINAL COMPARISON PLOT\n", + "plt.figure(figsize=(8, 6))\n", + "sns.set_theme(style=\"ticks\")\n", + "\n", + "# Plot Boxplot\n", + "ax = sns.boxplot(\n", + " data=melted_delta, x='Phase', y='Sleep_Change', hue='Condition', \n", + " palette={'Red': '#ff4c4c', 'Green': '#51ff4c'}, order=phases,\n", + " width=0.6, gap=0.2, boxprops={'edgecolor': 'black', 'alpha': 0.7},\n", + " medianprops={'color': 'black', 'linewidth': 1.5}, showfliers=False\n", + ")\n", + "\n", + "# Plot internal points\n", + "sns.stripplot(\n", + " data=melted_delta, x='Phase', y='Sleep_Change', hue='Condition', \n", + " order=phases, dodge=True,\n", + " color='black', alpha=0.5, size=4, jitter=0.05, legend=False\n", + ")\n", + "\n", + "# Median labels\n", + "medians = melted_delta.groupby(['Phase', 'Condition'], sort=False)['Sleep_Change'].median()\n", + "offsets = {'Red': -0.4, 'Green': 0.4}\n", + "\n", + "for i, phase in enumerate(phases):\n", + " for condition in ['Red', 'Green']:\n", + " val = medians[(phase, condition)]\n", + " ax.text(i + offsets[condition], val, f\"{val:.1f}h\", \n", + " ha='center', va='bottom', fontsize=9)\n", + "\n", + "# Add Significance Brackets/Stars\n", + "y_max = melted_delta['Sleep_Change'].max()\n", + "y_min = melted_delta['Sleep_Change'].min()\n", + "y_range = y_max - y_min\n", + "y_line = y_max + (y_range * 0.05)\n", + "h = y_range * 0.02\n", + "\n", + "for i, phase in enumerate(phases):\n", + " p = p_values[phase]\n", + " if p < 0.05:\n", + " star = '****' if p < 0.0001 else ('***' if p < 0.001 else ('**' if p < 0.01 else '*'))\n", + " \n", + " # Draw bracket from Red center to Green center\n", + " x1, x2 = i - 0.2, i + 0.2\n", + " plt.plot([x1, x1, x2, x2], [y_line, y_line+h, y_line+h, y_line], lw=1.5, c='k')\n", + " plt.text((x1+x2)*.5, y_line+h, star, ha='center', va='bottom', fontsize=12)\n", + "\n", + "# Add a reference line at 0 \n", + "plt.axhline(0, color='black', linestyle='--', linewidth=1.5, alpha=0.7)\n", + "plt.text(2.5, 0.2, 'Baseline', ha='left', va='bottom', fontsize=10, alpha=0.7)\n", + "\n", + "# Formatting\n", + "sns.despine()\n", + "plt.ylabel('Change in average time spent asleep (Δ hours)', fontsize=12)\n", + "plt.xlabel('')\n", + "plt.xlim(-0.5, 2.5) \n", + "\n", + "# Move legend outside the plot\n", + "plt.legend(title='', frameon=False, loc='center left', bbox_to_anchor=(1, 0.5))\n", + "\n", + "plt.ylim(y_min - (y_range * 0.1), y_max + (y_range * 0.2)) # Give room for stars\n", + "plt.tight_layout()\n", + "\n", + "plt.savefig(\"Red_vs_Green.png\", dpi=600, bbox_inches='tight')\n", + "plt.show()" + ] + } + ], + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}