code: def run_ucm(name, use_exact_diffuse=False):
      true = getattr(results_structural, name)
  
      for model in true["models"]:
          kwargs = model.copy()
          kwargs.update(true["kwargs"])
          kwargs["use_exact_diffuse"] = use_exact_diffuse
  
          # Make a copy of the data
          values = dta.copy()
  
          freq = kwargs.pop("freq", None)
          if freq is not None:
              values.index = pd.date_range(
                  start="1959-01-01", periods=len(dta), freq=freq
              )
  
          # Test pandas exog
          if "exog" in kwargs:
              # Default value here is pd.Series object
              exog = np.log(values["realgdp"])
  
              # Also allow a check with a 1-dim numpy array
              if kwargs["exog"] == "numpy":
                  exog = exog.values.squeeze()
  
              kwargs["exog"] = exog
  
          # Create the model
          mod = UnobservedComponents(values["unemp"], **kwargs)
  
          # Smoke test for starting parameters, untransform, transform
          # Also test that transform and untransform are inverses
          mod.start_params
          roundtrip = mod.transform_params(
              mod.untransform_params(mod.start_params)
          )
          assert_allclose(mod.start_params, roundtrip)
  
          # Fit the model at the true parameters
          res_true = mod.filter(true["params"])
  
          # Check that the cycle bounds were computed correctly
          freqstr = (
              freq[0] if freq is not None else values.index.freqstr[0]
          )
          if "cycle_period_bounds" in kwargs:
              cycle_period_bounds = kwargs["cycle_period_bounds"]
          elif freqstr in ("A", "AS", "Y", "YS"):
              cycle_period_bounds = (1.5, 12)
          elif freqstr in ("Q", "QS"):
              cycle_period_bounds = (1.5 * 4, 12 * 4)
          elif freqstr in ("M", "MS"):
              cycle_period_bounds = (1.5 * 12, 12 * 12)
          else:
              # If we have no information on data frequency, require the
              # cycle frequency to be between 0 and pi
              cycle_period_bounds = (2, np.inf)
  
          # Test that the cycle frequency bound is correct
          assert_equal(
              mod.cycle_frequency_bound,
              (
                  2 * np.pi / cycle_period_bounds[1],
                  2 * np.pi / cycle_period_bounds[0],
              ),
          )
  
          # Test that the likelihood is correct
          rtol = true.get("rtol", 1e-7)
          atol = true.get("atol", 0)
  
          if use_exact_diffuse:
              # If we are using exact diffuse initialization, then we need to
              # adjust for the fact that KFAS does not include the constant in
              # the likelihood function for the diffuse periods
              # (see note to test_exact_diffuse_filtering.py for details).
              res_llf = (
                  res_true.llf_obs.sum()
                  + res_true.nobs_diffuse * 0.5 * np.log(2 * np.pi)
              )
          else:
              # If we are using approximate diffuse initialization, then we need
              # to ignore the first period, and this will agree with KFAS (since
              # it does not include the constant in the likelihood function for
              # diffuse periods).
              res_llf = res_true.llf_obs[
                  res_true.loglikelihood_burn :
              ].sum()
  
          assert_allclose(res_llf, true["llf"], rtol=rtol, atol=atol)
  
          # Optional smoke test for plot_components
          try:
              import matplotlib.pyplot as plt
  
              try:
                  from pandas.plotting import (
                      register_matplotlib_converters,
                  )
  
                  register_matplotlib_converters()
              except ImportError:
                  pass
              fig = plt.figure()
              res_true.plot_components(fig=fig)
          except ImportError:
              pass
  
          # Now fit the model via MLE
          with warnings.catch_warnings(record=True):
              fit_kwargs = {}
              if "maxiter" in true:
                  fit_kwargs["maxiter"] = true["maxiter"]
              res = mod.fit(
                  start_params=true.get("start_params", None),
                  disp=-1,
                  **fit_kwargs,
              )
              # If we found a higher likelihood, no problem; otherwise check
              # that we're very close to that found by R
  
              # See note above about these computation
              if use_exact_diffuse:
                  res_llf = (
                      res.llf_obs.sum()
                      + res.nobs_diffuse * 0.5 * np.log(2 * np.pi)
                  )
              else:
                  res_llf = res.llf_obs[
                      res_true.loglikelihood_burn :
                  ].sum()
  
              if res_llf <= true["llf"]:
                  assert_allclose(res_llf, true["llf"], rtol=1e-4)
  
              # Smoke test for summary
              res.summary()
  
imports: import warnings
  import numpy
  from numpy.testing import assert_equal, assert_allclose, assert_raises
  import pandas
  import pytest
  from statsmodels.datasets import macrodata
  from statsmodels.tools.sm_exceptions import SpecificationWarning
  from statsmodels.tsa.statespace import structural
  from statsmodels.tsa.statespace.structural import UnobservedComponents
  from statsmodels.tsa.statespace.tests.results import results_structural
label_desc: Use image node_id 1 for calling a global function with example usage: run_ucm(name, use_exact_diffuse) without return types