code: def _omp_path_residues(
      X_train,
      y_train,
      X_test,
      y_test,
      copy=True,
      fit_intercept=True,
      normalize=True,
      max_iter=100,
  ):
      """Compute the residues on left-out data for a full LARS path
  
      Parameters
      -----------
      X_train : array, shape (n_samples, n_features)
          The data to fit the LARS on
  
      y_train : array, shape (n_samples)
          The target variable to fit LARS on
  
      X_test : array, shape (n_samples, n_features)
          The data to compute the residues on
  
      y_test : array, shape (n_samples)
          The target variable to compute the residues on
  
      copy : boolean, optional
          Whether X_train, X_test, y_train and y_test should be copied.  If
          False, they may be overwritten.
  
      fit_intercept : boolean
          whether to calculate the intercept for this model. If set
          to false, no intercept will be used in calculations
          (e.g. data is expected to be already centered).
  
      normalize : boolean, optional, default False
          If True, the regressors X will be normalized before regression.
          This parameter is ignored when `fit_intercept` is set to `False`.
          When the regressors are normalized, note that this makes the
          hyperparameters learnt more robust and almost independent of the number
          of samples. The same property is not valid for standardized data.
          However, if you wish to standardize, please use
          `preprocessing.StandardScaler` before calling `fit` on an estimator
          with `normalize=False`.
  
      max_iter : integer, optional
          Maximum numbers of iterations to perform, therefore maximum features
          to include. 100 by default.
  
      Returns
      -------
      residues: array, shape (n_samples, max_features)
          Residues of the prediction on the test data
      """
  
      if copy:
          X_train = X_train.copy()
          y_train = y_train.copy()
          X_test = X_test.copy()
          y_test = y_test.copy()
  
      if fit_intercept:
          X_mean = X_train.mean(axis=0)
          X_train -= X_mean
          X_test -= X_mean
          y_mean = y_train.mean(axis=0)
          y_train = as_float_array(y_train, copy=False)
          y_train -= y_mean
          y_test = as_float_array(y_test, copy=False)
          y_test -= y_mean
  
      if normalize:
          norms = np.sqrt(np.sum(X_train**2, axis=0))
          nonzeros = np.flatnonzero(norms)
          X_train[:, nonzeros] /= norms[nonzeros]
  
      coefs = orthogonal_mp(
          X_train,
          y_train,
          n_nonzero_coefs=max_iter,
          tol=None,
          precompute=False,
          copy_X=False,
          return_path=True,
      )
      if coefs.ndim == 1:
          coefs = coefs[:, np.newaxis]
      if normalize:
          coefs[nonzeros] /= norms[nonzeros][:, np.newaxis]
  
      return np.dot(coefs.T, X_test.T) - y_test
  
imports: import warnings
  from distutils.version import LooseVersion
  import numpy
  from scipy import linalg
  from scipy.linalg.lapack import get_lapack_funcs
  from .base import LinearModel, _pre_fit
  from ..base import RegressorMixin
  from ..utils import as_float_array, check_array, check_X_y
  from ..model_selection import check_cv
  from ..externals.joblib import Parallel, delayed
  import scipy
label_desc: Use image node_id 5 for calling a global function with example usage: _omp_path_residues(X_train, y_train, X_test, y_test, copy, fit_intercept, normalize, max_iter) and returns: unknown