google-meridian 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

meridian/model/eda/eda_engine.py

@@ -48,9 +48,6 @@ _CORRELATION_MATRIX_NAME = 'correlation_matrix'
 _OVERALL_PAIRWISE_CORR_THRESHOLD = 0.999
 _GEO_PAIRWISE_CORR_THRESHOLD = 0.999
 _NATIONAL_PAIRWISE_CORR_THRESHOLD = 0.999
-_EMPTY_DF_FOR_EXTREME_CORR_PAIRS = pd.DataFrame(
-    columns=[_CORR_VAR1, _CORR_VAR2, _CORRELATION_COL_NAME]
-)
 _Q1_THRESHOLD = 0.25
 _Q3_THRESHOLD = 0.75
 _IQR_MULTIPLIER = 1.5
@@ -175,10 +172,22 @@ def _data_array_like(
   )
 
 
-def _stack_variables(
+def stack_variables(
     ds: xr.Dataset, coord_name: str = _STACK_VAR_COORD_NAME
 ) -> xr.DataArray:
-  """Stacks data variables other than time and geo into a single variable."""
+  """Stacks data variables of a Dataset into a single DataArray.
+
+  This function is designed to work with Datasets that have 'time' or 'geo'
+  dimensions, which are preserved. Other dimensions are stacked into a new
+  dimension.
+
+  Args:
+    ds: The input xarray.Dataset to stack.
+    coord_name: The name of the new coordinate for the stacked dimension.
+
+  Returns:
+    An xarray.DataArray with the specified dimensions stacked.
+  """
   dims = []
   coords = []
   sample_dims = []
@@ -249,37 +258,57 @@ def _find_extreme_corr_pairs(
   corr_tri = _get_upper_triangle_corr_mat(extreme_corr_da)
   extreme_corr_da = corr_tri.where(abs(corr_tri) > extreme_corr_threshold)
 
-  df = extreme_corr_da.to_dataframe(name=_CORRELATION_COL_NAME).dropna()
-  if df.empty:
-    return _EMPTY_DF_FOR_EXTREME_CORR_PAIRS.copy()
-  return df.sort_values(
-      by=_CORRELATION_COL_NAME, ascending=False, inplace=False
+  return (
+      extreme_corr_da.to_dataframe(name=_CORRELATION_COL_NAME)
+      .dropna()
+      .assign(**{
+          eda_constants.ABS_CORRELATION_COL_NAME: (
+              lambda x: x[_CORRELATION_COL_NAME].abs()
+          )
+      })
+      .sort_values(
+          by=eda_constants.ABS_CORRELATION_COL_NAME,
+          ascending=False,
+          inplace=False,
+      )
   )
 
 
-def _calculate_std(
+def _get_outlier_bounds(
     input_da: xr.DataArray,
-) -> tuple[xr.Dataset, pd.DataFrame]:
-  """Helper function to compute std with and without outliers.
+) -> tuple[xr.DataArray, xr.DataArray]:
+  """Computes lower and upper bounds for outliers across time using the IQR method.
 
   Args:
-    input_da: A DataArray for which to calculate the std.
+    input_da: A DataArray for which to calculate outlier bounds.
 
   Returns:
-    A tuple where the first element is a Dataset with two data variables:
-    'std_incl_outliers' and 'std_excl_outliers'. The second element is a
-    DataFrame with columns for variables, geo (if applicable), time, and
-    outlier values.
+    A tuple containing the lower and upper bounds of outliers as DataArrays.
   """
-  std_with_outliers = input_da.std(dim=constants.TIME, ddof=1)
-
   # TODO: Allow users to specify custom outlier definitions.
   q1 = input_da.quantile(_Q1_THRESHOLD, dim=constants.TIME)
   q3 = input_da.quantile(_Q3_THRESHOLD, dim=constants.TIME)
   iqr = q3 - q1
   lower_bound = q1 - _IQR_MULTIPLIER * iqr
   upper_bound = q3 + _IQR_MULTIPLIER * iqr
+  return lower_bound, upper_bound
+
+
+def _calculate_std(
+    input_da: xr.DataArray,
+) -> xr.Dataset:
+  """Helper function to compute std with and without outliers.
 
+  Args:
+    input_da: A DataArray for which to calculate the std.
+
+  Returns:
+    A Dataset with two data variables: 'std_with_outliers' and
+    'std_without_outliers'.
+  """
+  std_with_outliers = input_da.std(dim=constants.TIME, ddof=1)
+
+  lower_bound, upper_bound = _get_outlier_bounds(input_da)
   da_no_outlier = input_da.where(
       (input_da >= lower_bound) & (input_da <= upper_bound)
   )
@@ -289,17 +318,34 @@ def _calculate_std(
       _STD_WITH_OUTLIERS_VAR_NAME: std_with_outliers,
       _STD_WITHOUT_OUTLIERS_VAR_NAME: std_without_outliers,
   })
+  return std_ds
+
 
+def _calculate_outliers(
+    input_da: xr.DataArray,
+) -> pd.DataFrame:
+  """Helper function to extract outliers from a DataArray across time.
+
+  Args:
+    input_da: A DataArray from which to extract outliers.
+
+  Returns:
+    A DataFrame with columns for variables, geo (if applicable), time, and
+    outlier values.
+  """
+  lower_bound, upper_bound = _get_outlier_bounds(input_da)
   outlier_da = input_da.where(
       (input_da < lower_bound) | (input_da > upper_bound)
   )
-
-  outlier_df = outlier_da.to_dataframe(name=_OUTLIERS_COL_NAME).dropna()
-  outlier_df = outlier_df.assign(
-      **{_ABS_OUTLIERS_COL_NAME: np.abs(outlier_df[_OUTLIERS_COL_NAME])}
-  ).sort_values(by=_ABS_OUTLIERS_COL_NAME, ascending=False, inplace=False)
-
-  return std_ds, outlier_df
+  outlier_df = (
+      outlier_da.to_dataframe(name=_OUTLIERS_COL_NAME)
+      .dropna()
+      .assign(
+          **{_ABS_OUTLIERS_COL_NAME: lambda x: np.abs(x[_OUTLIERS_COL_NAME])}
+      )
+      .sort_values(by=_ABS_OUTLIERS_COL_NAME, ascending=False, inplace=False)
+  )
+  return outlier_df
 
 
 def _calculate_vif(input_da: xr.DataArray, var_dim: str) -> xr.DataArray:
@@ -315,7 +361,9 @@ def _calculate_vif(input_da: xr.DataArray, var_dim: str) -> xr.DataArray:
   """
   num_vars = input_da.sizes[var_dim]
   np_data = input_da.values.reshape(-1, num_vars)
-  np_data_with_const = sm.add_constant(np_data, prepend=True)
+  np_data_with_const = sm.add_constant(
+      np_data, prepend=True, has_constant='add'
+  )
 
   # Compute VIF for each variable excluding const which is the first one in the
   # 'variable' dimension.
@@ -332,6 +380,117 @@ def _calculate_vif(input_da: xr.DataArray, var_dim: str) -> xr.DataArray:
   return vif_da
 
 
+def _check_cost_media_unit_inconsistency(
+    cost_da: xr.DataArray,
+    media_units_da: xr.DataArray,
+) -> pd.DataFrame:
+  """Checks for inconsistencies between cost and media units.
+
+  Args:
+    cost_da: DataArray containing cost data.
+    media_units_da: DataArray containing media unit data.
+
+  Returns:
+    A DataFrame of inconsistencies where either cost is zero and media units
+    are
+    positive, or cost is positive and media units are zero.
+  """
+  cost_media_units_ds = xr.merge([cost_da, media_units_da])
+
+  # Condition 1: cost == 0 and media unit > 0
+  zero_cost_positive_mask = (cost_da == 0) & (media_units_da > 0)
+  zero_cost_positive_media_unit_df = (
+      cost_media_units_ds.where(zero_cost_positive_mask).to_dataframe().dropna()
+  )
+
+  # Condition 2: cost > 0 and media unit == 0
+  positive_cost_zero_mask = (cost_da > 0) & (media_units_da == 0)
+  positive_cost_zero_media_unit_df = (
+      cost_media_units_ds.where(positive_cost_zero_mask).to_dataframe().dropna()
+  )
+
+  return pd.concat(
+      [zero_cost_positive_media_unit_df, positive_cost_zero_media_unit_df]
+  )
+
+
+def _check_cost_per_media_unit(
+    cost_ds: xr.Dataset,
+    media_units_ds: xr.Dataset,
+    level: eda_outcome.AnalysisLevel,
+) -> eda_outcome.EDAOutcome[eda_outcome.CostPerMediaUnitArtifact]:
+  """Helper to check if the cost per media unit is valid."""
+  findings = []
+  # Stack variables with the same dimension name, so that they can be operated
+  # on together.
+  cost_da = stack_variables(cost_ds, constants.CHANNEL).rename(constants.SPEND)
+  media_units_da = stack_variables(media_units_ds, constants.CHANNEL).rename(
+      constants.MEDIA_UNITS
+  )
+
+  cost_media_unit_inconsistency_df = _check_cost_media_unit_inconsistency(
+      cost_da,
+      media_units_da,
+  )
+  if not cost_media_unit_inconsistency_df.empty:
+    findings.append(
+        eda_outcome.EDAFinding(
+            severity=eda_outcome.EDASeverity.ATTENTION,
+            explanation=(
+                'There are instances of inconsistent cost and media units.'
+                ' This occurs when cost is zero but media units are positive,'
+                ' or when cost is positive but media units are zero. Please'
+                ' review the outcome artifact for more details.'
+            ),
+        )
+    )
+
+  # Calculate cost per media unit
+  # Avoid division by zero by setting cost to NaN where media units are 0.
+  # Note that both (cost == media unit == 0) and (cost > 0 and media unit ==
+  # 0) result in NaN, while the latter one is not desired.
+  cost_per_media_unit_da = xr.where(
+      media_units_da == 0,
+      np.nan,
+      cost_da / media_units_da,
+  )
+  cost_per_media_unit_da.name = eda_constants.COST_PER_MEDIA_UNIT
+
+  outlier_df = _calculate_outliers(cost_per_media_unit_da)
+  if not outlier_df.empty:
+    findings.append(
+        eda_outcome.EDAFinding(
+            severity=eda_outcome.EDASeverity.ATTENTION,
+            explanation=(
+                'There are outliers in cost per media unit across time.'
+                ' Please review the outcome artifact for more details.'
+            ),
+        )
+    )
+
+  # If no specific findings, add an INFO finding.
+  if not findings:
+    findings.append(
+        eda_outcome.EDAFinding(
+            severity=eda_outcome.EDASeverity.INFO,
+            explanation='Please review the cost per media unit data.',
+        )
+    )
+
+  artifact = eda_outcome.CostPerMediaUnitArtifact(
+      level=level,
+      cost_per_media_unit_da=cost_per_media_unit_da,
+      cost_media_unit_inconsistency_df=cost_media_unit_inconsistency_df,
+      outlier_df=outlier_df,
+  )
+
+  return eda_outcome.EDAOutcome(
+      check_type=eda_outcome.EDACheckType.COST_PER_MEDIA_UNIT,
+      findings=findings,
+      analysis_artifacts=[artifact],
+  )
+
+
 class EDAEngine:
   """Meridian EDA Engine."""
 
@@ -354,6 +513,7 @@ class EDAEngine:
 
   @functools.cached_property
   def controls_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled controls data array."""
     if self._meridian.input_data.controls is None:
       return None
     controls_scaled_da = _data_array_like(
@@ -388,6 +548,7 @@ class EDAEngine:
 
   @functools.cached_property
   def media_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw media data array."""
     if self._meridian.input_data.media is None:
       return None
     raw_media_da = self._truncate_media_time(self._meridian.input_data.media)
@@ -396,6 +557,7 @@ class EDAEngine:
 
   @functools.cached_property
   def media_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled media data array."""
     if self._meridian.input_data.media is None:
       return None
     media_scaled_da = _data_array_like(
@@ -423,10 +585,11 @@ class EDAEngine:
   @functools.cached_property
   def national_media_spend_da(self) -> xr.DataArray | None:
     """Returns the national media spend data array."""
-    if self.media_spend_da is None:
+    media_spend = self.media_spend_da
+    if media_spend is None:
       return None
     if self._is_national_data:
-      national_da = self.media_spend_da.squeeze(constants.GEO, drop=True)
+      national_da = media_spend.squeeze(constants.GEO, drop=True)
       national_da.name = constants.NATIONAL_MEDIA_SPEND
     else:
       national_da = self._aggregate_and_scale_geo_da(
@@ -472,6 +635,7 @@ class EDAEngine:
 
   @functools.cached_property
   def organic_media_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw organic media data array."""
     if self._meridian.input_data.organic_media is None:
       return None
     raw_organic_media_da = self._truncate_media_time(
@@ -482,6 +646,7 @@ class EDAEngine:
 
   @functools.cached_property
   def organic_media_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled organic media data array."""
     if self._meridian.input_data.organic_media is None:
       return None
     organic_media_scaled_da = _data_array_like(
@@ -527,6 +692,7 @@ class EDAEngine:
 
   @functools.cached_property
   def non_media_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled non-media treatments data array."""
     if self._meridian.input_data.non_media_treatments is None:
       return None
     non_media_scaled_da = _data_array_like(
@@ -576,10 +742,11 @@ class EDAEngine:
   @functools.cached_property
   def national_rf_spend_da(self) -> xr.DataArray | None:
     """Returns the national RF spend data array."""
-    if self.rf_spend_da is None:
+    rf_spend = self.rf_spend_da
+    if rf_spend is None:
       return None
     if self._is_national_data:
-      national_da = self.rf_spend_da.squeeze(constants.GEO, drop=True)
+      national_da = rf_spend.squeeze(constants.GEO, drop=True)
       national_da.name = constants.NATIONAL_RF_SPEND
     else:
       national_da = self._aggregate_and_scale_geo_da(
@@ -601,12 +768,14 @@ class EDAEngine:
 
   @property
   def reach_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw reach data array."""
     if self._rf_data is None:
       return None
     return self._rf_data.reach_raw_da
 
   @property
   def reach_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled reach data array."""
     if self._rf_data is None:
       return None
     return self._rf_data.reach_scaled_da  # pytype: disable=attribute-error
@@ -627,6 +796,7 @@ class EDAEngine:
 
   @property
   def frequency_da(self) -> xr.DataArray | None:
+    """Returns the frequency data array."""
     if self._rf_data is None:
       return None
     return self._rf_data.frequency_da  # pytype: disable=attribute-error
@@ -640,19 +810,21 @@ class EDAEngine:
 
   @property
   def rf_impressions_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw RF impressions data array."""
     if self._rf_data is None:
       return None
-    return self._rf_data.rf_impressions_raw_da
+    return self._rf_data.rf_impressions_raw_da  # pytype: disable=attribute-error
 
   @property
   def national_rf_impressions_raw_da(self) -> xr.DataArray | None:
     """Returns the national raw RF impressions data array."""
     if self._rf_data is None:
       return None
-    return self._rf_data.national_rf_impressions_raw_da
+    return self._rf_data.national_rf_impressions_raw_da  # pytype: disable=attribute-error
 
   @property
   def rf_impressions_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled RF impressions data array."""
     if self._rf_data is None:
       return None
     return self._rf_data.rf_impressions_scaled_da
@@ -676,12 +848,14 @@ class EDAEngine:
 
   @property
   def organic_reach_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw organic reach data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.reach_raw_da
 
   @property
   def organic_reach_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled organic reach data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.reach_scaled_da  # pytype: disable=attribute-error
@@ -702,6 +876,7 @@ class EDAEngine:
 
   @property
   def organic_rf_impressions_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled organic RF impressions data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.rf_impressions_scaled_da
@@ -715,6 +890,7 @@ class EDAEngine:
 
   @property
   def organic_frequency_da(self) -> xr.DataArray | None:
+    """Returns the organic frequency data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.frequency_da  # pytype: disable=attribute-error
@@ -728,6 +904,7 @@ class EDAEngine:
 
   @property
   def organic_rf_impressions_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw organic RF impressions data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.rf_impressions_raw_da
@@ -741,6 +918,7 @@ class EDAEngine:
 
   @functools.cached_property
   def geo_population_da(self) -> xr.DataArray | None:
+    """Returns the geo population data array."""
     if self._is_national_data:
       return None
     return xr.DataArray(
@@ -752,6 +930,7 @@ class EDAEngine:
 
   @functools.cached_property
   def kpi_scaled_da(self) -> xr.DataArray:
+    """Returns the scaled KPI data array."""
     scaled_kpi_da = _data_array_like(
         da=self._meridian.input_data.kpi,
         values=self._meridian.kpi_scaled,
@@ -806,10 +985,42 @@ class EDAEngine:
     ]
     return xr.merge(to_merge, join='inner')
 
+  @functools.cached_property
+  def all_spend_ds(self) -> xr.Dataset:
+    """Returns a Dataset containing all spend data.
+
+    This includes media spend and rf spend.
+    """
+    to_merge = [
+        da
+        for da in [
+            self.media_spend_da,
+            self.rf_spend_da,
+        ]
+        if da is not None
+    ]
+    return xr.merge(to_merge, join='inner')
+
+  @functools.cached_property
+  def national_all_spend_ds(self) -> xr.Dataset:
+    """Returns a Dataset containing all national spend data.
+
+    This includes media spend and rf spend.
+    """
+    to_merge = [
+        da
+        for da in [
+            self.national_media_spend_da,
+            self.national_rf_spend_da,
+        ]
+        if da is not None
+    ]
+    return xr.merge(to_merge, join='inner')
+
   @functools.cached_property
   def _stacked_treatment_control_scaled_da(self) -> xr.DataArray:
     """Returns a stacked DataArray of treatment_control_scaled_ds."""
-    da = _stack_variables(self.treatment_control_scaled_ds)
+    da = stack_variables(self.treatment_control_scaled_ds)
     da.name = constants.TREATMENT_CONTROL_SCALED
     return da
 
@@ -837,10 +1048,26 @@ class EDAEngine:
   @functools.cached_property
   def _stacked_national_treatment_control_scaled_da(self) -> xr.DataArray:
     """Returns a stacked DataArray of national_treatment_control_scaled_ds."""
-    da = _stack_variables(self.national_treatment_control_scaled_ds)
+    da = stack_variables(self.national_treatment_control_scaled_ds)
     da.name = constants.NATIONAL_TREATMENT_CONTROL_SCALED
     return da
 
+  @functools.cached_property
+  def treatments_without_non_media_scaled_ds(self) -> xr.Dataset:
+    """Returns a Dataset of scaled treatments excluding non-media."""
+    return self.treatment_control_scaled_ds.drop_dims(
+        [constants.NON_MEDIA_CHANNEL, constants.CONTROL_VARIABLE],
+        errors='ignore',
+    )
+
+  @functools.cached_property
+  def national_treatments_without_non_media_scaled_ds(self) -> xr.Dataset:
+    """Returns a Dataset of national scaled treatments excluding non-media."""
+    return self.national_treatment_control_scaled_ds.drop_dims(
+        [constants.NON_MEDIA_CHANNEL, constants.CONTROL_VARIABLE],
+        errors='ignore',
+    )
+
   @functools.cached_property
   def all_reach_scaled_da(self) -> xr.DataArray | None:
     """Returns a DataArray containing all scaled reach data.
@@ -947,6 +1174,30 @@ class EDAEngine:
     da.name = constants.NATIONAL_ALL_FREQUENCY
     return da
 
+  @functools.cached_property
+  def paid_raw_media_units_ds(self) -> xr.Dataset:
+    to_merge = [
+        da
+        for da in [
+            self.media_raw_da,
+            self.rf_impressions_raw_da,
+        ]
+        if da is not None
+    ]
+    return xr.merge(to_merge, join='inner')
+
+  @functools.cached_property
+  def national_paid_raw_media_units_ds(self) -> xr.Dataset:
+    to_merge = [
+        da
+        for da in [
+            self.national_media_raw_da,
+            self.national_rf_impressions_raw_da,
+        ]
+        if da is not None
+    ]
+    return xr.merge(to_merge, join='inner')
+
   @property
   def _critical_checks(
       self,
@@ -1384,8 +1635,8 @@ class EDAEngine:
     """
     if self._is_national_data:
       return self.check_national_pairwise_corr()
-    else:
-      return self.check_geo_pairwise_corr()
+
+    return self.check_geo_pairwise_corr()
 
   def _check_std(
       self,
@@ -1393,10 +1644,11 @@ class EDAEngine:
       level: eda_outcome.AnalysisLevel,
       zero_std_message: str,
   ) -> tuple[
-      Optional[eda_outcome.EDAFinding], eda_outcome.StandardDeviationArtifact
+      eda_outcome.EDAFinding | None, eda_outcome.StandardDeviationArtifact
   ]:
     """Helper to check standard deviation."""
-    std_ds, outlier_df = _calculate_std(data)
+    std_ds = _calculate_std(data)
+    outlier_df = _calculate_outliers(data)
 
     finding = None
     if (std_ds[_STD_WITHOUT_OUTLIERS_VAR_NAME] < _STD_THRESHOLD).any():
@@ -1585,8 +1837,8 @@ class EDAEngine:
     """
     if self._is_national_data:
       return self.check_national_std()
-    else:
-      return self.check_geo_std()
+
+    return self.check_geo_std()
 
   def check_geo_vif(self) -> eda_outcome.EDAOutcome[eda_outcome.VIFArtifact]:
     """Computes geo-level variance inflation factor among treatments and controls."""
@@ -1737,8 +1989,8 @@ class EDAEngine:
     """
     if self._is_national_data:
       return self.check_national_vif()
-    else:
-      return self.check_geo_vif()
+
+    return self.check_geo_vif()
 
   @property
   def kpi_has_variability(self) -> bool:
@@ -1775,6 +2027,60 @@ class EDAEngine:
         analysis_artifacts=[self._overall_scaled_kpi_invariability_artifact],
     )
 
+  def check_geo_cost_per_media_unit(
+      self,
+  ) -> eda_outcome.EDAOutcome[eda_outcome.CostPerMediaUnitArtifact]:
+    """Checks if the cost per media unit is valid for geo data.
+
+    Returns:
+      An EDAOutcome object with findings and result values.
+
+    Raises:
+      GeoLevelCheckOnNationalModelError: If the check is called for a national
+        model.
+    """
+    if self._is_national_data:
+      raise GeoLevelCheckOnNationalModelError(
+          'check_geo_cost_per_media_unit is not supported for national models.'
+      )
+    return _check_cost_per_media_unit(
+        self.all_spend_ds,
+        self.paid_raw_media_units_ds,
+        eda_outcome.AnalysisLevel.GEO,
+    )
+
+  def check_national_cost_per_media_unit(
+      self,
+  ) -> eda_outcome.EDAOutcome[eda_outcome.CostPerMediaUnitArtifact]:
+    """Checks if the cost per media unit is valid for national data.
+
+    Returns:
+      An EDAOutcome object with findings and result values.
+    """
+    return _check_cost_per_media_unit(
+        self.national_all_spend_ds,
+        self.national_paid_raw_media_units_ds,
+        eda_outcome.AnalysisLevel.NATIONAL,
+    )
+
+  def check_cost_per_media_unit(
+      self,
+  ) -> eda_outcome.EDAOutcome[eda_outcome.CostPerMediaUnitArtifact]:
+    """Checks if the cost per media unit is valid.
+
+    This function checks the following conditions:
+    1. cost == 0 and media unit > 0.
+    2. cost > 0 and media unit == 0.
+    3. cost_per_media_unit has outliers.
+
+    Returns:
+      An EDAOutcome object with findings and result values.
+    """
+    if self._is_national_data:
+      return self.check_national_cost_per_media_unit()
+
+    return self.check_geo_cost_per_media_unit()
+
   def run_all_critical_checks(self) -> list[eda_outcome.EDAOutcome]:
     """Runs all critical EDA checks.
 
@@ -1790,7 +2096,9 @@ class EDAEngine:
       except Exception as e:  # pylint: disable=broad-except
         error_finding = eda_outcome.EDAFinding(
             severity=eda_outcome.EDASeverity.ERROR,
-            explanation=f'An error occurred during check {check.__name__}: {e}',
+            explanation=(
+                f'An error occurred during running {check.__name__}: {e!r}'
+            ),
         )
         outcomes.append(
             eda_outcome.EDAOutcome(