code: def summary_with_hessian(self, transformed=True):
      ses = np.power(np.abs(np.diag(self.ihessian)), 0.5)
      t_z = self.z.get_z_values(transformed=True)
      t_p_std = ses.copy()  # vector for transformed standard errors
  
      # Create transformed variables
      # for k in range(len(t_z)-self.z_hide):
      #    z_temp = (self.z_values[k]/float(ses[k]))
      #    t_p_std[k] = t_z[k] / z_temp
  
      data = []
  
      for i in range(len(self.z.z_list) - int(self.z_hide)):
          if self.z.z_list[i].prior.transform == np.array:
              data.append(
                  {
                      "z_name": self.z.z_list[i].name,
                      "z_value": np.round(
                          self.z.z_list[i].prior.transform(
                              self.z_values[i]
                          ),
                          self.rounding_points,
                      ),
                      "z_std": np.round(
                          t_p_std[i], self.rounding_points
                      ),
                      "z_z": np.round(
                          t_z[i] / float(t_p_std[i]),
                          self.rounding_points,
                      ),
                      "z_p": np.round(
                          find_p_value(t_z[i] / float(t_p_std[i])),
                          self.rounding_points,
                      ),
                      "ci": "("
                      + str(
                          np.round(
                              t_z[i] - t_p_std[i] * 1.96,
                              self.rounding_points,
                          )
                      )
                      + " | "
                      + str(
                          np.round(
                              t_z[i] + t_p_std[i] * 1.96,
                              self.rounding_points,
                          )
                      )
                      + ")",
                  }
              )
          else:
              if transformed is True:
                  data.append(
                      {
                          "z_name": self.z.z_list[i].name,
                          "z_value": np.round(
                              self.z.z_list[i].prior.transform(
                                  self.z_values[i]
                              ),
                              self.rounding_points,
                          ),
                      }
                  )
              else:
                  data.append(
                      {
                          "z_name": self.z.z_list[
                              i
                          ].prior.itransform_name
                          + "("
                          + self.z.z_list[i].name
                          + ")",
                          "z_value": np.round(
                              self.z_values[i], self.rounding_points
                          ),
                          "z_std": np.round(
                              t_p_std[i], self.rounding_points
                          ),
                          "z_z": np.round(
                              t_z[i] / float(t_p_std[i]),
                              self.rounding_points,
                          ),
                          "z_p": np.round(
                              find_p_value(t_z[i] / float(t_p_std[i])),
                              self.rounding_points,
                          ),
                          "ci": "("
                          + str(
                              np.round(
                                  t_z[i] - t_p_std[i] * 1.96,
                                  self.rounding_points,
                              )
                          )
                          + " | "
                          + str(
                              np.round(
                                  t_z[i] + t_p_std[i] * 1.96,
                                  self.rounding_points,
                              )
                          )
                          + ")",
                      }
                  )
  
      fmt = [
          ("Latent Variable", "z_name", 40),
          ("Estimate", "z_value", 10),
          ("Std Error", "z_std", 10),
          ("z", "z_z", 8),
          ("P>|z|", "z_p", 8),
          ("95% C.I.", "ci", 25),
      ]
  
      model_details = []
  
      model_fmt = [
          (self.model_name, "model_details", 55),
          ("", "model_results", 50),
      ]
  
      if self.method == "MLE" or self.method == "OLS":
          obj_desc = "Log Likelihood: " + str(
              np.round(-self.objective_object(self.z_values), 4)
          )
      else:
          obj_desc = "Unnormalized Log Posterior: " + str(
              np.round(-self.objective_object(self.z_values), 4)
          )
  
      model_details.append(
          {
              "model_details": "Dependent Variable: "
              + str(self.data_name),
              "model_results": "Method: " + str(self.method),
          }
      )
      model_details.append(
          {
              "model_details": "Start Date: "
              + str(self.index[self.max_lag]),
              "model_results": obj_desc,
          }
      )
      model_details.append(
          {
              "model_details": "End Date: " + str(self.index[-1]),
              "model_results": "AIC: "
              + str(
                  np.round(
                      2 * len(self.z_values)
                      + 2 * self.objective_object(self.z_values),
                      4,
                  )
              ),
          }
      )
      model_details.append(
          {
              "model_details": "Number of observations: "
              + str(self.data_length),
              "model_results": "BIC: "
              + str(
                  np.round(
                      2 * self.objective_object(self.z_values)
                      + len(self.z_values) * np.log(self.data_length),
                      4,
                  )
              ),
          }
      )
  
      print(TablePrinter(model_fmt, ul="=")(model_details))
      print("=" * 106)
      print(TablePrinter(fmt, ul="=")(data))
      print("=" * 106)
      if "Skewt" in self.model_name:
          print(
              "WARNING: Skew t distribution is not well-suited for MLE or MAP inference"
          )
          print(
              "Workaround 1: Use a t-distribution instead for MLE/MAP"
          )
          print(
              "Workaround 2: Use M-H or BBVI inference for Skew t distribution"
          )
  
imports: import numpy
  from .output import TablePrinter
  from .tests import find_p_value
  from .inference import norm_post_sim
label_desc: Use image node_id 4 for calling the MLEResults obj's underlying member method code with example usage: obj.summary_with_hessian(transformed) without return types