code: def init_data_params(
      df,
      normalize="auto",
      config_lagged_regressors: Optional[ConfigLaggedRegressors] = None,
      config_regressors=None,
      config_events: Optional[ConfigEvents] = None,
      config_seasonality: Optional[ConfigSeasonality] = None,
      global_normalization=False,
      global_time_normalization=False,
  ):
      """Initialize data scaling values.
  
      Note
      ----
      We compute and store local and global normalization parameters independent of settings.
  
      Parameters
      ----------
          df : pd.DataFrame
              data to compute normalization parameters from.
          normalize : str
              Type of normalization to apply to the time series.
  
                  options:
  
                      ``soft`` (default), unless the time series is binary, in which case ``minmax`` is applied.
  
                      ``off`` bypasses data normalization
  
                      ``minmax`` scales the minimum value to 0.0 and the maximum value to 1.0
  
                      ``standardize`` zero-centers and divides by the standard deviation
  
                      ``soft`` scales the minimum value to 0.0 and the 95th quantile to 1.0
  
                      ``soft1`` scales the minimum value to 0.1 and the 90th quantile to 0.9
          config_lagged_regressors : configure.ConfigLaggedRegressors
              Configurations for lagged regressors
          config_regressors : configure.ConfigFutureRegressors
              extra regressors (with known future values)
          config_events : configure.ConfigEvents
              user specified events configs
          config_seasonality : configure.ConfigSeasonality
              user specified seasonality configs
          global_normalization : bool
  
              ``True``: sets global modeling training with global normalization
  
              ``False``: sets global modeling training with local normalization
          global_time_normalization : bool
  
              ``True``: normalize time globally across all time series
  
              ``False``: normalize time locally for each time series
  
              (only valid in case of global modeling - local normalization)
  
      Returns
      -------
          OrderedDict
              nested dict with data_params for each dataset where each contains
          OrderedDict
              ShiftScale entries containing ``shift`` and ``scale`` parameters for each column
      """
      # Compute Global data params
      df, _, _, _ = prep_or_copy_df(df)
      df_merged = df.copy(deep=True).drop("ID", axis=1)
      global_data_params = data_params_definition(
          df_merged,
          normalize,
          config_lagged_regressors,
          config_regressors,
          config_events,
          config_seasonality,
      )
      if global_normalization:
          log.debug(
              f"Global Normalization Data Parameters (shift, scale): {[(k, v) for k, v in global_data_params.items()]}"
          )
      # Compute individual  data params
      local_data_params = OrderedDict()
      local_run_despite_global = True if global_normalization else None
      for df_name, df_i in df.groupby("ID"):
          df_i.drop("ID", axis=1, inplace=True)
          local_data_params[df_name] = data_params_definition(
              df_i,
              normalize,
              config_lagged_regressors,
              config_regressors,
              config_events,
              config_seasonality,
              local_run_despite_global,
          )
          if global_time_normalization:
              # Overwrite local time normalization data_params with global values (pointer)
              local_data_params[df_name]["ds"] = global_data_params[
                  "ds"
              ]
          if not global_normalization:
              params = [
                  (k, v) for k, v in local_data_params[df_name].items()
              ]
              log.debug(
                  f"Local Normalization Data Parameters (shift, scale): {params}"
              )
      return local_data_params, global_data_params
  
imports: from __future__ import annotations
  import logging
  import math
  from collections import OrderedDict
  from dataclasses import dataclass
  from typing import TYPE_CHECKING, List, Optional, Tuple
  import numpy
  import pandas
label_desc: Use image node_id 6 for calling a global function with example usage: init_data_params(df, normalize, config_lagged_regressors, config_regressors, config_events, config_seasonality, global_normalization, global_time_normalization) and returns: local_data_params,  global_data_params