code: def isc(
      data, pairwise=False, summary_statistic=None, tolerate_nans=True
  ):
      """Intersubject correlation
  
      For each voxel or ROI, compute the Pearson correlation between each
      subject's response time series and other subjects' response time series.
      If pairwise is False (default), use the leave-one-out approach, where
      correlation is computed between each subject and the average of the other
      subjects. If pairwise is True, compute correlations between all pairs of
      subjects. If summary_statistic is None, return N ISC values for N subjects
      (leave-one-out) or N(N-1)/2 ISC values for each pair of N subjects,
      corresponding to the upper triangle of the pairwise correlation matrix
      (see scipy.spatial.distance.squareform). Alternatively, use either
      'mean' or 'median' to compute summary statistic of ISCs (Fisher Z will
      be applied if using mean). Input data should be a n_TRs by n_voxels by
      n_subjects array (e.g., brainiak.image.MaskedMultiSubjectData) or a list
      where each item is a n_TRs by n_voxels ndarray for a given subject.
      Multiple input ndarrays must be the same shape. If a 2D array is supplied,
      the last dimension is assumed to correspond to subjects. If only two
      subjects are supplied, simply compute Pearson correlation (precludes
      averaging in leave-one-out approach, and does not apply summary statistic).
      When using leave-one-out approach, NaNs are ignored when computing mean
      time series of N-1 subjects (default: tolerate_nans=True). Alternatively,
      you may supply a float between 0 and 1 indicating a threshold proportion
      of N subjects with non-NaN values required when computing the average time
      series for a given voxel. For example, if tolerate_nans=.8, ISCs will be
      computed for any voxel where >= 80% of subjects have non-NaN values,
      while voxels with < 80% non-NaN values will be assigned NaNs. If set to
      False, NaNs are not tolerated and voxels with one or more NaNs among the
      N-1 subjects will be assigned NaN. Setting tolerate_nans to True or False
      will not affect the pairwise approach; however, if a threshold float is
      provided, voxels that do not reach this threshold will be excluded. Note
      that accommodating NaNs may be notably slower than setting tolerate_nans to
      False. Output is an ndarray where the first dimension is the number of
      subjects or pairs and the second dimension is the number of voxels (or
      ROIs). If only two subjects are supplied or a summary statistic is invoked,
      the output is a ndarray n_voxels long.
  
      The implementation is based on the work in [Hasson2004]_.
  
      Parameters
      ----------
      data : list or ndarray (n_TRs x n_voxels x n_subjects)
          fMRI data for which to compute ISC
  
      pairwise : bool, default: False
          Whether to use pairwise (True) or leave-one-out (False) approach
  
      summary_statistic : None or str, default: None
          Return all ISCs or collapse using 'mean' or 'median'
  
      tolerate_nans : bool or float, default: True
          Accommodate NaNs (when averaging in leave-one-out approach)
  
      Returns
      -------
      iscs : subjects or pairs by voxels ndarray
          ISC for each subject or pair (or summary statistic) per voxel
  
      """
  
      # Check response time series input format
      data, n_TRs, n_voxels, n_subjects = _check_timeseries_input(data)
  
      # No summary statistic if only two subjects
      if n_subjects == 2:
          logger.info(
              "Only two subjects! Simply computing Pearson correlation."
          )
          summary_statistic = None
  
      # Check tolerate_nans input and use either mean/nanmean and exclude voxels
      if tolerate_nans:
          mean = np.nanmean
      else:
          mean = np.mean
      data, mask = _threshold_nans(data, tolerate_nans)
  
      # Compute correlation for only two participants
      if n_subjects == 2:
          # Compute correlation for each corresponding voxel
          iscs_stack = array_correlation(data[..., 0], data[..., 1])[
              np.newaxis, :
          ]
  
      # Compute pairwise ISCs using voxel loop and corrcoef for speed
      elif pairwise:
          # Swap axes for np.corrcoef
          data = np.swapaxes(data, 2, 0)
  
          # Loop through voxels
          voxel_iscs = []
          for v in np.arange(data.shape[1]):
              voxel_data = data[:, v, :]
  
              # Correlation matrix for all pairs of subjects (triangle)
              iscs = squareform(np.corrcoef(voxel_data), checks=False)
              voxel_iscs.append(iscs)
  
          iscs_stack = np.column_stack(voxel_iscs)
  
      # Compute leave-one-out ISCs
      elif not pairwise:
          # Loop through left-out subjects
          iscs_stack = []
          for s in np.arange(n_subjects):
              # Correlation between left-out subject and mean of others
              iscs_stack.append(
                  array_correlation(
                      data[..., s],
                      mean(np.delete(data, s, axis=2), axis=2),
                  )
              )
  
          iscs_stack = np.array(iscs_stack)
  
      # Get ISCs back into correct shape after masking out NaNs
      iscs = np.full((iscs_stack.shape[0], n_voxels), np.nan)
      iscs[:, np.where(mask)[0]] = iscs_stack
  
      # Summarize results (if requested)
      if summary_statistic:
          iscs = compute_summary_statistic(
              iscs, summary_statistic=summary_statistic, axis=0
          )[np.newaxis, :]
  
      # Throw away first dimension if singleton
      if iscs.shape[0] == 1:
          iscs = iscs[0]
  
      return iscs
  
imports: import numpy
  import logging
  from scipy.spatial.distance import squareform
  from itertools import combinations, permutations, product
  from brainiak.fcma.util import compute_correlation
  from brainiak.utils.utils import array_correlation, phase_randomize, p_from_null, _check_timeseries_input
label_desc: Use image node_id 1 for calling a global function with example usage: isc(data, pairwise, summary_statistic, tolerate_nans) and returns: iscs