visualization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import plotly.io as pio\n",
    "import plotly.graph_objects as go\n",
    "import plotly.express as px\n",
    "import json\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import glob\n",
    "import os.path\n",
    "import chart_studio.plotly as py\n",
    "import plotly.graph_objs as go\n",
    "from itertools import product\n",
    "from plotly.subplots import make_subplots\n",
    "import  plotly.graph_objs as go \n",
    "import plotly\n",
    "from itertools import product\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.spatial.distance import squareform\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Paths to all pkl files \n",
    "naive_stillff_path = '/Users/huseyinelmas/Desktop/CCN-Lab/CCN-RSA/RSA_Results/Naive/Still_FF/correlation_hamming_avg_subjects_results.pkl'\n",
    "naive_stillmf_path = '/Users/huseyinelmas/Desktop/CCN-Lab/CCN-RSA/RSA_Results/Naive/Still_MF/correlation_hamming_avg_subjects_results.pkl'\n",
    "naive_video_path   = '/Users/huseyinelmas/Desktop/CCN-Lab/CCN-RSA/RSA_Results/Naive/Video/correlation_hamming_avg_subjects_results.pkl'\n",
    "prior_still_path   = '/Users/huseyinelmas/Desktop/CCN-Lab/CCN-RSA/RSA_Results/Prior/Still/correlation_hamming_avg_subjects_results.pkl'\n",
    "prior_video_path   = '/Users/huseyinelmas/Desktop/CCN-Lab/CCN-RSA/RSA_Results/Prior/Video/correlation_hamming_avg_subjects_results.pkl'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load pickle files as dataframes eeg, rdm distance metrics\n",
    "n_sff_rdm_statistics_df, eeg_rdm_dist_metric, model_rdm_dist_metric = pd.read_pickle(naive_stillff_path)\n",
    "n_smf_rdm_statistics_df, eeg_rdm_dist_metric, model_rdm_dist_metric = pd.read_pickle(naive_stillmf_path)\n",
    "n_v_rdm_statistics_df, eeg_rdm_dist_metric, model_rdm_dist_metric = pd.read_pickle(naive_video_path)\n",
    "p_s_rdm_statistics_df, eeg_rdm_dist_metric, model_rdm_dist_metric = pd.read_pickle(prior_still_path)\n",
    "p_v_rdm_statistics_df, eeg_rdm_dist_metric, model_rdm_dist_metric = pd.read_pickle(prior_video_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Merge all dfs in one df\n",
    "frames = [n_sff_rdm_statistics_df, n_v_rdm_statistics_df, p_s_rdm_statistics_df,p_v_rdm_statistics_df]\n",
    "rdm_df = pd.concat(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def find_significant_rdms(df, alpha=0.001,correct=True):\n",
    "    pos_corr_rdms =  df[df.kendall_tau > 0]\n",
    "    n_test = 1\n",
    "    if correct:\n",
    "        n_test = 400\n",
    "    significant_rdms = pos_corr_rdms[pos_corr_rdms[\"kendall_p-value\"]/2 <= (alpha/n_test)]\n",
    "    return significant_rdms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_experiment_stimuli_comparisons(rdm_df,electrode_region, model_name):\n",
    "    fig = make_subplots(rows=2, cols=2,shared_yaxes=False,\n",
    "    subplot_titles=(\"Naive: Still vs Video\", \"Prior: Still vs Video\", \n",
    "                    \"Still: Naive vs Prior\", \"Video: Naive vs Prior\"))\n",
    "    colors = px.colors.qualitative.Plotly \n",
    "    \n",
    "    variables = ['still', 'video']\n",
    "    constants = ['naive', 'prior']\n",
    "    conditions = [\"naive still\", \"naive video\", \"prior still\", \"prior video\"]\n",
    "    c_no = 0\n",
    "    \n",
    "    # Plots for Naive still vs Naive video, Prior still vs Prior video \n",
    "    for col_no, constant in enumerate(constants):\n",
    "        for variable in variables:\n",
    "            df_to_plot = rdm_df[(rdm_df[\"model_name\"] == model_name) \n",
    "                                & (rdm_df[\"electrode_region\"] == electrode_region)\n",
    "                                & (rdm_df[\"experiment_type\"] == constant) \n",
    "                                & (rdm_df[\"stimulus_type\"] == variable)]\n",
    "            pos_corr = find_significant_rdms(df_to_plot)[\"time\"].tolist()           \n",
    "            # Plots the kendall tau curve\n",
    "            fig.add_trace(go.Scatter(x=df_to_plot[\"time\"],\n",
    "                                    y=df_to_plot[\"kendall_tau\"],\n",
    "                                    legendgroup=constant + \" \" + variable,\n",
    "                                    mode='lines',\n",
    "                                    name=constant + \" \" + variable,\n",
    "                                    line_color = colors[conditions.index(constant + \" \" + variable)]),\n",
    "                                    row=1, col=col_no+1)\n",
    "            \n",
    "            # Plotting the significance points in below the curves\n",
    "            fig.add_trace(go.Scatter(\n",
    "                            mode='markers',\n",
    "                            legendgroup=constant + \" \" + variable,\n",
    "                            name=constant + \" \" + variable,\n",
    "                            x=pos_corr,\n",
    "                            y=[-.1-(c_no*.02) for _ in range(len(pos_corr))],\n",
    "                            marker=dict( size=2,color= colors[conditions.index(constant + \" \" + variable)]),\n",
    "                            showlegend=False),row = 1, col=col_no+1)\n",
    "            \n",
    "            fig.update_yaxes(range=[-0.2, 0.6])\n",
    "            fig.update_yaxes(title_text=\"Kendall-tau\", row=1, col=col_no+1)\n",
    "            fig.update_xaxes(title_text=\"Time ms (relative to stimulus onset)\",  row=1, col=col_no+1)\n",
    "            c_no = c_no+1\n",
    "\n",
    "     # Plots for Prior Still vs Naive Still, Naive video vs Prior video \n",
    "    constants = ['still', 'video']\n",
    "    variables = ['naive','prior']\n",
    "    c_no = 0\n",
    "    for col_no, constant in enumerate(constants):\n",
    "        for  variable in variables:\n",
    "            \n",
    "            df_to_plot = rdm_df[(rdm_df[\"model_name\"] == model_name) \n",
    "                                & (rdm_df[\"electrode_region\"] == electrode_region)\n",
    "                                & (rdm_df[\"experiment_type\"] == variable) \n",
    "                                & (rdm_df[\"stimulus_type\"] == constant)]\n",
    "            pos_corr = find_significant_rdms(df_to_plot)[\"time\"].tolist()   \n",
    "            # Plotting the kendall tau curve\n",
    "            fig.add_trace(go.Scatter(x=df_to_plot[\"time\"],\n",
    "                                    y=df_to_plot[\"kendall_tau\"],\n",
    "                                    mode='lines',\n",
    "                                    legendgroup=variable + \" \" + constant,\n",
    "                                    name= variable + \" \" + constant,\n",
    "                                    line_color = colors[conditions.index(variable + \" \" + constant)]),\n",
    "                                    row=2, col=col_no+1)\n",
    "            \n",
    "            # Significance dots plotting\n",
    "            fig.add_trace(go.Scatter(mode='markers',\n",
    "                            legendgroup=variable + \" \" + constant,\n",
    "                            name=variable + \" \" + constant,\n",
    "                            x=pos_corr,\n",
    "                            y=[-.1-(c_no*.02) for _ in range(len(pos_corr))],\n",
    "                            marker=dict(size=2,color= colors[conditions.index(variable + \" \" + constant)]),\n",
    "                            showlegend=False),row = 2, col=col_no+1)\n",
    "            fig.update_yaxes(range=[-0.2, 0.6])\n",
    "            fig.update_yaxes(title_text=\"Kendall-tau\", row=1, col=col_no+1)\n",
    "            c_no = c_no+1\n",
    "    fig.update_layout(height=1000, width=1700,title=electrode_region + \" \" + model_name,\n",
    "    xaxis_title=\"Time ms (relative to stimulus onset)\",\n",
    "    yaxis_title=\"Kendall-tau\",\n",
    "    font=dict(size=18,color=\"#000000\"))\n",
    "    plotly.offline.plot(fig, filename = \"RSA_Results/new_plots/\"+\n",
    "                        electrode_region + \"_\" + model_name +'_experiment_stimuli_comparison.html', auto_open=False)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For testing only occipital of action category\n",
    "arg_dict = {\"action_category_hamming\":[\"occipital\"]}\n",
    "for model, electrode_region_list in arg_dict.items():\n",
    "    for electrode_region in electrode_region_list:    \n",
    "        plot_experiment_stimuli_comparisons(rdm_df,electrode_region, model)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plots for all models parietal and occipital channels naive, prior x still video\n",
    "arg_dict = {model : [\"parietal\",\"occipital\"] for model in rdm_df[\"model_name\"].unique()   }\n",
    "for model, electrode_region_list in arg_dict.items():\n",
    "    for electrode_region in electrode_region_list:    \n",
    "        plot_experiment_stimuli_comparisons(rdm_df,electrode_region, model)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_channels(model_name=\"biological_appearance_hamming\"):\n",
    "    colors = px.colors.qualitative.Plotly\n",
    "    fig = make_subplots(rows=2, cols=2,shared_yaxes=True,\n",
    "                        subplot_titles=(\"Naive Still \", \"Naive Video\", \n",
    "                                        \"Prior Still\", \"Prior Video\"))\n",
    "    er_list=rdm_df[\"electrode_region\"].unique().tolist()\n",
    "    for row_no, exp_type in enumerate(['naive', 'prior']):\n",
    "        for col_no, stm_type in enumerate(['still', 'video']):\n",
    "                df_of_model = rdm_df[rdm_df[\"model_name\"] == model_name]    \n",
    "                df = df_of_model[(df_of_model[\"experiment_type\"] == exp_type) &\n",
    "                                 (df_of_model[\"stimulus_type\"] == stm_type)]\n",
    "                sig_time={}\n",
    "                # Calculate significance for each electrode\n",
    "                for er in list(df[\"electrode_region\"].unique()):\n",
    "                    sig_time[er] = find_significant_rdms(df[df[\"electrode_region\"] ==  er])[\"time\"].tolist()\n",
    "\n",
    "                for i, er in enumerate(sig_time.keys()):\n",
    "                    if row_no == 0 and col_no == 0:\n",
    "                        df_er = df[df[\"electrode_region\"]==er]\n",
    "                        fig.add_trace(\n",
    "                            go.Scatter(mode='lines',\n",
    "                                x=df_er[\"time\"],\n",
    "                                y=df_er[\"kendall_tau\"], \n",
    "                                line_color=colors[er_list.index(er)],\n",
    "                                legendgroup=er,\n",
    "                            name=er),\n",
    "                            row = row_no+1, col=col_no+1\n",
    "                        )\n",
    "                    else:\n",
    "                        df_er = df[df[\"electrode_region\"]==er]\n",
    "                        fig.add_trace(\n",
    "                            go.Scatter(\n",
    "                                mode='lines',\n",
    "                                x=df_er[\"time\"],\n",
    "                                y=df_er[\"kendall_tau\"], \n",
    "                                line_color=colors[er_list.index(er)],\n",
    "                                legendgroup=er,\n",
    "                                showlegend=False,\n",
    "                            name=er),\n",
    "                            row = row_no+1, col=col_no+1\n",
    "                        )                \n",
    "                    fig.add_trace(\n",
    "                        go.Scatter(\n",
    "                            mode='markers',\n",
    "                            legendgroup=er,\n",
    "                            name=er,\n",
    "                            x=sig_time[er],\n",
    "                            y=[-.1-(i*.02) for _ in range(len(sig_time[er]))],\n",
    "                            marker=dict(\n",
    "                                size=2,\n",
    "                                color= er_list.index(er)),\n",
    "                            showlegend=False),\n",
    "                        row = row_no+1, col=col_no+1\n",
    "                    )\n",
    "                    fig.update_yaxes(range=[-0.2, 0.6])\n",
    "                    fig.update_yaxes(title_text=\"Kendall-tau\", row=row_no+1, col=col_no+1)\n",
    "                    fig.update_xaxes(title_text=\"Time ms (relative to stimulus onset)\",  row=row_no+1, col=col_no+1)\n",
    "    fig.update_layout(\n",
    "        height=1200, width=2000,\n",
    "        title= model_name)\n",
    "    plotly.offline.plot(fig, filename = \"RSA_Results/plots/\"+model_name+'_channel_wise_comparison.html', auto_open=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "for model_name in list(rdm_df[\"model_name\"].unique()):\n",
    "    plot_channels(model_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def model_comparisons(electrode_region=\"parietal\"):\n",
    "    colors = px.colors.qualitative.Plotly\n",
    "    fig = make_subplots(rows=2, cols=2,shared_yaxes=True,\n",
    "                        subplot_titles=(\"Naive Still \", \"Naive Video\",\"Prior Still\", \"Prior Video\"))\n",
    "    models = list(rdm_df[\"model_name\"].unique())\n",
    "    for row_no, exp_type in enumerate(['naive', 'prior']):\n",
    "        for col_no, stm_type in enumerate(['still', 'video']):\n",
    "            df = rdm_df[(rdm_df[\"electrode_region\"] == electrode_region)&\n",
    "                        (rdm_df[\"experiment_type\"] == exp_type)&\n",
    "                        (rdm_df[\"stimulus_type\"] == stm_type)]\n",
    "            for i, model in enumerate(models):\n",
    "                sig_time = {}\n",
    "                df_model = df[df[\"model_name\"]==model]\n",
    "                sig_time[model] = find_significant_rdms(df_model)[\"time\"].tolist()\n",
    "                fig.add_trace(\n",
    "                    go.Scatter(mode='lines',\n",
    "                        x=df_model[\"time\"],\n",
    "                        y=df_model[\"kendall_tau\"], \n",
    "                        line_color=colors[models.index(model)],\n",
    "                        legendgroup=model,name=model),\n",
    "                    row = row_no+1, col=col_no+1\n",
    "                ) \n",
    "                fig.add_trace(\n",
    "                    go.Scatter(\n",
    "                        mode='markers',\n",
    "                        legendgroup=model,\n",
    "                        name=model,\n",
    "                        x=sig_time[model],\n",
    "                        y=[-.1-(i*.02) for _ in range(len(sig_time[model]))],\n",
    "                        marker=dict(size=2,color= colors[models.index(model)]),showlegend=False),row = row_no+1, col=col_no+1)\n",
    "                fig.update_yaxes(range=[-0.5, 0.8])\n",
    "                fig.update_yaxes(title_text=\"Kendall-tau\", row=row_no+1, col=col_no+1)\n",
    "                fig.update_xaxes(title_text=\"Time ms (relative to stimulus onset)\",  row=row_no+1, col=col_no+1)\n",
    "        fig.update_layout(height=1200, width=2000,title= electrode_region)\n",
    "        plotly.offline.plot(fig, filename = \"RSA_Results/test_plots/\"+electrode_region+'_model_comparison.html', auto_open=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for electrode_region in list(rdm_df[\"electrode_region\"].unique()):\n",
    "    model_comparisons(electrode_region)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# TODO: Add saving, change figure names axes information etc when necessary\n",
    "# Plot seperated subjects figure (line graph for each subject)\n",
    "def plot_seperated_subjects(seperated_subjects_dataframe, model_name, electrode_region):\n",
    "    colors = px.colors.qualitative.Dark24\n",
    "    subjects = list(seperated_subjects_data[\"subject_no\"].unique())\n",
    "    fig = make_subplots(rows=2, cols=2,shared_yaxes=False,\n",
    "                        subplot_titles=(\"Naive Still \", \"Naive Video\", \n",
    "                                        \"Prior Still\", \"Prior Video\"))\n",
    "    for row_no, exp_type in enumerate(['naive', 'prior']):\n",
    "        for col_no, stm_type in enumerate(['still-mf', 'video']):\n",
    "            color_no=0\n",
    "            df_to_plot = seperated_subjects_dataframe[(seperated_subjects_dataframe[\"experiment_type\"] == exp_type) &\n",
    "            (seperated_subjects_dataframe[\"stimulus_type\"] == stm_type)&\n",
    "            (seperated_subjects_dataframe[\"model_name\"] == model_name)&\n",
    "            (seperated_subjects_dataframe[\"electrode_region\"] == electrode_region)]\n",
    "            \n",
    "            for subject in subjects:\n",
    "                fig.add_trace(go.Scatter(x=df_to_plot[df_to_plot[\"subject_no\"]==subject][\"time\"],\n",
    "                        y=df_to_plot[df_to_plot[\"subject_no\"]==subject][\"kendall_tau\"],\n",
    "                        mode=\"lines\",\n",
    "                        name=\"Subject\" +str(subject),\n",
    "                        line_color=colors[color_no],\n",
    "                        legendgroup=str(subject)),\n",
    "                        row = row_no+1, col=col_no+1) \n",
    "                color_no = color_no + 1        \n",
    "    fig.update_layout(\n",
    "        height=1000, width=1000,\n",
    "        title= model_name + electrode_region)                \n",
    "    fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_seperated_subjects(seperated_subjects_data,\"agent_hamming\",\"occipital\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load Naive Video RDMs for occipital region\n",
    "          \n",
    "windowed_eeg_rdm_dict_n_v = {}\n",
    "with h5py.File(\"/Users/huseyinelmas/Desktop/CCN-Lab/CCN-RSA/RSA_Results/Naive\"+\n",
    "               \"/Video/eegRDMs/eeg_rdm_naive_video_occipital_2_correlation.hdf5\", \"r\") as f:\n",
    "    attributes = list(f.attrs.items())\n",
    "    for key in list(f.keys()):\n",
    "          windowed_eeg_rdm_dict_n_v[tuple(map(int, key[1:-1].split(',')))] = np.asarray(f[key][\"rdm\"])\n",
    "\n",
    "# Load Prior Video RDMs for occipital region\n",
    "windowed_eeg_rdm_dict_p_v = {}\n",
    "with h5py.File(\"/Users/huseyinelmas/Desktop/CCN-Lab/CCN-RSA/RSA_Results/Prior\"+\n",
    "               \"/Video/eegRDMs/eeg_rdm_prior_video_occipital_2_correlation.hdf5\", \"r\") as f:\n",
    "    attributes = list(f.attrs.items())\n",
    "    for key in list(f.keys()):\n",
    "          windowed_eeg_rdm_dict_p_v[tuple(map(int, key[1:-1].split(',')))] = np.asarray(f[key][\"rdm\"])\n",
    "            \n",
    "# Load Prior Still RDMs for occipital region\n",
    "windowed_eeg_rdm_dict_p_s = {}\n",
    "with h5py.File(\"/Users/huseyinelmas/Desktop/CCN-Lab/CCN-RSA/RSA_Results/Prior\"+\n",
    "               \"/Still/eegRDMs/eeg_rdm_prior_still-ff_occipital_2_correlation.hdf5\", \"r\") as f:\n",
    "    attributes = list(f.attrs.items())\n",
    "    for key in list(f.keys()):\n",
    "          windowed_eeg_rdm_dict_p_s[tuple(map(int, key[1:-1].split(',')))] = np.asarray(f[key][\"rdm\"])\n",
    "\n",
    "# Load Naive Still RDMs for occipital region\n",
    "# TODO: add Naive still middle frame and first frame support\n",
    "windowed_eeg_rdm_dict_n_sff = {}\n",
    "with h5py.File(\"/Users/huseyinelmas/Desktop/CCN-Lab/CCN-RSA/RSA_Results/Naive\"+\n",
    "               \"/Still_FF/eegRDMs/eeg_rdm_naive_still-ff_occipital_2_correlation.hdf5\", \"r\") as f:\n",
    "    attributes = list(f.attrs.items())\n",
    "    for key in list(f.keys()):\n",
    "          windowed_eeg_rdm_dict_n_sff[tuple(map(int, key[1:-1].split(',')))] = np.asarray(f[key][\"rdm\"])\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "stimuli =[\"robot-drink\",\"robot-grasp\",\"robot-handwave\",\"robot-talk\",\"robot-nudge\",\n",
    "        \"robot-paper\",\"robot-turn\",\"robot-wipe\",\"android-drink\",\"android-grasp\",\"android-handwave\",\n",
    "        \"android-talk\",\"android-nudge\",\"android-paper\",\"android-turn\",\"android-wipe\",\"human-drink\",\n",
    "        \"human-grasp\",\"human-handwave\",\"human-talk\",\"human-nudge\",\"human-paper\",\"human-turn\",\"human-wipe\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plots rdms as heatpmap and returns the image\n",
    "def plot_rdm_heatmap(RDM,subject,time_window):\n",
    "    fig, ax = plt.subplots(figsize=(10,5))\n",
    "    img=ax.imshow(squareform(RDM), interpolation='nearest')\n",
    "    ax.set(title='EEG rdm of subject ' + str(subject) + ' at time window ' + str(2*(time_window[0]-100)))    # Used to return the plot as an image rray\n",
    "    ax.set_xticks(np.arange(len(stimuli)))\n",
    "    ax.set_yticks(np.arange(len(stimuli)))\n",
    "    # ... and label them with the respective list entries\n",
    "    ax.set_xticklabels(stimuli)\n",
    "    ax.set_yticklabels(stimuli)\n",
    "    for tick in ax.get_xticklabels():\n",
    "        tick.set_rotation(90)\n",
    "    fig.colorbar(img)\n",
    "    fig.canvas.draw()       # draw the canvas, cache the renderer\n",
    "    image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\n",
    "    image  = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n",
    "    return image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'imageio' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-99-1b245d02c533>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mkwargs_write\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m'fps'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'quantizer'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m'nq'\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"still_subject_\"\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msubject\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m\"_EEG_RDM\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m imageio.mimsave('./' + name +'.gif', [plot_rdm_heatmap(windowed_eeg_rdm_dict[(start_time,start_time+1)][subject]\n\u001b[0m\u001b[1;32m      7\u001b[0m                                 ,subject, (start_time,start_time+1))\n\u001b[1;32m      8\u001b[0m                                  for start_time in range(len(windowed_eeg_rdm_dict.keys()))], fps=4)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'imageio' is not defined"
     ]
    }
   ],
   "source": [
    "# Given a subject, converts the heatmaps to a gif\n",
    "# TODOO: check this\n",
    "subject=0\n",
    "kwargs_write = {'fps':4, 'quantizer':'nq'}\n",
    "name = \"still_subject_\"+str(subject)+\"_EEG_RDM\"\n",
    "imageio.mimsave('./' + name +'.gif', [plot_rdm_heatmap(windowed_eeg_rdm_dict[(start_time,start_time+1)][subject]\n",
    "                                ,subject, (start_time,start_time+1))\n",
    "                                 for start_time in range(len(windowed_eeg_rdm_dict.keys()))], fps=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "rdm_avg_df = rdm_df\n",
    "# TODO: debug wasnt working on prior\n",
    "# Finds the start and end times of significane by if significance continues looking at 5 ahead and 5 behind indices\n",
    "# TODO: get time window from argument or smth\n",
    "time_window = 2\n",
    "def inner(df_sorted):\n",
    "    start_times=[]\n",
    "    end_times=[]\n",
    "    i = 0\n",
    "    while i < df_sorted.shape[0]:\n",
    "        j = 0\n",
    "        sig_len = 0\n",
    "        while i+j+1 < df_sorted.shape[0] and df_sorted.iloc[i+j+1].time == df_sorted.iloc[i+j].time+time_window:\n",
    "            j += 1\n",
    "            sig_len +=1\n",
    "        if sig_len>5:\n",
    "            start_times.append(df_sorted.iloc[i].time) \n",
    "            end_times.append(df_sorted.iloc[i+sig_len].time)\n",
    "            i += sig_len\n",
    "        else:\n",
    "            i = i + 1\n",
    "    return start_times, end_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Plot max significant points in all conditions\n",
    "# TODO: Debug prior there was a problem\n",
    "# TODO: Add support for mf and ff\n",
    "# TODO: After debugging turn into function\n",
    "er=\"occipital\"\n",
    "model=\"agent_hamming\"\n",
    "start_time=0\n",
    "# Create mean kendall tau dataframes for naive, prior x still, video \n",
    "df_n_s = rdm_avg_df[(rdm_avg_df.electrode_region == er) & (rdm_avg_df.experiment_type==\"naive\")&\n",
    "       (rdm_avg_df.model_name==model) & (rdm_avg_df.stimulus_type==\"still-ff\")].set_index(\"time\")[[\"kendall_tau\",\"kendall_p-value\"]] \n",
    "df_n_v = rdm_avg_df[(rdm_avg_df.electrode_region == er) & (rdm_avg_df.experiment_type==\"naive\")&\n",
    "       (rdm_avg_df.model_name==model) & (rdm_avg_df.stimulus_type==\"video\")].set_index(\"time\")[[\"kendall_tau\",\"kendall_p-value\"]]\n",
    "df_p_s = rdm_avg_df[(rdm_avg_df.electrode_region == er) & (rdm_avg_df.experiment_type==\"prior\")&\n",
    "       (rdm_avg_df.model_name==model) & (rdm_avg_df.stimulus_type==\"still-ff\")].set_index(\"time\")[[\"kendall_tau\",\"kendall_p-value\"]] \n",
    "df_p_v = rdm_avg_df[(rdm_avg_df.electrode_region == er) & (rdm_avg_df.experiment_type==\"prior\")&\n",
    "       (rdm_avg_df.model_name==model) & (rdm_avg_df.stimulus_type==\"video\")].set_index(\"time\")[[\"kendall_tau\",\"kendall_p-value\"]]\n",
    "\n",
    "\n",
    "# Find significance\n",
    "pos_corr_n_s = find_significant_rdms(rdm_avg_df[(rdm_avg_df.electrode_region == er) & (rdm_avg_df.experiment_type==\"naive\")&\n",
    "       (rdm_avg_df.model_name==model) & (rdm_avg_df.stimulus_type==\"still-ff\")].sort_values(by=\"time\"))\n",
    "pos_corr_n_v = find_significant_rdms(rdm_avg_df[(rdm_avg_df.electrode_region == er) & (rdm_avg_df.experiment_type==\"naive\")&\n",
    "       (rdm_avg_df.model_name==model) & (rdm_avg_df.stimulus_type==\"video\")].sort_values(by=\"time\"))\n",
    "pos_corr_p_s = find_significant_rdms(rdm_avg_df[(rdm_avg_df.electrode_region == er) & (rdm_avg_df.experiment_type==\"prior\")&\n",
    "       (rdm_avg_df.model_name==model) & (rdm_avg_df.stimulus_type==\"still-ff\")].sort_values(by=\"time\"))\n",
    "pos_corr_p_v = find_significant_rdms(rdm_avg_df[(rdm_avg_df.electrode_region == er) &(rdm_avg_df.experiment_type==\"prior\")&\n",
    "       (rdm_avg_df.model_name==model) & (rdm_avg_df.stimulus_type==\"video\")].sort_values(by=\"time\"))\n",
    "\n",
    "start_times_ns,end_times_ns = inner(pos_corr_n_s)\n",
    "start_times_nv,end_times_nv = inner(pos_corr_n_v)\n",
    "start_times_pv,end_times_pv = inner(pos_corr_p_v)\n",
    "start_times_ps,end_times_ps = inner(pos_corr_p_s)\n",
    "\n",
    "max_ns_time = []\n",
    "max_nv_time = []\n",
    "\n",
    "max_ps_time = []\n",
    "max_pv_time = []\n",
    "\n",
    "\n",
    "\n",
    "# Find max RDMs of these windows for ns\n",
    "for i,start_time in enumerate(start_times_ns):\n",
    "    end_time = end_times_ns[i]\n",
    "    max_ns_time.append(df_n_s.loc[start_time:end_time, 'kendall_tau'].idxmax())\n",
    "\n",
    "# Find max RDMs of these windows for nv\n",
    "for i,start_time in enumerate(start_times_nv):\n",
    "    end_time = end_times_nv[i]\n",
    "    max_nv_time.append(df_n_v.loc[start_time:end_time, 'kendall_tau'].idxmax())\n",
    "\n",
    "# Find max RDMs of these windows for ps\n",
    "for i,start_time in enumerate(start_times_ps):\n",
    "    end_time = end_times_ps[i]\n",
    "    max_ps_time.append(df_p_s.loc[start_time:end_time, 'kendall_tau'].idxmax())\n",
    "    \n",
    "# Find max RDMs of these windows for nv\n",
    "for i,start_time in enumerate(start_times_pv):\n",
    "    end_time = end_times_pv[i]\n",
    "    max_pv_time.append(df_p_v.loc[start_time:end_time, 'kendall_tau'].idxmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_ps_start_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# Calculate Start index from start tie\n",
    "fig = plt.figure(constrained_layout=True,figsize=(20,20))\n",
    "gs = fig.add_gridspec(5, max(len(max_nv_time),len(max_ns_time),len(max_pv_time),len(max_pv_time)))\n",
    "f_ax1 = fig.add_subplot(gs[0, :])\n",
    " \n",
    "# Mark significcant points\n",
    "f_ax1.scatter(pos_corr_n_s.time.values.tolist(),[-0.1]*len(pos_corr_n_s.time.values.tolist()),c=\"b\")\n",
    "f_ax1.scatter(pos_corr_n_v.time.values.tolist(),[-0.15]*len(pos_corr_n_v.time.values.tolist()),c=\"g\")\n",
    "f_ax1.scatter(pos_corr_p_s.time.values.tolist(),[-0.2]*len(pos_corr_p_s.time.values.tolist()),c=\"r\")\n",
    "f_ax1.scatter(pos_corr_p_v.time.values.tolist(),[-0.25]*len(pos_corr_p_v.time.values.tolist()),c=\"c\")\n",
    "f_ax1.plot(df_n_s.kendall_tau,'-bD',markevery=[int(x/2+100) for x in max_ns_time],label=\"Naive Still\")\n",
    "f_ax1.plot(df_n_v.kendall_tau,'-gD',markevery=[int(x/2+100) for x in max_nv_time], label=\"Naive Video\")\n",
    "f_ax1.plot(df_p_s.kendall_tau,'-rD',markevery=[int(x/2+100) for x in max_ps_time], label=\"Prior Still\")\n",
    "f_ax1.plot(df_p_v.kendall_tau,'-cD',markevery=[int(x/2+100) for x in max_pv_time], label=\"Prior Video\")\n",
    "\n",
    "\n",
    "f_ax1.set_title('Naive Still mean RDM with model ' + model + \"on electrode region \" + er)\n",
    "f_ax1.legend()\n",
    "\n",
    "for i,max_ns_start_time in enumerate(max_ns_time):\n",
    "    ax = fig.add_subplot(gs[1, i])\n",
    "    RDM_n_s = np.mean(windowed_eeg_rdm_dict_n_sff[(max_ns_start_time,max_ns_start_time+time_window)],0)\n",
    "    ax.imshow(squareform(RDM_n_s))\n",
    "    ax.set_title(\"Naive Still EEG RDM at: \" + str(max_ns_start_time))\n",
    "    \n",
    "    \n",
    "for i,max_nv_start_time in enumerate(max_nv_time):\n",
    "    ax = fig.add_subplot(gs[2, i])\n",
    "    RDM_n_v = np.mean(windowed_eeg_rdm_dict_n_v[(max_nv_start_time,max_nv_start_time+time_window)],0)\n",
    "    ax.imshow(squareform(RDM_n_v))\n",
    "    ax.set_title(\"Naive Video EEG RDM at: \" + str(max_nv_start_time))\n",
    "    \n",
    "    \n",
    "for i,max_ps_start_time in enumerate(max_ps_time):\n",
    "    ax = fig.add_subplot(gs[3, i])\n",
    "    RDM_p_s = np.mean(windowed_eeg_rdm_dict_p_s[(max_ps_start_time,max_ps_start_time+time_window)],0)\n",
    "    ax.imshow(squareform(RDM_p_s))\n",
    "    ax.set_title(\"Prior Still EEG RDM at: \" + str(max_ps_start_time))\n",
    "    \n",
    "    \n",
    "for i,max_pv_start_time in enumerate(max_pv_time):\n",
    "    ax = fig.add_subplot(gs[4, i])\n",
    "    RDM_p_v = np.mean(windowed_eeg_rdm_dict_p_v[(max_pv_start_time,max_pv_start_time+time_window)],0)\n",
    "    ax.imshow(squareform(RDM_n_v))\n",
    "    ax.set_title(\"Prior Video EEG RDM at: \" + str(max_pv_start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "RDM_n_s = np.mean(windowed_eeg_rdm_dict_n_sff[(max_ns_start_time,max_ns_start_time+time_window)],0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "282"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_ns_start_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}