google-meridian 1.2.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

meridian/analysis/optimizer.py

@@ -26,7 +26,7 @@ import altair as alt
 import jinja2
 from meridian import backend
 from meridian import constants as c
-from meridian.analysis import analyzer
+from meridian.analysis import analyzer as analyzer_module
 from meridian.analysis import formatter
 from meridian.analysis import summary_text
 from meridian.data import time_coordinates as tc
@@ -114,7 +114,11 @@ class OptimizationGrid:
       does not contain reach and frequency data, or if the model does contain
       reach and frequency data, but historical frequency is used for the
       optimization scenario.
-    selected_times: The time coordinates from the model used in this grid.
+    selected_times: The time coordinates from the model used in this grid. If
+      new data with modified time coordinates is used for optimization, this
+      is a list of booleans indicating which time coordinates are selected.
+      Otherwise, this is a list of strings indicating the time coordinates used
+      in this grid.
   """
 
   _grid_dataset: xr.Dataset
@@ -128,7 +132,7 @@ class OptimizationGrid:
   gtol: float
   round_factor: int
   optimal_frequency: np.ndarray | None
-  selected_times: Sequence[str] | None
+  selected_times: Sequence[str] | Sequence[bool] | None
 
   @property
   def grid_dataset(self) -> xr.Dataset:
@@ -438,40 +442,33 @@ class OptimizationResults:
   """The optimized budget allocation.
 
   This is a dataclass object containing datasets output from `BudgetOptimizer`.
-  These datasets include:
 
-  - `nonoptimized_data`: The non-optimized budget metrics (based on historical
-    frequency).
-  - `nonoptimized_data_with_optimal_freq`: The non-optimized budget metrics
-    based on optimal frequency.
-  - `optimized_data`: The optimized budget metrics.
-  - `optimization_grid`: The grid information used for optimization.
-
-  The metrics (data variables) are: ROI, mROI, incremental outcome, CPIK.
-
-  Additionally, some intermediate values and referecences to the source fitted
-  model and analyzer are also stored here. These are useful for visualizing and
-  debugging.
+  The performance metrics (data variables) are: spend, percentage of spend, ROI,
+  mROI, incremental outcome, CPIK, and effectiveness.
 
   Attributes:
     meridian: The fitted Meridian model that was used to create this budget
       allocation.
     analyzer: The analyzer bound to the model above.
-    spend_ratio: The spend ratio used to scale the non-optimized budget metrics
-      to the optimized budget metrics.
-    spend_bounds: The spend bounds used to scale the non-optimized budget
-      metrics to the optimized budget metrics.
-    nonoptimized_data: The non-optimized budget metrics (based on historical
-      frequency).
-    nonoptimized_data_with_optimal_freq: The non-optimized budget metrics based
-      on optimal frequency.
-    optimized_data: The optimized budget metrics.
+    spend_ratio: The spend ratio used to scale the non-optimized performance
+      metrics to the optimized performance metrics.
+    spend_bounds: The spend bounds used to scale the non-optimized performance
+      metrics to the optimized performance metrics.
+    nonoptimized_data: Performance metrics under the non-optimized budget. For
+      R&F channels, the non-optimized frequency is used.
+    nonoptimized_data_with_optimal_freq: Performance metrics under the
+      non-optimized budget. For R&F channels, the optimal frequency is used if
+      frequency was optimized.
+    optimized_data: Performance metrics under the optimized budget. For R&F
+      channels, the optimal frequency is used if frequency was optimized.
     optimization_grid: The grid information used for optimization.
