code: def test_hyperopt_nested_parameters(
      csv_filename, tmpdir, ray_cluster_7cpu
  ):
      config = {
          INPUT_FEATURES: [
              {
                  "name": "cat1",
                  TYPE: "category",
                  "encoder": {"vocab_size": 2},
              },
              {"name": "num1", TYPE: "number"},
          ],
          OUTPUT_FEATURES: [
              {"name": "bin1", TYPE: "binary"},
          ],
          TRAINER: {"epochs": 2, BATCH_SIZE: 128},
          HYPEROPT: {
              EXECUTOR: {
                  TYPE: "ray",
                  "time_budget_s": 200,
                  "cpu_resources_per_trial": 1,
                  "num_samples": 2,
                  "scheduler": {TYPE: "fifo"},
              },
              "search_alg": {TYPE: "variant_generator"},
              "parameters": {
                  ".": {
                      "space": "choice",
                      "categories": [
                          {
                              "combiner": {
                                  "type": "tabnet",
                                  "bn_virtual_bs": 256,
                              },
                              "trainer": {
                                  "learning_rate_scaling": "sqrt",
                                  "learning_rate_scheduler": {
                                      "decay": "exponential",
                                      "decay_steps": 20000,
                                      "decay_rate": 0.8,
                                  },
                                  "optimizer": {"type": "adam"},
                              },
                          },
                          {
                              "combiner": {"type": "concat"},
                              "trainer": {
                                  "learning_rate_scaling": "linear"
                              },
                          },
                      ],
                  },
                  "trainer.learning_rate": {
                      "space": "choice",
                      "categories": [0.7, 0.42],
                  },
              },
          },
      }
  
      input_features = config[INPUT_FEATURES]
      output_features = config[OUTPUT_FEATURES]
      rel_path = generate_data(
          input_features, output_features, csv_filename
      )
  
      results = hyperopt(
          config,
          dataset=rel_path,
          output_directory=tmpdir,
          experiment_name="test_hyperopt_nested_params",
      )
  
      results_df = results.experiment_analysis.results_df
      assert len(results_df) == 2
  
      for _, trial_meta in results_df.iterrows():
          trial_dir = trial_meta["trial_dir"]
          trial_config = load_json(
              os.path.join(
                  trial_dir,
                  "test_hyperopt_nested_params_run",
                  "model",
                  "model_hyperparameters.json",
              )
          )
  
          assert len(trial_config[INPUT_FEATURES]) == len(
              config[INPUT_FEATURES]
          )
          assert len(trial_config[OUTPUT_FEATURES]) == len(
              config[OUTPUT_FEATURES]
          )
  
          assert trial_config[COMBINER][TYPE] in {"tabnet", "concat"}
          if trial_config[COMBINER][TYPE] == "tabnet":
              assert trial_config[COMBINER]["bn_virtual_bs"] == 256
              assert (
                  trial_config[TRAINER]["learning_rate_scaling"]
                  == "sqrt"
              )
              assert (
                  trial_config[TRAINER]["learning_rate_scheduler"][
                      "decay"
                  ]
                  == "exponential"
              )
              assert (
                  trial_config[TRAINER]["learning_rate_scheduler"][
                      "decay_steps"
                  ]
                  == 20000
              )
              assert (
                  trial_config[TRAINER]["learning_rate_scheduler"][
                      "decay_rate"
                  ]
                  == 0.8
              )
              assert (
                  trial_config[TRAINER]["optimizer"]["type"] == "adam"
              )
          else:
              assert (
                  trial_config[TRAINER]["learning_rate_scaling"]
                  == "linear"
              )
  
          assert trial_config[TRAINER]["learning_rate"] in {0.7, 0.42}
  
imports: import json
  import os
  import os.path
  import uuid
  from typing import Dict, Tuple
  import pytest
  from ludwig.backend import initialize_backend
  from ludwig.constants import ACCURACY, AUTO, BATCH_SIZE, CATEGORY, COMBINER, EXECUTOR, HYPEROPT, INPUT_FEATURES, MAX_CONCURRENT_TRIALS, MODEL_ECD, MODEL_GBM, MODEL_TYPE, NAME, OUTPUT_FEATURES, RAY, TEST, TEXT, TRAINER, TRAINING, TYPE, VALIDATION
  from ludwig.globals import HYPEROPT_STATISTICS_FILE_NAME
  from ludwig.hyperopt.results import HyperoptResults
  from ludwig.hyperopt.run import hyperopt
  from ludwig.hyperopt.utils import update_hyperopt_params_with_defaults
  from ludwig.schema.model_config import ModelConfig
  from ludwig.utils import fs_utils
  from ludwig.utils.data_utils import load_json, use_credentials
  from tests.integration_tests.utils import category_feature, generate_data, minio_test_creds, private_param, remote_tmpdir, text_feature
  from ludwig.hyperopt.execution import get_build_hyperopt_executor, RayTuneExecutor
label_desc: Use image node_id 11 for calling a global function with example usage: test_hyperopt_nested_parameters(csv_filename, tmpdir, ray_cluster_7cpu) without return types