text: Title: Discrepancy between specified `5min` frequency and DeepAR model configuration
  Body: # Subject: Discrepancy between specified 'freq' and DeepAR config 'freq'
  
  Hi everyone,
  
  I'm encountering an issue where I specified `freq='5min'` during the training of a DeepAR model using AutoGluon, but the final model configuration shows `freq='D'`. I'm trying to understand why this discrepancy exists and if it could be impacting my model.
  
  ## Details from Training Logs
  
  Here are some key points from the training logs:
  ```plaintext
  =================== System Info ===================
  AutoGluon Version:  1.2
  Python Version:     3.12.3
  Operating System:   Linux
  Platform Machine:   x86_64
  Platform Version:   #1 SMP Tue Nov 5 00:21:55 UTC 2024
  CPU Count:          16
  GPU Count:          1
  Memory Avail:       27.98 GB / 31.29 GB (89.4%)
  Disk Space Avail:   437.20 GB / 953.26 GB (45.9%)
  ===================================================
  Setting presets to: best_quality
  
  Fitting with arguments:
  {'enable_ensemble': True,
   'eval_metric': MASE,
   'excluded_model_types': ['RecursiveTabular', 'DirectTabular', 'TiDE'],
   'freq': '5min',
   'hyperparameters': 'default',
   'known_covariates_names': ['minute_sin',
                              'minute_cos',
                              'hour_sin',
                              'hour_cos',
                              'day_of_week_sin',
                              'day_of_week_cos',
                              'is_weekend'],
   'num_val_windows': 5,
   'prediction_length': 30,
   'quantile_levels': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
   'random_seed': 123,
   'refit_every_n_windows': 2,
   'refit_full': False,
   'skip_model_selection': False,
   'target': 'target',
   'time_limit': 20000,
   'verbosity': 2}
  
  Data with frequency 'None' has been resampled to frequency '5min'.
  The provided data has a large number of rows and several time series.
  
  The data contains a target column and the following known covariates:
          categorical:        ['is_weekend']
          continuous (float): ['minute_sin', 'minute_cos', 'hour_sin', 'hour_cos', 'day_of_week_sin', 'day_of_week_cos']
  
  To learn how to fix incorrectly inferred types, please see documentation for TimeSeriesPredictor.fit
  
  AutoGluon will gauge predictive performance using evaluation metric: 'MASE'
          This metric's sign has been flipped to adhere to being higher_is_better. The metric score can be multiplied by -1 to get the metric value.
  ===================================================
  ```
  And here's the relevant part of the saved DeepAR model's config:
  ```json
  {
    "__kind__": "instance",
    "args": [],
    "class": "gluonts.torch.model.predictor.PyTorchPredictor",
    "kwargs": {
      "batch_size": 64,
      "device": "auto",
      "forecast_generator": {
        "__kind__": "instance",
        "args": [],
        "class": "gluonts.model.forecast_generator.SampleForecastGenerator",
        "kwargs": {}
      },
      "input_names": [
        "feat_static_cat",
        "feat_static_real",
        "past_time_feat",
        "past_target",
        "past_observed_values",
        "future_time_feat"
      ],
      "input_transform": {
        "__kind__": "instance",
        "class": "gluonts.transform._base.Chain",
        "kwargs": {
          "transformations": [
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.field.RemoveFields",
              "kwargs": {
                "field_names": [
                  "feat_static_real"
                ]
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.field.SetField",
              "kwargs": {
                "output_field": "feat_static_cat",
                "value": [
                  0
                ]
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.field.SetField",
              "kwargs": {
                "output_field": "feat_static_real",
                "value": [
                  0.0
                ]
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.convert.AsNumpyArray",
              "kwargs": {
                "dtype": {
                  "__kind__": "type",
                  "class": "builtins.int"
                },
                "expected_ndim": 1,
                "field": "feat_static_cat"
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.convert.AsNumpyArray",
              "kwargs": {
                "dtype": {
                  "__kind__": "type",
                  "class": "numpy.float32"
                },
                "expected_ndim": 1,
                "field": "feat_static_real"
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.convert.AsNumpyArray",
              "kwargs": {
                "dtype": {
                  "__kind__": "type",
                  "class": "numpy.float32"
                },
                "expected_ndim": 1,
                "field": "target"
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.feature.AddObservedValuesIndicator",
              "kwargs": {
                "dtype": {
                  "__kind__": "type",
                  "class": "numpy.float32"
                },
                "imputation_method": {
                  "__kind__": "instance",
                  "args": [],
                  "class": "gluonts.transform.feature.DummyValueImputation",
                  "kwargs": {
                    "dummy_value": 0.0
                  }
                },
                "output_field": "observed_values",
                "target_field": "target"
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.feature.AddTimeFeatures",
              "kwargs": {
                "dtype": {
                  "__kind__": "type",
                  "class": "numpy.float32"
                },
                "output_field": "time_feat",
                "pred_length": 30,
                "start_field": "start",
                "target_field": "target",
                "time_features": [
                  {
                    "__kind__": "type",
                    "class": "autogluon.timeseries.utils.datetime.time_features.minute_of_hour"
                  },
                  {
                    "__kind__": "type",
                    "class": "autogluon.timeseries.utils.datetime.time_features.hour_of_day"
                  },
                  {
                    "__kind__": "type",
                    "class": "autogluon.timeseries.utils.datetime.time_features.day_of_week"
                  },
                  {
                    "__kind__": "type",
                    "class": "autogluon.timeseries.utils.datetime.time_features.day_of_month"
                  },
                  {
                    "__kind__": "type",
                    "class": "autogluon.timeseries.utils.datetime.time_features.day_of_year"
                  }
                ]
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.feature.AddAgeFeature",
              "kwargs": {
                "dtype": {
                  "__kind__": "type",
                  "class": "numpy.float32"
                },
                "log_scale": true,
                "output_field": "feat_dynamic_age",
                "pred_length": 30,
                "target_field": "target"
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.convert.VstackFeatures",
              "kwargs": {
                "drop_inputs": true,
                "h_stack": false,
                "input_fields": [
                  "time_feat",
                  "feat_dynamic_age",
                  "feat_dynamic_real"
                ],
                "output_field": "time_feat"
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.convert.AsNumpyArray",
              "kwargs": {
                "dtype": {
                  "__kind__": "type",
                  "class": "numpy.float32"
                },
                "expected_ndim": 2,
                "field": "time_feat"
              }
            },
            {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.transform.split.InstanceSplitter",
              "kwargs": {
                "dummy_value": 0.0,
                "forecast_start_field": "forecast_start",
                "future_length": 30,
                "instance_sampler": {
                  "__kind__": "instance",
                  "class": "gluonts.transform.sampler.PredictionSplitSampler",
                  "kwargs": {
                    "allow_empty_interval": false,
                    "axis": -1,
                    "min_future": 0,
                    "min_past": 0
                  }
                },
                "is_pad_field": "is_pad",
                "lead_time": 0,
                "output_NTC": true,
                "past_length": 1212,
                "start_field": "start",
                "target_field": "target",
                "time_series_fields": [
                  "time_feat",
                  "observed_values"
                ]
              }
            }
          ]
        }
      },
      "lead_time": 0,
      "output_transform": null,
      "prediction_length": 30,
      "prediction_net": {
        "__kind__": "instance",
        "args": [],
        "class": "gluonts.torch.model.deepar.lightning_module.DeepARLightningModule",
        "kwargs": {
          "lr": 0.001,
          "model_kwargs": {
            "cardinality": [
              1
            ],
            "context_length": 60,
            "default_scale": null,
            "distr_output": {
              "__kind__": "instance",
              "args": [],
              "class": "gluonts.torch.distributions.studentT.StudentTOutput",
              "kwargs": {
                "beta": 0.0
              }
            },
            "dropout_rate": 0.1,
            "embedding_dimension": null,
            "freq": "D",
            "hidden_size": 40,
            "lags_seq": [
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              10,
              11,
              12,
              13,
              14,
              22,
              23,
              24,
              25,
              26,
              34,
              35,
              36,
              37,
              38,
              287,
              288,
              289,
              575,
              576,
              577,
              863,
              864,
              865,
              1151,
              1152,
              1153
            ],
            "nonnegative_pred_samples": false,
            "num_feat_dynamic_real": 14,
            "num_feat_static_cat": 1,
            "num_feat_static_real": 1,
            "num_layers": 2,
            "num_parallel_samples": 100,
            "prediction_length": 30,
            "scaling": true
          },
          "patience": 10,
          "weight_decay": 1e-08
        }
      }
    }
  }
  ```
  As you can see, the training arguments clearly state freq='5min', and the logs confirm that the data was resampled to '5min'. However, the freq within the model_kwargs of the trained DeepAR model is 'D'.
  
  Could someone shed some light on why this might be happening? Is this expected behavior, or is there something I might be missing in how AutoGluon handles frequency with DeepAR? Could this mismatch potentially affect the model's accuracy or the interpretation of the results?
  
  Any insights would be greatly appreciated. Thanks!