+    new_data: The optional `DataTensors` container that was used to create this
+      budget allocation.
   """
 
   meridian: model.Meridian
   # The analyzer bound to the model above.
-  analyzer: analyzer.Analyzer
+  analyzer: analyzer_module.Analyzer
   spend_ratio: np.ndarray  # spend / historical spend
   spend_bounds: tuple[np.ndarray, np.ndarray]
 
@@ -481,6 +478,10 @@ class OptimizationResults:
   _optimized_data: xr.Dataset
   _optimization_grid: OptimizationGrid
 
+  # The optional `DataTensors` container to use if optimization was performed
+  # on data different from the original `input_data`.
+  new_data: analyzer_module.DataTensors | None = None
+
   # TODO: Move this, and the plotting methods, to a summarizer.
   @functools.cached_property
   def template_env(self) -> jinja2.Environment:
@@ -497,10 +498,10 @@ class OptimizationResults:
 
   @property
   def nonoptimized_data(self) -> xr.Dataset:
-    """Dataset holding the non-optimized budget metrics.
+    """Dataset holding the non-optimized performance metrics.
 
     For channels that have reach and frequency data, their performance metrics
-    (ROI, mROI, incremental outcome, CPIK) are based on historical frequency.
+    are based on historical frequency.
 
     The dataset contains the following:
 
@@ -519,10 +520,10 @@ class OptimizationResults:
 
   @property
   def nonoptimized_data_with_optimal_freq(self) -> xr.Dataset:
-    """Dataset holding the non-optimized budget metrics.
+    """Dataset holding the non-optimized performance metrics.
 
     For channels that have reach and frequency data, their performance metrics
-    (ROI, mROI, incremental outcome, CPIK) are based on optimal frequency.
+    are based on optimal frequency.
 
     The dataset contains the following:
 
@@ -537,10 +538,10 @@ class OptimizationResults:
 
   @property
   def optimized_data(self) -> xr.Dataset:
-    """Dataset holding the optimized budget metrics.
+    """Dataset holding the optimized performance metrics.
 
     For channels that have reach and frequency data, their performance metrics
-    (ROI, mROI, incremental outcome) are based on optimal frequency.
+    are based on optimal frequency.
 
     The dataset contains the following:
 
@@ -894,9 +895,12 @@ class OptimizationResults:
       returned this result.
     """
     channels = self.optimized_data.channel.values
