code: def _no_refit_cross_validation(
      self,
      df: Optional[DataFrame],
      static_df: Optional[DataFrame],
      n_windows: int,
      step_size: int,
      val_size: Optional[int],
      test_size: int,
      sort_df: bool,
      verbose: bool,
      id_col: str,
      time_col: str,
      target_col: str,
      **data_kwargs,
  ) -> DataFrame:
      if (df is None) and not (hasattr(self, "dataset")):
          raise Exception(
              "You must pass a DataFrame or have one stored."
          )
  
      # Process and save new dataset (in self)
      if df is not None:
          validate_freq(df[time_col], self.freq)
          (
              self.dataset,
              self.uids,
              self.last_dates,
              self.ds,
          ) = self._prepare_fit(
              df=df,
              static_df=static_df,
              sort_df=sort_df,
              predict_only=False,
              id_col=id_col,
              time_col=time_col,
              target_col=target_col,
          )
          self.sort_df = sort_df
      else:
          if verbose:
              print("Using stored dataset.")
  
      if val_size is not None:
          if self.dataset.min_size < (val_size + test_size):
              warnings.warn(
                  "Validation and test sets are larger than the shorter time-series."
              )
  
      cols = []
      count_names = {"model": 0}
      for model in self.models:
          model_name = repr(model)
          count_names[model_name] = count_names.get(model_name, -1) + 1
          if count_names[model_name] > 0:
              model_name += str(count_names[model_name])
          cols += [model_name + n for n in model.loss.output_names]
  
      fcsts_df = ufp.cv_times(
          times=self.ds,
          uids=self.uids,
          indptr=self.dataset.indptr,
          h=self.h,
          test_size=test_size,
          step_size=step_size,
          id_col=id_col,
          time_col=time_col,
      )
      # the cv_times is sorted by window and then id
      fcsts_df = ufp.sort(fcsts_df, [id_col, "cutoff", time_col])
  
      col_idx = 0
      fcsts = np.full(
          (self.dataset.n_groups * self.h * n_windows, len(cols)),
          np.nan,
          dtype=np.float32,
      )
  
      for model in self.models:
          model.fit(
              dataset=self.dataset,
              val_size=val_size,
              test_size=test_size,
          )
          model_fcsts = model.predict(
              self.dataset, step_size=step_size, **data_kwargs
          )
  
          # Append predictions in memory placeholder
          output_length = len(model.loss.output_names)
          fcsts[:, col_idx : (col_idx + output_length)] = model_fcsts
          col_idx += output_length
      if self.scalers_:
          indptr = np.append(
              0,
              np.full(
                  self.dataset.n_groups, self.h * n_windows
              ).cumsum(),
          )
          fcsts = self._scalers_target_inverse_transform(fcsts, indptr)
  
      self._fitted = True
  
      # Add predictions to forecasts DataFrame
      if isinstance(self.uids, pl_Series):
          fcsts = pl_DataFrame(dict(zip(cols, fcsts.T)))
      else:
          fcsts = pd.DataFrame(fcsts, columns=cols)
      fcsts_df = ufp.horizontal_concat([fcsts_df, fcsts])
  
      # Add original input df's y to forecasts DataFrame
      fcsts_df = ufp.join(
          fcsts_df,
          df[[id_col, time_col, target_col]],
          how="left",
          on=[id_col, time_col],
      )
      if isinstance(fcsts_df, pd.DataFrame) and _id_as_idx():
          _warn_id_as_idx()
          fcsts_df = fcsts_df.set_index(id_col)
      return fcsts_df
  
imports: import os
  import pickle
  import warnings
  from copy import deepcopy
  from itertools import chain
  from typing import Any, Dict, List, Optional, Union
  import numpy
  import pandas
  import torch
  import utilsforecast.processing
  from utilsforecast.compat import DataFrame, Series, pl_DataFrame, pl_Series
  from utilsforecast.grouped_array import GroupedArray
  from utilsforecast.target_transforms import BaseTargetTransform, LocalBoxCox, LocalMinMaxScaler, LocalRobustScaler, LocalStandardScaler
  from utilsforecast.validation import validate_freq
  from .tsdataset import TimeSeriesDataset
  from neuralforecast.models import GRU, LSTM, RNN, TCN, DeepAR, DilatedRNN, MLP, NHITS, NBEATS, NBEATSx, TFT, VanillaTransformer, Informer, Autoformer, FEDformer, StemGNN, PatchTST, TimesNet
label_desc: Use image node_id 12 for calling the NeuralForecast obj's underlying member method code with example usage: obj._no_refit_cross_validation(df, static_df, n_windows, step_size, val_size, test_size, sort_df, verbose, id_col, time_col, target_col) and returns: fcsts_df