{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Across-trials testing with [GLHMM toolbox](https://github.com/vidaurre/glhmm)\n", "In this tutorial, we explore how to implement across-trials testing using the [GLHMMS toolbox](https://github.com/vidaurre/glhmm), part of the paper [The Gaussian-Linear Hidden Markov Model: a Python Package](https://direct.mit.edu/imag/article/doi/10.1162/imag_a_00460/127499/The-Gaussian-Linear-Hidden-Markov-model-a-Python). This test is designed to assess differences between trials within one or more experimental sessions, making it ideal for analyzing trial-by-trial variability within a session.\n", "\n", "In real-world scenarios, one would typically fit a Hidden Markov Model (HMM) to actual data. However, for the purpose of illustrating the statistical testing concept, we use synthetic data for both the brain data ($D$) and the behavioural data ($R$) in the ```across_trials_within_session``` test. For this demonstration, we specifically use a time-delayed embedding HMM (TDE-HMM), showcasing its application within the testing framework.\n", "\n", "The synthetic data is generated using the toolbox [Genephys](https://github.com/vidaurre/genephys), developed by [Vidaurre in 2023](https://elifesciences.org/reviewed-preprints/87729). Genephys enables the simulation of electrophysiological data within the context of psychometric experiments. It can create scenarios where a subject is exposed to one or multiple stimuli while recording EEG or MEG data.\n", "\n", "For this tutorial:\n", "\n", "* The Brain data ($D$) simulates EEG or MEG recordings with 16 channels, measured across multiple trials and sessions. Each trial consists of 250 timepoints.\n", "* The behavioural data ($R$) marks when a subject observes different types of stimuli, such as animate versus inanimate objects.\n", "This setup gives a detailed analysis of how brain activity patterns vary across stimulus conditions and trials.\n", "\n", "\n", "While data preparation requires some explanation, running the ```across_trials_within_session``` test is straightforward. Simply provide the input variables ($D$ and $R$) and specify the method for the analysis.\n", "\n", "**Note:** Due to rendering issues when viewing this notebook through github, internal links, like the table of contents, may not work correctly. To ensure that the notebook renders correctly, you can view it through [this link](https://nbviewer.org/github/vidaurre/glhmm/blob/main/docs/notebooks/Testing_across_trials_within_session.ipynb).\n", "\n", "Authors: Nick Yao Larsen \n", "\n", "\n", "## Table of Contents\n", "1. [Load and prepare data](#load-data)\n", " * [Look at data](#look-data)\n", " * [Prepare data for HMM](#prep_hmm)\n", "2. [Load or initialise and train TDE-HMM](#load_hmm)\n", " * [Data restructuring](#data-recon)\n", "3. [Across-trials within session testing](#across_trials)\n", " * [Across-trials within sessions testing - Multivariate](#perm-regression)\n", " * [Across-trials within sessions testing - Univariate](#perm-correlation)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Install necessary packages\n", "If you dont have the **GLHMM-package** installed, then run the following command in your terminal:\n", "\n", "```pip install git+https://github.com/vidaurre/glhmm```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Import libraries\n", "Let's start by importing the required libraries and modules." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from pathlib import Path\n", "from glhmm import glhmm, graphics, preproc, statistics, auxiliary, io" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Load and prepare data \n", "First, we'll load the synthetic data from this [folder](https://github.com/vidaurre/glhmm/tree/main/docs/notebooks/data_statistical_testing) and use the [GLHMM toolbox](https://github.com/vidaurre/glhmm) to train a classic HMM on the synthetic data that represents EEG or MEG measurements.\\\n", "Let's start by loading the essential data for this tutorial:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data dimension of D-session data: (250, 1421, 16)\n", "Data dimension of R-session data: (1421,)\n", "Data dimension of indices for the number of trials for each session: (10, 2)\n", "Data dimension of indices: (1421, 2)\n" ] } ], "source": [ "# Get the current directory\n", "PATH_PARENT = Path.cwd()\n", "# Path of the location of the data\n", "PATH_DATA = PATH_PARENT / \"data_statistical_testing\"\n", "\n", "# Load D data\n", "D_trials = np.load(PATH_DATA/\"D_trials.npy\")\n", "# Load R data\n", "R_trials = np.load(PATH_DATA/\"R_trials.npy\")\n", "# Load indices\n", "idx_trials_session = np.load(PATH_DATA/\"idx_trials_session.npy\")\n", "# Load indices\n", "idx_trials = np.load(PATH_DATA/\"idx_trials.npy\")\n", "\n", "\n", "print(f\"Data dimension of D-session data: {D_trials.shape}\")\n", "print(f\"Data dimension of R-session data: {R_trials.shape}\")\n", "print(f\"Data dimension of indices for the number of trials for each session: {idx_trials_session.shape}\")\n", "print(f\"Data dimension of indices: {idx_trials.shape}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Look at data \n", "Now we can look at the data structure.\n", "- D_sessions: 3D array of shape (n_timepoints, n_trials, n_features)\n", "- R_sessions: 3D array of shape (n_trials,)\n", "- idx_trials_session: 2D array of shape (n_sessions, 2)\n", "- idx_trials: 2D array of shape (n_trials, 2)\n", "\n", "```D_sessions``` represents the data collected from the subject, structured as a list with three elements: ```[250, 1421, 16]```. The first element indicates that the subject underwent measurement across 250 timepoints. The second element, 1421 corresponds to the total number of trials conducted. In this context, 10 distinct sessions were executed, each comprising 150 trials, lead up to a total of 1421 trials (150*10). Each individual trial involved the measurement of 16 channels within the EEG or MEG scanner.\n", "\n", "```R_sessions``` categorial values of when a stimulus is prestented. It contain values of 1 and 2. \n", "\n", "```idx_trials_session.shape = [10, 2]``` shows the indices for the number of sessions conducted, which in this case is 10 The values in each row represent the indices for the first and last trial for a given session. As you can see the number of trials are different from each session.\n", "```python\n", "np.diff(idx_trials_session)\n", "array([[129],\n", " [132],\n", " [150],\n", " [150],\n", " [150],\n", " [150],\n", " [150],\n", " [150],\n", " [111],\n", " [149]])\n", "```\n", "\n", "\n", "Lastly, we have ```idx_trials.shape = [1421, 2]```, which marks the number of trials conducted, which in this case is 1421 The values in each row represent the start and end indices for every trial. Having this index to seperate the time period for each trial is required when training a time-delay embedded HMM (TDE-HMM)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Prepare data for HMM \n", "When training a HMM, the input data must follow a specific format. The data should be organized as ((number of timepoints * number of trials), number of features). This means trials from different sessions are combined into one row. The second element represents the features, such as parcels or channels.\n", "\n", "In our case, the initial data matrix, ```D_session```, has the shape ```[250, 1421, 16]``` (n_timepoints, n_trials, n_channels). After combining all trials, the matrix becomes ```[355250, 16]``` (timepoints * trials, channels). \n", "\n", "To align everything, ```R_session``` and ```idx_trials_session``` also need to be updated to match the concatenated data. The function ```get_concatenate_sessions``` automates this process by handling the trial-by-trial concatenation for each session.\n", "\n", "**Note: it is important to use ```idx_trials_session``` for this function as the concatenation is done trial-by-trial basis for every defined session.**" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data dimension of the concatenated D-data: (355250, 16)\n", "Data dimension of the concatenated R-data: (355250,)\n", "Data dimension of the updated time stamp indices: (10, 2)\n" ] } ], "source": [ "D_con,R_con,idx_con=statistics.get_concatenate_sessions(D_trials, R_trials, idx_trials_session)\n", "print(f\"Data dimension of the concatenated D-data: {D_con.shape}\")\n", "print(f\"Data dimension of the concatenated R-data: {R_con.shape}\")\n", "print(f\"Data dimension of the updated time stamp indices: {idx_con.shape}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For a quick sanity check, let's verify whether the concatenation was performed correctly on ```D_trials```. We've essentially stacked up every timepoint from each trial sequentially.\n", "\n", "To do this, we can compare a slice of our original design matrix, say ```D_trials[:, 0, :]```, with the corresponding slice in the concatenated data, ```D_con[0:250, :]```.\\\n", "If the comparison ```D_trials[:, 0, :] == D_con[0:250, :]``` holds true, we're essentially confirming that all timepoints in the first trial align perfectly with the first 250 values in our concatenated data. It's like double-checking to make sure everything lined up as expected." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.array_equal(D_trials[:, 0, :], D_con[0:250, :])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, it's evident that the concatenation process has been executed accurately.\n", "\n", "Next up, let's confirm if the values in ```idx_con``` have been appropriately updated. Each row in this matrix should represent the total count of timepoints and trials for each of the 10 sessions. " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 32250],\n", " [ 32250, 65250],\n", " [ 65250, 102750],\n", " [102750, 140250],\n", " [140250, 177750],\n", " [177750, 215250],\n", " [215250, 252750],\n", " [252750, 290250],\n", " [290250, 318000],\n", " [318000, 355250]], dtype=int32)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idx_con" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Indeed, each session now aligns with the number of datapoints. This means that when we pooled together the timepoints and trials, the count for each session ended up exactly as expected. It's a reassuring confirmation that our concatenation didn't miss a beat." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**NOTE: It is important to standardise your timeseries and, if necessary, apply other kinds of preprocessing before fitting the model.**\\\n", "This will be done separately for each session/subject as specified in the indices. The data provided here are already close to standardised (so the code below will not do much)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Load data or initialise and train TDE-HMM \n", "You can either load the ```Gamma``` values from a pretrained model or train your own model. If you prefer the former option, load the data (```Gamma_trials_tde```) from the [data_statistical_testing](https://github.com/vidaurre/glhmm/tree/main/docs/notebooks/data_statistical_testing) folder. In this example we have trained a time-delay embedded HMM (TDE-HMM), incorporating mean and covariance parameters for 6 distinct states.\n", "TDE-HMM calculates the covariance and then compares the covariance at different time points. If the covariances are similar, the time points are assigned to the same state; otherwise, they are assigned to different states.\n", "\n", "If you decide to train your own TDE-HMM model, you need to prepare the dataset by adding lags that act like a sliding window. These lags capture temporal dependencies in the data and span from -n to n, passing through zero. The code below shows how to define such lags:\n", "\n", "Once the dataset is appropriately prepared, you can proceed with training the TDE-HMM." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7]\n" ] } ], "source": [ "# Define the number of lags (Window size)\n", "lag_val =list(range(-7, 8, 1))\n", "print(lag_val)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**NOTE: It is important to standardise your timeseries and, if necessary, apply other kinds of preprocessing before fitting the model.**\\\n", "This will be done separately for each session/subject as specified in the indices. The data provided here are already close to standardised (so the code below will not do much). " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "D_con_preproc,_ = preproc.preprocess_data(D_con, idx_con, standardise=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now prepare the dataset by using the following function ```preproc.build_data_tde```, so it is ready for the TDE-HMM.\\\n", "The inputs will be the concatenated data (```D_con```), the indices that defines the running period for each trial (```idx_trials```) of the concatenated data, and the lag kernel (```lag_val```) that will run over each trial." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Prepare the dataset for TDE-HMM\n", "D_con_tde,idx_tde = preproc.build_data_tde(D_con_preproc, idx_trials,lag_val)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data dimension of the concatenated TDE D-data: (335356, 240)\n", "Data dimension of the updated TDE time stamp indices: (1421, 2)\n" ] } ], "source": [ "print(f\"Data dimension of the concatenated TDE D-data: {D_con_tde.shape}\")\n", "print(f\"Data dimension of the updated TDE time stamp indices: {idx_tde.shape}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "The dimensions of the concatenated data (```D_con```) changed from [355250, 16] to [335356, 240] (```D_con_tde```) after applying the lag kernel.\n", "\n", "This change is due to the defined lag kernel, which ranges from `-7` to `7`. The kernel excludes 7 data points from both the start and end of each trial, reducing the trial length from 250 time points to 236 (`250 - 14`).\n", "\n", "With 1421 trials, the original data had `1421 * 250 = 355250` data points. After applying the lag kernel, the total is `1421 * 236 = 335356`, as seen in `D_con_tde`.\n", "\n", "The `idx_tde` values confirm this adjustment, showing that each trial now spans 236 points, consistent with the removal of 7 data points from both ends based on the defined `lag_val`.\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 236],\n", " [ 236, 472],\n", " [ 472, 708],\n", " ...,\n", " [334648, 334884],\n", " [334884, 335120],\n", " [335120, 335356]])" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Look at idx_tde\n", "idx_tde" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Initialize HMM-TDE \n", "If you want to train your own HMM-TDE you need to do the following steps. First, we need to initialize the ```hmm``` object and set the hyperparameters according to our modeling preferences.\n", "\n", "In this case, we choose not to model an interaction between two sets of variables in the HMM states, so we set ```model_beta='no'```. For our estimation, we choose ```K=6``` states. If you wish to model a different number of states, simply adjust the value of ```K```.\n", "\n", "Our modeling approach involves representing states as Gaussian distributions with mean and a full covariance matrix. This means that each state is characterized by a mean amplitude and a functional connectivity pattern. To specify this configuration, set ```covtype='full'```. If you prefer not to model the mean, you can include ```model_mean='no'```. Optionally, you can check the hyperparameters to make sure that they correspond to how you want the model to be set up." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'K': 6, 'covtype': 'full', 'model_mean': 'state', 'model_beta': 'no', 'dirichlet_diag': 10, 'connectivity': None, 'Pstructure': array([[ True, True, True, True, True, True],\n", " [ True, True, True, True, True, True],\n", " [ True, True, True, True, True, True],\n", " [ True, True, True, True, True, True],\n", " [ True, True, True, True, True, True],\n", " [ True, True, True, True, True, True]]), 'Pistructure': array([ True, True, True, True, True, True])}\n" ] } ], "source": [ "# Create an instance of the glhmm class\n", "K = 6 # number of states\n", "hmm = glhmm.glhmm(model_beta='no', K=K, covtype='full')\n", "print(hmm.hyperparameters)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Train an HMM \n", "Now, let's proceed to train the TDE-HMM using the data (```D_con_tde```) and time indices (```idx_tde```).\n", "\n", "Since in this case, we are not modeling an interaction between two sets of timeseries but opting for a \"classic\" HMM, we set ```X=None```. For training, ```Y``` should represent the timeseries from which we aim to estimate states (```D_con_tde```), and indices should encompass the beginning and end indices of each subject (```idx_tde```).\n", "\n", "If you want to use the same Gamma values as used in this tutorial without training the HMM, you can just load ```Gamma_tde``` using the code below:\n", "```python\n", "# Get the current directory\n", "PATH_PARENT = Path.cwd()\n", "# Path of the location of the data\n", "PATH_DATA = PATH_PARENT / \"data_statistical_testing\"\n", "# Load Gamma data\n", "Gamma_tde = np.load(PATH_DATA/\"Gamma_trials_tde.npy\")\n", "print(f\"Data dimension of Gamma-TDE: {Gamma_tde.shape}\")\n", "\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Gamma_tde,Xi,FE = hmm.train(X=None, Y=D_con_tde, indices=idx_tde)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, checking out ```Gamma```, you'll see it's got the same number of points as the concatenated dataset (335356 ). Each column in Gamma stands for one of the six different states." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(335356, 6)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Gamma_tde.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Reconstruct the shape of Gamma**\\\n", "To reshape Gamma back to match the original dataset, we will pad the data using the auxiliary.padGamma function. This function requires three inputs: ```Gamma```, ```T```, and ```option```.\n", "\n", "* ```Gamma```: The state probabilities obtained from the TDE-HMM.\n", "* ```T```: The original number of data points per trial, restored from 236 to 250. This can be computed using the ```auxiliary.get_T``` function, which takes the original indices idx_trials as input.\n", "* ```option```: A dictionary specifying additional parameters. Since lags are used here, the key is \"embeddedlags\", and the value is the variable lag_val.\n", "\n", "This process restores Gamma to align with the original trial structure, making it ready for further analysis." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# Get T\n", "T = auxiliary.get_T(idx_trials)\n", "# Define options\n", "options ={'embeddedlags':lag_val}\n", "Gamma =auxiliary.padGamma(Gamma_tde,\n", " T,\n", " options=options)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Look at Gamma" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((355250, 6), (355250, 16))" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Look at shape for Gamma and D_con\n", "Gamma.shape, D_con.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, you'll notice that the number of data points in both ```Gamma``` and ```D_con``` are back in sync.\n", "\n", "Taking a closer look at the padding for the initial trial in state 1, you can observe that padding has been applied to the first 7 data points and the last 7 data points.\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(array([0.229, 0.229, 0.229, 0.229, 0.229, 0.229, 0.229, 0. , 0. ,\n", " 0. ]),\n", " array([0.607, 0.775, 0.783, 0.229, 0.229, 0.229, 0.229, 0.229, 0.229,\n", " 0.229]))" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# As we can see the padding works, since the first and last 7 numbers\n", "# has been added to the timepoints for every trial\n", "Gamma[:10,0].round(3),Gamma[240:250,0].round(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data Restructuring \n", "\n", "After training the HMM and obtaining the `Gamma` values, we need to restructure the data back to its original format. Instead of performing HMM-aggregated statistics, this tutorial focuses on statistical testing at each time point.\n", "\n", "To achieve this, we use the `reconstruct_concatenated_to_3D` function. This function converts a concatenated 2D matrix into a 3D matrix. Specifically, it reshapes `Gamma` from `[355250, 6]` to `[250, 1421, 6]` (timepoints, trials, states).\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(250, 1421, 6)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Reconstruct the Gamma matrix\n", "n_timepoints, n_trials, n_channels = D_trials.shape[0], D_trials.shape[1], Gamma.shape[1]\n", "Gamma_epoch = statistics.reconstruct_concatenated_to_3D(Gamma,\n", " n_timepoints=n_timepoints, \n", " n_entities=n_trials, \n", " n_features=n_channels)\n", "Gamma_epoch.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a sanity check this tutorial will see if ```Gamma_epoch``` is actually structured correctly by comparing it with ```Gamma```.\n", "\n", "To do this, we can compare a slice of our 3D-matrix, like ```Gamma_epoch[:, 0, :]```, with the corresponding slice in the concatenated 2D-data, ```Gamma[0:250, :]```.\\\n", "If the comparison ```Gamma_epoch[:, 0, :] == Gamma[0:250, :]``` holds true, we're essentially confirming that all timepoints in the first trial align perfectly with the first 250 values in our concatenated data. \n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.array_equal(Gamma_epoch[:, 0, :], Gamma[0:250, :])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What we can see here is that all the values are **True** and we therefore know that the restructuring is performed correctly. " ] }, { "attachments": { "image.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Across-trials testing \n", "As we move on to the next part of this tutorial, let's dive into how we can use the ```across_trials_within_subject``` function.\n", "This function helps us to find connections between HMM state time course (D) and behavioral variables or individual traits (R) using permutation testing.\n", "\n", "\n", "**Permutation testing**\\\n", "Permutation testing does not assume any particular data distribution and the procedure shuffles the data around to create a null distribution. This null distribution comes in handy for testing our hypotheses without making any assumptions about the data.\n", "This null distribution becomes our benchmark to test the question: is there any real difference or relationship between the variables we're interested in?\n", "\n", "![image.png](attachment:image.png)\n", "\n", "**Figure 5B** in [Vidaurre et al. 2023](https://arxiv.org/abs/2312.07151#:~:text=GLHMM%20is%20implemented%20as%20a,sets%20at%20reasonable%20computational%20time): A 9 x 4 matrix representing permutation testing across trials. Each number corresponds to a trial within a session, and permutations are performed within sessions.\n", "\n", "\n", "**Hypothesis**\n", "* Null Hypothesis (H0): No significant relationship exists between the independent variables and the dependent variable.\n", "* Alternative Hypothesis (H1): There is a significant relationship between the independent variables and the dependent variable. \n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Across-trials testing - Multivariate \n", "\n", "The multivariate analysis aims to evaluate whether the state time courses of our brain data ($D$) contribute to explaining the observed variability in behavioral measurements ($R$) when viewing inanimate versus animated objects. By quantifying explained variance, this analysis determines whether state transitions significantly influence changes in behavioral responses.\n", "\n", "To run the ``test_across_trials`` test, we set the following parameters:\n", "\n", "**Inputs**:\n", "\n", "* ```D_data```: The state time courses of the brain data (```Gamma_epoch```).\n", "* ```R_data```: The behavioral measurements that is the stimuli condition (```R_trials```).\n", "* ```idx_data``` : Indices for the first and last trial for a given session (```idx_trials_session```)\n", "\n", "**Settings**:\n", "\n", "* ```method = \"multivariate\"```: Specifies that the test should perform multivariate analysis.\n", "* ```Nnull_samples```: Number of permutations (optional, default is 1000).\n", "\n", "Additional settings allow for the inclusion of confounding variables, which can be regressed out during the permutation testing process. For details on these settings, refer to the function documentation." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "performing permutation testing per timepoint\n", "Total possible permutations: 1.29e+2459\n", "Running number of permutations: 1000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 250/250 [01:10<00:00, 3.56it/s]\n" ] } ], "source": [ "# Set the parameters for across sessions within subject testing\n", "method = \"multivariate\"\n", "Nnull_samples = 1000 # Number of permutations (default = 1000)\n", "\n", "# Perform across-trial testing\n", "result_multivariate_trials =statistics.test_across_trials(D_data=Gamma_epoch, \n", " R_data=R_trials, \n", " idx_data=idx_trials_session,\n", " method=method, \n", " Nnull_samples=Nnull_samples)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What we can see here is that ```result_multivariate_trials``` is a dictionary containing the outcomes of a statistical analysis conducted using the specified ```method``` and ```test_type```. \n", "\n", "Let us break it down:\n", "* ```pval```: This array holds the p-values resulting from the permutation test. Each value corresponds to a behavioral variable and will have shape of 1 by q, see [GLHMM paper](https://direct.mit.edu/imag/article/doi/10.1162/imag_a_00460/127499/The-Gaussian-Linear-Hidden-Markov-model-a-Python).\n", "\n", "* ```base_statistics```: Stores the base statistics of the tests. In this case it is the explained variance $R^2$\n", "\n", "* ```test_statistic```: Will by default always return a list of the base (unpermuted) statistics when ```test_statistic_option=False```. This list can store the test statistics associated with the permutation test. It provides information about the permutation distribution that is used to calculate the p-values. The output will exported if we set ```test_statistic_option=True```\n", "\n", "* ```statistical_measures```: A dictionary that marks the units used as test_statistics\n", "\n", "* ```test_type```: Indicates the type of permutation test performed. In this case, it is ```across_trials```.\n", "\n", "* ```method```: Specifies the analytical method employed, which is ```'multivariate'```, which means that the analysis is carried out using regression-based permutation testing.\n", "\n", "* ```max_correction```: Boolean value that indicates whether Max correction has been applied when performing permutation testing\n", "\n", "* ```Nnull_samples```: Is the number of permutations that has been performed.\n", "\n", "* ```test_summary```: A dictionary summarizing the test results based on the applied method." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Visualization of results**\\\n", "Now that we have performed our test, we can then visualize the p-value array.\\\n", "We will use the function ```plot_heatmap``` from the ```graphics``` module.\n", "\n", "Note: Elements marked in red indicate a p-value below 0.05, signifying statistical significance." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# The alpha score we set for the p-values\n", "alpha = 0.05\n", "# Plot p-values\n", "graphics.plot_p_values_over_time(result_multivariate_trials[\"pval\"], \n", " title_text =\"Multivariate - Uncorrected\",\n", " figsize=(10, 3), \n", " xlabel=\"Time points\", \n", " alpha=alpha, \n", " num_x_ticks=11)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Multiple Comparison**\\\n", "To be sure there is no type 1 error, we can apply the Benjamini/Hochberg to control the False Discovery Rate" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pval_corrected, rejected_corrected =statistics.pval_correction(result_multivariate_trials, \n", " method='fdr_bh')\n", "# Plot p-values\n", "graphics.plot_p_values_over_time(pval_corrected, \n", " title_text =\"Multivariate - Benjamini/Hochberg\",\n", " figsize=(9, 3), \n", " xlabel=\"HMM States\", \n", " num_x_ticks=11)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Cluster based permutation testing**\\\n", "In order to provide a more strict control over Type I mistakes, we can also apply cluster-based permutation testing to control the Family-Wise Error Rate when conducting multiple comparisons.\n", "To use this p-value correction, set ```test_statistics_option=True``` while performing permutation testing, as it is an input to the function (```pval_cluster_based_correction```)." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pval_cluster =statistics.pval_cluster_based_correction(result_multivariate_trials)\n", "# Plot p-values\n", "graphics.plot_p_values_over_time(pval_cluster, title_text =\"Multivariate - Cluster correction\",\n", " figsize=(10, 3), \n", " xlabel=\"Time points\", \n", " num_x_ticks=11)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Visualize average probabilities and differences**\\\n", "We can now compare if the results from ```result_multivariate_trials[\"pval\"]``` correspond to the difference for each state over time for the two conditions. This will be done using the function ```plot_condition_difference```.\n", "\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Detect the intervals of when there is a significant difference, will be highlighed\n", "alpha = 0.05\n", "intervals =statistics.detect_significant_intervals(pval_corrected, alpha)\n", "# Plot the average probability for each state over time for two conditions and their difference.\n", "graphics.plot_condition_difference(Gamma_epoch, \n", " R_trials, \n", " figsize=(12,3),\n", " vertical_lines=intervals, \n", " highlight_boxes=True, \n", " title=\"Average Probability and Differences (fdr_bh correction)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Conclusion - Multivariate\n", "The results of the multivariate test on the synthetic data reveal a statistically significant period between 20 and 60 timepoints after applying cluster correction. This indicates that, during this time window, there is a detectable difference in how the simulated subject perceives the stimuli. While these findings are based on synthetic data, they demonstrate the ability of the test to capture meaningful patterns in the simulated brain activity and its relationship with the stimuli.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Across-trials within sessions testing - Univariate \n", "The univariate analysis examines how each state in the brain's activity ($D$, represented by ```Gamma_epoch```) relates to the behavioral measurements ($R$). This method looks for patterns between individual states and the variability in behavioral responses across trials.\n", "\n", "If the result is significant, it suggests that certain patterns in the brain's activity (```Gamma_epoch```) are linked to differences in the behavioral measurements, such as responses to different stimuli. A non-significant result means that the observed relationship might be due to chance, and the brain states do not explain the differences in behavior.\n", "\n", "To run the test_across_trials, you need to provide the following:\n", "\n", "**Inputs**:\n", "\n", "* ```D_data```: The state time courses of the brain data (```Gamma_epoch```).\n", "* ```R_data```: The behavioral measurements that is the stimuli condition (```R_trials```).\n", "* ```idx_data``` : Indices for the first and last trial for a given session (```idx_trials_session```)\n", "\n", "**Settings**:\n", "\n", "* ```method = \"univariate\"```: Specifies that the test should perform multivariate analysis.\n", "* ```Nnull_samples```: Number of permutations (optional, default is 1000).\n", "\n", "You can also adjust for other variables by using permutation testing. For more details, check the function documentation.\n", "\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "performing permutation testing per timepoint\n", "Total possible permutations: 1.29e+2459\n", "Running number of permutations: 1000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 250/250 [00:42<00:00, 5.92it/s]\n" ] } ], "source": [ "# Set the parameters for between-subject testing\n", "method = \"univariate\"\n", "Nnull_samples = 1000 # Number of permutations (default = 1000)\n", "# Perform across-subject testing\n", "result_univariate =statistics.test_across_trials(Gamma_epoch, \n", " R_trials, \n", " idx_trials_session,\n", " method=method,\n", " Nnull_samples=Nnull_samples)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Visualization of results**\\\n", "Now that we have performed our test, we can then visualize the p-value matrix.\\\n", "We will use the function ```plot_heatmap``` from the ```graphics``` module.\n", "\n", "Note: Elements marked in red indicate a p-value below 0.05, signifying statistical significance." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot p-values\n", "alpha = 0.05 # threshold for p-values\n", "graphics.plot_p_value_matrix(result_univariate[\"pval\"].T, \n", " title_text =\"Univariate - Uncorrected\",\n", " figsize=(8, 5), \n", " xlabel=\"Time points\", \n", " ylabel=\"HMM States\", \n", " annot=False, \n", " num_x_ticks=11)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Multiple Comparison**\\\n", "To be sure there is no type 1 error, we can apply the Benjamini/Hochberg to control the False Discovery Rate" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "alpha = 0.05 # threshold for p-values\n", "pval_corrected, rejected_corrected =statistics.pval_correction(result_univariate, \n", " method='fdr_bh', \n", " alpha=0.5)\n", "# Plot p-values\n", "graphics.plot_p_value_matrix(pval_corrected.T, title_text =\"Univaraite - Benjamini/Hochberg\",\n", " figsize=(8, 5), \n", " xlabel=\"Time points\", \n", " ylabel=\"HMM States\", \n", " annot=False, \n", " num_x_ticks=11)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Cluster based permutation testing**\\\n", "In order to provide a more strict control over Type I mistakes, we can also apply cluster-based permutation testing to control the Family-Wise Error Rate when conducting multiple comparisons." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pval_cluster =statistics.pval_cluster_based_correction(result_univariate, individual_feature=True)\n", "# Plot p-values\n", "graphics.plot_p_value_matrix(pval_cluster.T, title_text =\"Univariate - Cluster corrected\",\n", " figsize=(8, 5), \n", " xlabel=\"Time points\", \n", " ylabel=\"HMM States\", \n", " annot=False,\n", " num_x_ticks=11,\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Conclusion - Univariate test\n", "The results of the univariate test on the synthetic data, after applying cluster correction, reveal distinct periods of significance across different states. For states 2 through 6, significant relationships are observed within the time range of 18–54 timepoints. In state 1, a significant period is identified around 115–120 timepoints, while state 2 also shows additional significance later between 118–122 timepoints. These findings suggest that specific states are associated with varying temporal patterns in the simulated brain activity, reflecting differences in responses to the stimuli.\n", "\n", "However, when applying the Benjamini/Hochberg procedure to control for multiple hypotheses, none of the timepoints reach statistical significance. This highlights the challenge of maintaining statistical power in the presence of multiple comparisons and underscores the importance of considering the appropriate correction method for the analysis context.\n" ] } ], "metadata": { "kernelspec": { "display_name": "GLHMM_env", "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.9.21" } }, "nbformat": 4, "nbformat_minor": 2 }