-    selected_times = self.meridian.expand_selected_time_dims(
+    selected_times = _expand_selected_times(
+        meridian=self.meridian,
         start_date=self.optimized_data.start_date,
         end_date=self.optimized_data.end_date,
+        new_data=self.new_data,
+        return_flexible_str=True,
     )
     _, ubounds = self.spend_bounds
     upper_bound = (
@@ -912,6 +916,7 @@ class OptimizationResults:
     # WARN: If `selected_times` is not None (i.e. a subset time range), this
     # response curve computation might take a significant amount of time.
     return self.analyzer.response_curves(
+        new_data=self.new_data,
         spend_multipliers=spend_multiplier,
         use_posterior=self.optimization_grid.use_posterior,
         selected_times=selected_times,
@@ -1276,7 +1281,7 @@ class BudgetOptimizer:
 
   def __init__(self, meridian: model.Meridian):
     self._meridian = meridian
-    self._analyzer = analyzer.Analyzer(self._meridian)
+    self._analyzer = analyzer_module.Analyzer(self._meridian)
 
   def _validate_model_fit(self, use_posterior: bool):
     """Validates that the model is fit."""
@@ -1288,7 +1293,7 @@ class BudgetOptimizer:
 
   def optimize(
       self,
-      new_data: analyzer.DataTensors | None = None,
+      new_data: analyzer_module.DataTensors | None = None,
       use_posterior: bool = True,
       # TODO: b/409550413 - Remove this argument.
       selected_times: tuple[str | None, str | None] | None = None,
@@ -1526,7 +1531,7 @@ class BudgetOptimizer:
     use_historical_budget = budget is None or np.isclose(
         budget, np.sum(optimization_grid.historical_spend)
     )
-    new_data = new_data or analyzer.DataTensors()
+    new_data = new_data or analyzer_module.DataTensors()
     nonoptimized_data = self._create_budget_dataset(
         new_data=new_data.filter_fields(c.PAID_DATA + (c.TIME,)),
         use_posterior=use_posterior,
@@ -1595,6 +1600,7 @@ class BudgetOptimizer:
     )
 
     return OptimizationResults(
+        new_data=new_data,
         meridian=self._meridian,
         analyzer=self._analyzer,
         spend_ratio=spend_ratio,
@@ -1617,7 +1623,7 @@ class BudgetOptimizer:
       rf_spend: backend.Tensor | None = None,
       revenue_per_kpi: backend.Tensor | None = None,
       use_optimal_frequency: bool = True,
-  ) -> analyzer.DataTensors:
+  ) -> analyzer_module.DataTensors:
     """Creates a `DataTensors` for optimizations from CPM and flighting data.
 
     CPM is broken down into cost per media unit, `cpmu`, for the media channels
@@ -1739,11 +1745,11 @@ class BudgetOptimizer:
     if revenue_per_kpi is not None:
       tensors[c.REVENUE_PER_KPI] = revenue_per_kpi
     tensors[c.TIME] = backend.to_tensor(time)
-    return analyzer.DataTensors(**tensors)
+    return analyzer_module.DataTensors(**tensors)
 
   def _validate_grid(
       self,
-      new_data: analyzer.DataTensors | None,
+      new_data: analyzer_module.DataTensors | None,
       use_posterior: bool,
       start_date: tc.Date,
       end_date: tc.Date,
@@ -1799,7 +1805,7 @@ class BudgetOptimizer:
       return False
 
     if new_data is None:
-      new_data = analyzer.DataTensors()
+      new_data = analyzer_module.DataTensors()
     required_tensors = c.PERFORMANCE_DATA + (c.TIME,)
     filled_data = new_data.validate_and_fill_missing_data(
         required_tensors_names=required_tensors, meridian=self._meridian
@@ -1815,7 +1821,8 @@ class BudgetOptimizer:
       return False
 
     n_channels = len(optimization_grid.channels)
-    selected_times = self._validate_selected_times(
+    selected_times = _expand_selected_times(
+        meridian=self._meridian,
         start_date=start_date,
         end_date=end_date,
         new_data=new_data,
@@ -1961,7 +1968,7 @@ class BudgetOptimizer:
     """
     self._validate_model_fit(use_posterior)
     if new_data is None:
-      new_data = analyzer.DataTensors()
+      new_data = analyzer_module.DataTensors()
 
     if selected_times is not None:
       warnings.warn(
@@ -1978,7 +1985,8 @@ class BudgetOptimizer:
     filled_data = new_data.validate_and_fill_missing_data(
         required_tensors_names=required_tensors, meridian=self._meridian
     )
-    selected_times = self._validate_selected_times(
+    selected_times = _expand_selected_times(
+        meridian=self._meridian,
         start_date=start_date,
         end_date=end_date,
         new_data=filled_data,
@@ -2008,7 +2016,7 @@ class BudgetOptimizer:
         )
     )
     if self._meridian.n_rf_channels > 0 and use_optimal_frequency:
-      opt_freq_data = analyzer.DataTensors(
+      opt_freq_data = analyzer_module.DataTensors(
           rf_impressions=filled_data.reach * filled_data.frequency,
           rf_spend=filled_data.rf_spend,
           revenue_per_kpi=filled_data.revenue_per_kpi,
@@ -2098,38 +2106,11 @@ class BudgetOptimizer:
         attrs={c.SPEND_STEP_SIZE: spend_step_size},
     )
 
-  def _validate_selected_times(
-      self,
-      start_date: tc.Date,
-      end_date: tc.Date,
-      new_data: analyzer.DataTensors | None,
-  ) -> Sequence[str] | Sequence[bool] | None:
-    """Validates and returns the selected times."""
-    if start_date is None and end_date is None:
-      return None
-
-    new_data = new_data or analyzer.DataTensors()
-    if new_data.get_modified_times(self._meridian) is None:
-      return self._meridian.expand_selected_time_dims(
-          start_date=start_date,
-          end_date=end_date,
-      )
-    else:
-      assert new_data.time is not None
-      new_times_str = np.asarray(new_data.time).astype(str).tolist()
-      time_coordinates = tc.TimeCoordinates.from_dates(new_times_str)
-      expanded_dates = time_coordinates.expand_selected_time_dims(
-          start_date=start_date,
-          end_date=end_date,
-      )
-      expanded_str = [date.strftime(c.DATE_FORMAT) for date in expanded_dates]
-      return [x in expanded_str for x in new_times_str]
-
   def _get_incremental_outcome_tensors(
       self,
       hist_spend: np.ndarray,
       spend: np.ndarray,
-      new_data: analyzer.DataTensors | None = None,
+      new_data: analyzer_module.DataTensors | None = None,
       optimal_frequency: Sequence[float] | None = None,
   ) -> tuple[
       backend.Tensor | None,
@@ -2165,7 +2146,7 @@ class BudgetOptimizer:
     Returns:
       Tuple of backend.tensors (new_media, new_reach, new_frequency).
     """
-    new_data = new_data or analyzer.DataTensors()
+    new_data = new_data or analyzer_module.DataTensors()
     filled_data = new_data.validate_and_fill_missing_data(
         c.PAID_CHANNELS,
         self._meridian,
@@ -2206,7 +2187,7 @@ class BudgetOptimizer:
       self,
       hist_spend: np.ndarray,
       spend: np.ndarray,
-      new_data: analyzer.DataTensors | None = None,
+      new_data: analyzer_module.DataTensors | None = None,
       use_posterior: bool = True,
       use_kpi: bool = False,
       start_date: tc.Date = None,
@@ -2218,13 +2199,16 @@ class BudgetOptimizer:
       use_historical_budget: bool = True,
   ) -> xr.Dataset:
     """Creates the budget dataset."""
-    new_data = new_data or analyzer.DataTensors()
+    new_data = new_data or analyzer_module.DataTensors()
     filled_data = new_data.validate_and_fill_missing_data(
         c.PAID_DATA + (c.TIME,),
         self._meridian,
     )
-    selected_times = self._validate_selected_times(
-        start_date=start_date, end_date=end_date, new_data=new_data
+    selected_times = _expand_selected_times(
+        meridian=self._meridian,
+        start_date=start_date,
+        end_date=end_date,
+        new_data=new_data,
     )
     spend_tensor = backend.to_tensor(spend, dtype=backend.float32)
     hist_spend = backend.to_tensor(hist_spend, dtype=backend.float32)
@@ -2237,7 +2221,7 @@ class BudgetOptimizer:
         )
     )
     budget = np.sum(spend_tensor)
-    inc_outcome_data = analyzer.DataTensors(
+    inc_outcome_data = analyzer_module.DataTensors(
         media=new_media,
         reach=new_reach,
         frequency=new_frequency,
@@ -2269,7 +2253,7 @@ class BudgetOptimizer:
     # shape (n_channels, n_metrics) where n_metrics = 4 for (mean, median,
     # ci_lo, and ci_hi)
     incremental_outcome_with_mean_median_and_ci = (
-        analyzer.get_central_tendency_and_ci(
+        analyzer_module.get_central_tendency_and_ci(
             data=incremental_outcome,
             confidence_level=confidence_level,
             include_median=True,
@@ -2281,7 +2265,7 @@ class BudgetOptimizer:
     )
 
     aggregated_impressions = self._analyzer.get_aggregated_impressions(
-        new_data=analyzer.DataTensors(
+        new_data=analyzer_module.DataTensors(
             media=new_media, reach=new_reach, frequency=new_frequency
         ),
         selected_times=selected_times,
@@ -2292,7 +2276,7 @@ class BudgetOptimizer:
         include_non_paid_channels=False,
     )
     effectiveness_with_mean_median_and_ci = (
-        analyzer.get_central_tendency_and_ci(
+        analyzer_module.get_central_tendency_and_ci(
             data=backend.divide_no_nan(
                 incremental_outcome, aggregated_impressions
             ),
@@ -2301,12 +2285,12 @@ class BudgetOptimizer:
         )
     )
 
-    roi = analyzer.get_central_tendency_and_ci(
+    roi = analyzer_module.get_central_tendency_and_ci(
         data=backend.divide_no_nan(incremental_outcome, spend_tensor),
         confidence_level=confidence_level,
         include_median=True,
     )
-    marginal_roi = analyzer.get_central_tendency_and_ci(
+    marginal_roi = analyzer_module.get_central_tendency_and_ci(
         data=backend.divide_no_nan(
             mroi_numerator, spend_tensor * incremental_increase
         ),
@@ -2314,7 +2298,7 @@ class BudgetOptimizer:
         include_median=True,
     )
 
-    cpik = analyzer.get_central_tendency_and_ci(
+    cpik = analyzer_module.get_central_tendency_and_ci(
         data=backend.divide_no_nan(spend_tensor, incremental_outcome),
         confidence_level=confidence_level,
         include_median=True,
@@ -2374,7 +2358,7 @@ class BudgetOptimizer:
       i: int,
       incremental_outcome_grid: np.ndarray,
       multipliers_grid: backend.Tensor,
-      new_data: analyzer.DataTensors | None = None,
+      new_data: analyzer_module.DataTensors | None = None,
       selected_times: Sequence[str] | Sequence[bool] | None = None,
       use_posterior: bool = True,
       use_kpi: bool = False,
@@ -2416,7 +2400,7 @@ class BudgetOptimizer:
         reducing `batch_size`. The calculation will generally be faster with
         larger `batch_size` values.
     """
-    new_data = new_data or analyzer.DataTensors()
+    new_data = new_data or analyzer_module.DataTensors()
     filled_data = new_data.validate_and_fill_missing_data(
         c.PAID_DATA, self._meridian
     )
@@ -2455,7 +2439,7 @@ class BudgetOptimizer:
         np.asarray(
             self._analyzer.incremental_outcome(
                 use_posterior=use_posterior,
-                new_data=analyzer.DataTensors(
+                new_data=analyzer_module.DataTensors(
                     media=new_media,
                     reach=new_reach,
                     frequency=new_frequency,
@@ -2477,7 +2461,7 @@ class BudgetOptimizer:
       spend_bound_lower: np.ndarray,
       spend_bound_upper: np.ndarray,
       step_size: int,
-      new_data: analyzer.DataTensors | None = None,
+      new_data: analyzer_module.DataTensors | None = None,
       selected_times: Sequence[str] | Sequence[bool] | None = None,
       use_posterior: bool = True,
       use_kpi: bool = False,
@@ -2958,3 +2942,63 @@ def _expand_tensor(tensor: backend.Tensor, required_shape: tuple[int, ...]):
       f'Cannot expand tensor with shape {tensor.shape} to target'
       f' {required_shape}.'
   )
+
+
+def _expand_selected_times(
+    meridian: model.Meridian,
+    start_date: tc.Date,
+    end_date: tc.Date,
+    new_data: analyzer_module.DataTensors | None,
+    return_flexible_str: bool = False,
+) -> Sequence[str] | Sequence[bool] | None:
+  """Creates selected_times from start_date and end_date.
+
+  This function creates `selected_times` argument based on `start_date`,
+  `end_date` and `new_data`. If `new_data` is not used or used with unmodified
+  times, dates are selected from `meridian.input_data.time`. In the flexible
+  time scenario, when `new_data` is provided with modified times, dates are
+  selected from `new_data.time`. In this case, `new_data.time` must be provided
+  and the function returns a list of booleans.
+
+  Args:
+    meridian: The `Meridian` object with original data.
+    start_date: Start date of the selected time period.
+    end_date: End date of the selected time period.
+    new_data: The optional `DataTensors` object. If times are modified in
+      `new_data`, then `new_data.time` must be provided.
+    return_flexible_str: Whether to return a list of strings or a list of
+      booleans in case time is modified in `new_data`.
+
+  Returns:
+    If both `start_date` and `end_date` are `None`, returns `None`. If
+    `new_data` is not used or used with unmodified times, returns a list of
+    strings with selected dates. If `new_data` is used with modified times,
+    returns a list of strings or a list of booleans depending on the
+    `return_flexible_str` argument.
+  """
+  if start_date is None and end_date is None:
+    return None
+
+  new_data = new_data or analyzer_module.DataTensors()
+  if new_data.get_modified_times(meridian) is None:
+    return meridian.expand_selected_time_dims(
+        start_date=start_date,
+        end_date=end_date,
+    )
+  else:
+    assert new_data.time is not None
+    new_times_str = np.asarray(new_data.time).astype(str).tolist()
+    time_coordinates = tc.TimeCoordinates.from_dates(new_times_str)
+    expanded_dates = time_coordinates.expand_selected_time_dims(
+        start_date=start_date,
+        end_date=end_date,
+    )
+    if return_flexible_str:
+      if expanded_dates is None:
+        expanded_dates = time_coordinates.all_dates
+      expanded_str = [date.strftime(c.DATE_FORMAT) for date in expanded_dates]
+      return [x for x in new_times_str if x in expanded_str]
+    # TODO: Remove once every method uses `new_data.time`.
+    else:
+      expanded_str = [date.strftime(c.DATE_FORMAT) for date in expanded_dates]
+      return [x in expanded_str for x in new_times_str]

meridian/analysis/summarizer.py

@@ -77,6 +77,7 @@ class Summarizer:
       filepath: str,
       start_date: tc.Date = None,
       end_date: tc.Date = None,
+      use_kpi: bool = False,
   ):
     """Generates and saves the HTML results summary output.
 
@@ -86,15 +87,18 @@ class Summarizer:
       start_date: Optional start date selector, *inclusive*, in _yyyy-mm-dd_
         format.
       end_date: Optional end date selector, *inclusive* in _yyyy-mm-dd_ format.
+      use_kpi: If `True`, calculate the incremental KPI. Otherwise, calculate
+        the incremental revenue using the revenue per KPI (if available).
     """
     os.makedirs(filepath, exist_ok=True)
     with open(os.path.join(filepath, filename), 'w') as f:
-      f.write(self._gen_model_results_summary(start_date, end_date))
+      f.write(self._gen_model_results_summary(start_date, end_date, use_kpi))
 
   def _gen_model_results_summary(
       self,
       start_date: tc.Date = None,
       end_date: tc.Date = None,
+      use_kpi: bool = False,
   ) -> str:
     """Generate HTML results summary output (as sanitized content str)."""
     all_dates = self._meridian.input_data.time_coordinates.all_dates
@@ -140,6 +144,7 @@ class Summarizer:
     cards_htmls = self._create_cards_htmls(
         template_env,
         selected_times=selected_times,
+        use_kpi=use_kpi,
     )
 
     return html_template.render(
@@ -150,6 +155,7 @@ class Summarizer:
       self,
       template_env: jinja2.Environment,
       selected_times: Sequence[str] | None,
+      use_kpi: bool,
   ) -> Sequence[str]:
     """Creates the HTML snippets for cards in the summary page."""
     media_summary = visualizer.MediaSummary(
@@ -165,10 +171,13 @@ class Summarizer:
     )
     cards = [
         self._create_model_fit_card_html(
-            template_env, selected_times=selected_times
+            template_env, selected_times=selected_times, use_kpi=use_kpi
         ),
         self._create_outcome_contrib_card_html(
-            template_env, media_summary, selected_times=selected_times
+            template_env,
+            media_summary,
+            selected_times=selected_times,
+            use_kpi=use_kpi,
         ),
         self._create_performance_breakdown_card_html(
             template_env, media_summary
@@ -179,16 +188,17 @@ class Summarizer:
             media_summary=media_summary,
             media_effects=media_effects,
             reach_frequency=reach_frequency,
+            use_kpi=use_kpi,
         ),
     ]
     return cards
 
   def _create_model_fit_card_html(
-      self, template_env: jinja2.Environment, **kwargs
+      self, template_env: jinja2.Environment, use_kpi: bool, **kwargs
   ) -> str:
     """Creates the HTML snippet for the Model Fit card."""
     model_fit = self._model_fit
-    outcome = self._kpi_or_revenue()
+    outcome = self._kpi_or_revenue(use_kpi)
     expected_actual_outcome_chart = formatter.ChartSpec(
         id=summary_text.EXPECTED_ACTUAL_OUTCOME_CHART_ID,
         description=summary_text.EXPECTED_ACTUAL_OUTCOME_CHART_DESCRIPTION_FORMAT.format(
@@ -197,7 +207,9 @@ class Summarizer:
         chart_json=model_fit.plot_model_fit(**kwargs).to_json(),
     )
 
-    predictive_accuracy_table = self._predictive_accuracy_table_spec(**kwargs)
+    predictive_accuracy_table = self._predictive_accuracy_table_spec(
+        use_kpi=use_kpi, **kwargs
+    )
     insights = summary_text.MODEL_FIT_INSIGHTS_FORMAT
 
     return formatter.create_card_html(
@@ -207,9 +219,11 @@ class Summarizer:
         [expected_actual_outcome_chart, predictive_accuracy_table],
     )
 
-  def _predictive_accuracy_table_spec(self, **kwargs) -> formatter.TableSpec:
+  def _predictive_accuracy_table_spec(
+      self, use_kpi: bool, **kwargs
+  ) -> formatter.TableSpec:
     """Creates the HTML snippet for the predictive accuracy table."""
-    outcome = self._kpi_or_revenue()
+    outcome = self._kpi_or_revenue(use_kpi)
     model_diag = self._model_diagnostics
     table = model_diag.predictive_accuracy_table(column_var=c.METRIC, **kwargs)
 
@@ -270,9 +284,10 @@ class Summarizer:
       template_env: jinja2.Environment,
       media_summary: visualizer.MediaSummary,
       selected_times: Sequence[str] | None,
+      use_kpi: bool,
   ) -> str:
     """Creates the HTML snippet for the Outcome Contrib card."""
-    outcome = self._kpi_or_revenue()
+    outcome = self._kpi_or_revenue(use_kpi)
 
     num_selected_times = (
         self._meridian.n_times
@@ -442,9 +457,10 @@ class Summarizer:
       media_summary: visualizer.MediaSummary,
       media_effects: visualizer.MediaEffects,
       reach_frequency: visualizer.ReachAndFrequency | None,
+      use_kpi: bool,
   ) -> str:
     """Creates the HTML snippet for the Optimal Analyst card."""
-    outcome = self._kpi_or_revenue()
+    outcome = self._kpi_or_revenue(use_kpi)
     charts = []
     charts.append(
         formatter.ChartSpec(
@@ -457,6 +473,7 @@ class Summarizer:
                 selected_times=(
                     frozenset(selected_times) if selected_times else None
                 ),
+                use_kpi=use_kpi,
                 plot_separately=False,
                 include_ci=False,
                 num_channels_displayed=7,
@@ -524,9 +541,7 @@ class Summarizer:
         rf_channel=most_spend_rf_channel
     ).optimal_frequency
 
-  def _kpi_or_revenue(self) -> str:
-    if self._meridian.input_data.revenue_per_kpi is not None:
-      outcome_str = c.REVENUE
-    else:
-      outcome_str = c.KPI.upper()
-    return outcome_str
+  def _kpi_or_revenue(self, use_kpi: bool) -> str:
+    if use_kpi or self._meridian.input_data.revenue_per_kpi is None:
+      return c.KPI.upper()
+    return c.REVENUE