From 9e9836537bf7815515a8a548024cec6aaf991d83 Mon Sep 17 00:00:00 2001 From: rdingjin Date: Tue, 26 May 2026 15:26:43 +0000 Subject: [PATCH] 14. 11H05-GAL4>UAS-ChRmine-attP5 no ATR vs ATR --- 14.11H05_ChRmine_noATRvsATR.ipynb | 294 ++++++++++++++++++++++++++++++ 1 file changed, 294 insertions(+) create mode 100644 14.11H05_ChRmine_noATRvsATR.ipynb diff --git a/14.11H05_ChRmine_noATRvsATR.ipynb b/14.11H05_ChRmine_noATRvsATR.ipynb new file mode 100644 index 0000000..180ff61 --- /dev/null +++ b/14.11H05_ChRmine_noATRvsATR.ipynb @@ -0,0 +1,294 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "52cafe51-05b0-4287-bf31-418090f929de", + "metadata": {}, + "outputs": [], + "source": [ + "# COMPARE NO-ATR VS ATR (11H05 crosses)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "76a37581-2e43-4fec-9886-0f0849b86602", + "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": 10, + "id": "5450b41f-4a94-48f1-99c9-9a8a2862165e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing No-ATR Data...\n", + "Processing ATR Data...\n" + ] + } + ], + "source": [ + "# 1. LOAD SAVED PICKLE FILES\n", + "df_no_atr_raw = pd.read_pickle('/home/rdingjin/UASxGal4_2026-04-28/phase6.pkl')\n", + "df_atr_raw = pd.read_pickle('/home/rdingjin/UASxGal4_2026-05-05/phase7(11H)1.pkl')\n", + "\n", + "# 2. HELPER FUNCTION\n", + "def calculate_delta_sleep(df, base_start, base_end, stim_start, stim_end):\n", + " \n", + " # --- BASELINE ---\n", + " base_df = df.t_filter(start_time=base_start, end_time=base_end).copy()\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", + " 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", + " 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", + " 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()\n", + "\n", + "# 3. PROCESS GROUPS\n", + "print(\"Processing No-ATR Data...\")\n", + "delta_no_atr = calculate_delta_sleep(df_no_atr_raw, base_start=0, base_end=48, stim_start=48, stim_end=72)\n", + "delta_no_atr['Condition'] = 'No-ATR'\n", + "\n", + "print(\"Processing ATR Data...\")\n", + "delta_atr = calculate_delta_sleep(df_atr_raw, base_start=0, base_end=48, stim_start=48, stim_end=72)\n", + "delta_atr['Condition'] = 'ATR'\n", + "\n", + "master_delta = pd.concat([delta_no_atr, delta_atr], ignore_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "642d6bbc-3674-4c1e-9a41-88928ee407f1", + "metadata": {}, + "outputs": [], + "source": [ + "# 4. MELT DATA FOR PLOTTING AND STATS\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": 13, + "id": "fb18dd18-a4f4-4f06-a088-e2cf6b5a677c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "==================================================\n", + "--- SCIPY T-TESTS (No-ATR vs ATR Delta) ---\n", + "==================================================\n", + "24h Total Phase Comparison:\n", + " No-ATR Δ Mean: 1.24 hours\n", + " ATR Δ Mean: -5.42 hours\n", + " P-value: 1.3586e-13\n", + "\n", + "Day Phase Comparison:\n", + " No-ATR Δ Mean: 0.07 hours\n", + " ATR Δ Mean: -2.21 hours\n", + " P-value: 2.5060e-07\n", + "\n", + "Night Phase Comparison:\n", + " No-ATR Δ Mean: 0.22 hours\n", + " ATR Δ Mean: -3.86 hours\n", + " P-value: 9.3420e-12\n", + "\n" + ] + } + ], + "source": [ + "# 5. STATISTICAL COMPARISON \n", + "print(\"\\n\" + \"=\"*50)\n", + "print(\"--- SCIPY T-TESTS (No-ATR vs ATR Delta) ---\")\n", + "print(\"=\"*50)\n", + "\n", + "p_values = {}\n", + "phases = ['24h Total', 'Day', 'Night']\n", + "\n", + "for phase in phases:\n", + " group_no_atr = melted_delta[(melted_delta['Phase'] == phase) & (melted_delta['Condition'] == 'No-ATR')]['Sleep_Change']\n", + " group_atr = melted_delta[(melted_delta['Phase'] == phase) & (melted_delta['Condition'] == 'ATR')]['Sleep_Change']\n", + " \n", + " # Run Independent T-Test\n", + " t_stat, p_val = ttest_ind(group_no_atr, group_atr)\n", + " p_values[phase] = p_val\n", + " \n", + " print(f\"{phase} Phase Comparison:\")\n", + " print(f\" No-ATR Δ Mean: {group_no_atr.mean():.2f} hours\")\n", + " print(f\" ATR Δ Mean: {group_atr.mean():.2f} hours\")\n", + " print(f\" P-value: {p_val:.4e}\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "c11c05b3-a8b5-4e86-86bf-bae60ec24103", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_50430/3429110790.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": [ + "# 6. 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={'No-ATR': '#cccccc', 'ATR': '#f1c232'}, 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", + "# Add Median Labels\n", + "medians = melted_delta.groupby(['Phase', 'Condition'], sort=False)['Sleep_Change'].median()\n", + "offsets = {'No-ATR': -0.4, 'ATR': 0.4}\n", + "\n", + "for i, phase in enumerate(phases):\n", + " for condition in ['No-ATR', 'ATR']:\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\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", + " 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", + "plt.axhline(0, color='black', linestyle='--', linewidth=1.5, alpha=0.7)\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", + "plt.legend(title='', frameon=False, loc='center left', bbox_to_anchor=(1, 0.5))\n", + "plt.ylim(y_min - (y_range * 0.1), y_max + (y_range * 0.25))\n", + "plt.tight_layout()\n", + "\n", + "plt.savefig(\"ATR_vs_NoATR_Delta.png\", dpi=600, bbox_inches='tight')\n", + "\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 +}