code: def test_regularization(tmp_path):
      (
          input_features,
          output_features,
      ) = synthetic_test_data.get_feature_configs()
  
      config = {
          "input_features": input_features,
          "output_features": output_features,
          "combiner": {"type": "concat"},
          TRAINER: {
              "epochs": 1,
              "batch_size": 16,
              "regularization_lambda": 1,
          },
      }
  
      # create sub-directory to store results
      results_dir = tmp_path / "results"
      results_dir.mkdir()
  
      regularization_losses = []
      generated_data = synthetic_test_data.get_generated_data()
      for regularizer in [None, "l1", "l2", "l1_l2"]:
          np.random.seed(RANDOM_SEED)
          torch.manual_seed(RANDOM_SEED)
  
          # setup regularization parameters
          config[TRAINER]["regularization_type"] = regularizer
  
          # run experiment
          _, _, _, _, output_dir = experiment_cli(
              training_set=generated_data.train_df,
              validation_set=generated_data.validation_df,
              test_set=generated_data.test_df,
              output_directory=str(results_dir),
              config=config,
              experiment_name="regularization",
              model_name=str(regularizer),
              skip_save_processed_input=True,
              skip_save_progress=True,
              skip_save_unprocessed_output=True,
              skip_save_model=True,
              skip_save_log=True,
          )
  
          # test existence of required files
          train_stats_fp = os.path.join(
              output_dir, "training_statistics.json"
          )
          metadata_fp = os.path.join(output_dir, DESCRIPTION_FILE_NAME)
          assert os.path.isfile(train_stats_fp)
          assert os.path.isfile(metadata_fp)
  
          # retrieve results so we can compare training loss with regularization
          with open(train_stats_fp) as f:
              train_stats = json.load(f)
  
          # retrieve training losses for all epochs
          train_losses = train_stats[TRAINING]["combined"]["loss"]
          regularization_losses.append(train_losses[0])
  
      # create a set of losses
      regularization_losses_set = set(regularization_losses)
  
      # ensure all losses obtained with the different methods are different
      assert len(regularization_losses) == len(
          regularization_losses_set
      )
  
imports: import json
  import logging
  import os.path
  import re
  import numpy
  import pandas
  import pytest
  import torch
  from ludwig import globals
  from ludwig.api import LudwigModel
  from ludwig.backend import LOCAL_BACKEND
  from ludwig.constants import BATCH_SIZE, CATEGORY, DEFAULTS, EPOCHS, INPUT_FEATURES, OUTPUT_FEATURES, PREPROCESSING, TRAINER, TRAINING
  from ludwig.contribs.mlflow import MlflowCallback
  from ludwig.experiment import experiment_cli
  from ludwig.features.number_feature import numeric_transformation_registry
  from ludwig.globals import DESCRIPTION_FILE_NAME, TRAINING_PREPROC_FILE_NAME
  from ludwig.schema.optimizers import optimizer_registry
  from ludwig.utils.data_utils import load_json, replace_file_extension
  from ludwig.utils.misc_utils import get_from_registry
  from ludwig.utils.package_utils import LazyLoader
  from tests.integration_tests import synthetic_test_data
  from tests.integration_tests.utils import category_feature, generate_data, LocalTestBackend
label_desc: Use image node_id 6 for calling a global function with example usage: test_regularization(tmp_path) without return types