google-meridian 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

meridian/analysis/formatter.py

@@ -110,6 +110,24 @@ def bar_chart_width(num_bars: int) -> int:
   return (c.BAR_SIZE + c.PADDING_20) * num_bars
 
 
+def format_percent(percent: float) -> str:
+  """Formats a percentage value into a string format.
+
+  Percentage values between 0 and 1 are formatted with 1 decimal place.
+  Percentage values greater than 1 are formatted with 0 decimal places.
+
+  Args:
+    percent: The percentage value to format.
+
+  Returns:
+    A formatted string.
+  """
+  if percent >= 0.01:
+    return '{:.0%}'.format(percent)
+  else:
+    return '{:.1g}%'.format(percent * 100)
+
+
 def compact_number(n: float, precision: int = 0, currency: str = '') -> str:
   """Formats a number into a compact notation to the specified precision.
 

meridian/analysis/optimizer.py

@@ -45,6 +45,64 @@ alt.data_transformers.disable_max_rows()
 _SpendConstraint: TypeAlias = float | Sequence[float]
 
 
+@dataclasses.dataclass(frozen=True)
+class OptimizationGrid:
+  """Optimization grid information.
+
+  Attributes:
+    spend: ndarray of shape `(n_paid_channels,)` containing the spend allocation
+      for spend for all media and RF channels. The order matches
+      `InputData.get_all_paid_channels`.
+    use_kpi: Whether using generic KPI or revenue.
+    use_posterior: Whether posterior distributions were used, or prior.
+    use_optimal_frequency: Whether optimal frequency was used.
+    round_factor: The round factor used for the optimization grid.
+    optimal_frequency: Optional ndarray of shape `(n_paid_channels,)`,
+      containing the optimal frequency per channel. Value is `None` if the model
+      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.
+  """
+
+  _grid_dataset: xr.Dataset
+
+  spend: np.ndarray
+  use_kpi: bool
+  use_posterior: bool
+  use_optimal_frequency: bool
+  round_factor: int
+  optimal_frequency: np.ndarray | None
+  selected_times: list[str] | None
+
+  @property
+  def grid_dataset(self) -> xr.Dataset:
+    """Dataset holding the grid information used for optimization.
+
+    The dataset contains the following:
+
+      - Coordinates:  `grid_spend_index`, `channel`
+      - Data variables: `spend_grid`, `incremental_outcome_grid`
+      - Attributes: `spend_step_size`
+    """
+    return self._grid_dataset
+
+  @property
+  def spend_grid(self) -> np.ndarray:
+    """The spend grid."""
+    return self.grid_dataset.spend_grid
+
+  @property
+  def incremental_outcome_grid(self) -> np.ndarray:
+    """The incremental outcome grid."""
+    return self.grid_dataset.incremental_outcome_grid
+
+  @property
+  def spend_step_size(self) -> float:
+    """The spend step size."""
+    return self.grid_dataset.attrs[c.SPEND_STEP_SIZE]
+
+
 @dataclasses.dataclass(frozen=True)
 class OptimizationResults:
   """The optimized budget allocation.
@@ -69,10 +127,6 @@ class OptimizationResults:
     meridian: The fitted Meridian model that was used to create this budget
       allocation.
     analyzer: The analyzer bound to the model above.
-    use_posterior: Whether the posterior distribution was used to optimize the
-      budget. If `False`, the prior distribution was used.
-    use_optimal_frequency: Whether optimal frequency was used to optimize the
-      budget.
     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
@@ -88,10 +142,6 @@ class OptimizationResults:
   meridian: model.Meridian
   # The analyzer bound to the model above.
   analyzer: analyzer.Analyzer
-
-  # The intermediate values used to derive the optimized budget allocation.
-  use_posterior: bool
-  use_optimal_frequency: bool
   spend_ratio: np.ndarray  # spend / historical spend
   spend_bounds: tuple[np.ndarray, np.ndarray]
 
@@ -99,7 +149,7 @@ class OptimizationResults:
   _nonoptimized_data: xr.Dataset
   _nonoptimized_data_with_optimal_freq: xr.Dataset
   _optimized_data: xr.Dataset
-  _optimization_grid: xr.Dataset
+  _optimization_grid: OptimizationGrid
 
   # TODO: Move this, and the plotting methods, to a summarizer.
   @functools.cached_property
@@ -174,23 +224,15 @@ class OptimizationResults:
     return self._optimized_data
 
   @property
-  def optimization_grid(self) -> xr.Dataset:
-    """Dataset holding the grid information used for optimization.
-
-    The dataset contains the following:
-
-      - Coordinates:  `grid_spend_index`, `channel`
-      - Data variables: `spend_grid`, `incremental_outcome_grid`
-      - Attributes: `spend_step_size`
-    """
+  def optimization_grid(self) -> OptimizationGrid:
+    """The grid information used for optimization."""
     return self._optimization_grid
 
   def output_optimization_summary(self, filename: str, filepath: str):
     """Generates and saves the HTML optimization summary output."""
-    if self.optimized_data:
-      os.makedirs(filepath, exist_ok=True)
-      with open(os.path.join(filepath, filename), 'w') as f:
-        f.write(self._gen_optimization_summary())
+    os.makedirs(filepath, exist_ok=True)
+    with open(os.path.join(filepath, filename), 'w') as f:
+      f.write(self._gen_optimization_summary())
 
   def plot_incremental_outcome_delta(self) -> alt.Chart:
     """Plots a waterfall chart showing the change in incremental outcome."""
@@ -540,10 +582,10 @@ class OptimizationResults:
     # response curve computation might take a significant amount of time.
     return self.analyzer.response_curves(
         spend_multipliers=spend_multiplier,
-        use_posterior=self.use_posterior,
+        use_posterior=self.optimization_grid.use_posterior,
         selected_times=selected_times,
         by_reach=True,
-        use_optimal_frequency=self.use_optimal_frequency,
+        use_optimal_frequency=self.optimization_grid.use_optimal_frequency,
     )
 
   def _get_plottable_response_curves_df(
@@ -675,7 +717,6 @@ class OptimizationResults:
         id=summary_text.SCENARIO_PLAN_CARD_ID,
         title=summary_text.SCENARIO_PLAN_CARD_TITLE,
     )
-
     scenario_type = (
         summary_text.FIXED_BUDGET_LABEL.lower()
         if self.optimized_data.fixed_budget
@@ -892,6 +933,14 @@ class BudgetOptimizer:
     self._meridian = meridian
     self._analyzer = analyzer.Analyzer(self._meridian)
 
+  def _validate_model_fit(self, use_posterior: bool):
+    """Validates that the model is fit."""
+    dist_type = c.POSTERIOR if use_posterior else c.PRIOR
+    if dist_type not in self._meridian.inference_data.groups():
+      raise model.NotFittedModelError(
+          'Running budget optimization scenarios requires fitting the model.'
+      )
+
   def optimize(
       self,
       use_posterior: bool = True,
@@ -930,24 +979,33 @@ class BudgetOptimizer:
         specify either `target_roi` or `target_mroi`.
       budget: Number indicating the total budget for the fixed budget scenario.
         Defaults to the historical budget.
-      pct_of_spend: Numeric list of size `n_total_channels` containing the
+      pct_of_spend: Numeric list of size `n_paid_channels` containing the
         percentage allocation for spend for all media and RF channels. The order
-        must match `InputData.media` with values between 0-1, summing to 1. By
-        default, the historical allocation is used. Budget and allocation are
-        used in conjunction to determine the non-optimized media-level spend,
-        which is used to calculate the non-optimized performance metrics (for
-        example, ROI) and construct the feasible range of media-level spend with
-        the spend constraints.
-      spend_constraint_lower: Numeric list of size `n_total_channels` or float
+        must match `(InputData.media + InputData.reach)` with values between
+        0-1, summing to 1. By default, the historical allocation is used. Budget
+        and allocation are used in conjunction to determine the non-optimized
+        media-level spend, which is used to calculate the non-optimized
+        performance metrics (for example, ROI) and construct the feasible range
+        of media-level spend with the spend constraints. Consider using
+        `InputData.get_paid_channels_argument_builder()` to construct this
+        argument.
+      spend_constraint_lower: Numeric list of size `n_paid_channels` or float
         (same constraint for all channels) indicating the lower bound of
-        media-level spend. The lower bound of media-level spend is `(1 -
-        spend_constraint_lower) * budget * allocation)`. The value must be
-        between 0-1. Defaults to `0.3` for fixed budget and `1` for flexible.
-      spend_constraint_upper: Numeric list of size `n_total_channels` or float
+        media-level spend. If given as a channel-indexed array, the order must
+        match `(InputData.media + InputData.reach)`. The lower bound of
+        media-level spend is `(1 - spend_constraint_lower) * budget *
+        allocation)`. The value must be between 0-1. Defaults to `0.3` for fixed
+        budget and `1` for flexible. Consider using
+        `InputData.get_paid_channels_argument_builder()` to construct this
+        argument.
+      spend_constraint_upper: Numeric list of size `n_paid_channels` or float
         (same constraint for all channels) indicating the upper bound of
-        media-level spend. The upper bound of media-level spend is `(1 +
-        spend_constraint_upper) * budget * allocation)`. Defaults to `0.3` for
-        fixed budget and `1` for flexible.
+        media-level spend. If given as a channel-indexed array, the order must
+        match `(InputData.media + InputData.reach)`. The upper bound of
+        media-level spend is `(1 + spend_constraint_upper) * budget *
+        allocation)`. Defaults to `0.3` for fixed budget and `1` for flexible.
+        Consider using `InputData.get_paid_channels_argument_builder()` to
+        construct this argument.
       target_roi: Float indicating the target ROI constraint. Only used for
         flexible budget scenarios. The budget is constrained to when the ROI of
         the total spend hits `target_roi`.
@@ -972,12 +1030,13 @@ class BudgetOptimizer:
       An `OptimizationResults` object containing optimized budget allocation
       datasets, along with some of the intermediate values used to derive them.
     """
-    dist_type = c.POSTERIOR if use_posterior else c.PRIOR
-    if dist_type not in self._meridian.inference_data.groups():
-      raise model.NotFittedModelError(
-          'Running budget optimization scenarios requires fitting the model.'
-      )
-    self._validate_budget(fixed_budget, budget, target_roi, target_mroi)
+    _validate_budget(
+        fixed_budget=fixed_budget,
+        budget=budget,
+        target_roi=target_roi,
+        target_mroi=target_mroi,
+    )
+
     if selected_times is not None:
       start_date, end_date = selected_times
       selected_time_dims = self._meridian.expand_selected_time_dims(
@@ -986,23 +1045,17 @@ class BudgetOptimizer:
       )
     else:
       selected_time_dims = None
-
     hist_spend = self._analyzer.get_historical_spend(
         selected_time_dims,
         include_media=self._meridian.n_media_channels > 0,
         include_rf=self._meridian.n_rf_channels > 0,
     ).data
 
-    use_historical_budget = budget is None or round(budget) == round(
-        np.sum(hist_spend)
-    )
     budget = budget or np.sum(hist_spend)
     pct_of_spend = self._validate_pct_of_spend(hist_spend, pct_of_spend)
     spend = budget * pct_of_spend
     round_factor = _get_round_factor(budget, gtol)
-    step_size = 10 ** (-round_factor)
     rounded_spend = np.round(spend, round_factor).astype(int)
-    spend_ratio = spend / hist_spend
     if self._meridian.n_rf_channels > 0 and use_optimal_frequency:
       optimal_frequency = tf.convert_to_tensor(
           self._analyzer.optimal_freq(
@@ -1024,34 +1077,30 @@ class BudgetOptimizer:
             fixed_budget=fixed_budget,
         )
     )
-    (spend_grid, incremental_outcome_grid) = self._create_grids(
+    optimization_grid = self.create_optimization_grid(
         spend=hist_spend,
         spend_bound_lower=optimization_lower_bound,
         spend_bound_upper=optimization_upper_bound,
-        step_size=step_size,
         selected_times=selected_time_dims,
+        round_factor=round_factor,
         use_posterior=use_posterior,
         use_kpi=use_kpi,
+        use_optimal_frequency=use_optimal_frequency,
         optimal_frequency=optimal_frequency,
         batch_size=batch_size,
     )
+    # TODO: b/375644691) - Move grid search to a OptimizationGrid class.
     optimal_spend = self._grid_search(
-        spend_grid=spend_grid,
-        incremental_outcome_grid=incremental_outcome_grid,
+        spend_grid=optimization_grid.spend_grid,
+        incremental_outcome_grid=optimization_grid.incremental_outcome_grid,
         budget=np.sum(rounded_spend),
         fixed_budget=fixed_budget,
         target_mroi=target_mroi,
         target_roi=target_roi,
     )
-
-    constraints = {
-        c.FIXED_BUDGET: fixed_budget,
-    }
-    if target_roi:
-      constraints[c.TARGET_ROI] = target_roi
-    elif target_mroi:
-      constraints[c.TARGET_MROI] = target_mroi
-
+    use_historical_budget = budget is None or round(budget) == round(
+        np.sum(hist_spend)
+    )
     nonoptimized_data = self._create_budget_dataset(
         use_posterior=use_posterior,
         use_kpi=use_kpi,
@@ -1073,6 +1122,13 @@ class BudgetOptimizer:
         batch_size=batch_size,
         use_historical_budget=use_historical_budget,
     )
+    constraints = {
+        c.FIXED_BUDGET: fixed_budget,
+    }
+    if target_roi:
+      constraints[c.TARGET_ROI] = target_roi
+    elif target_mroi:
+      constraints[c.TARGET_MROI] = target_mroi
     optimized_data = self._create_budget_dataset(
         use_posterior=use_posterior,
         use_kpi=use_kpi,
@@ -1085,18 +1141,16 @@ class BudgetOptimizer:
         batch_size=batch_size,
         use_historical_budget=use_historical_budget,
     )
-
-    optimization_grid = self._create_optimization_grid(
-        spend_grid=spend_grid,
-        spend_step_size=step_size,
-        incremental_outcome_grid=incremental_outcome_grid,
+    spend_ratio = np.divide(
+        spend,
+        hist_spend,
+        out=np.zeros_like(hist_spend, dtype=float),
+        where=hist_spend != 0,
     )
 
     return OptimizationResults(
         meridian=self._meridian,
         analyzer=self._analyzer,
-        use_posterior=use_posterior,
-        use_optimal_frequency=use_optimal_frequency,
         spend_ratio=spend_ratio,
         spend_bounds=spend_bounds,
         _nonoptimized_data=nonoptimized_data,
@@ -1105,7 +1159,83 @@ class BudgetOptimizer:
         _optimization_grid=optimization_grid,
     )
 
-  def _create_optimization_grid(
+  def create_optimization_grid(
+      self,
+      spend: np.ndarray,
+      spend_bound_lower: np.ndarray,
+      spend_bound_upper: np.ndarray,
+      selected_times: Sequence[str] | None,
+      round_factor: int,
+      use_posterior: bool = True,
+      use_kpi: bool = False,
+      use_optimal_frequency: bool = True,
+      optimal_frequency: xr.DataArray | None = None,
+      batch_size: int = c.DEFAULT_BATCH_SIZE,
+  ) -> OptimizationGrid:
+    """Creates a OptimizationGrid for optimization.
+
+    Args:
+      spend: ndarray of shape `(n_paid_channels,)` with spend per paid channel.
+      spend_bound_lower: ndarray of dimension `(n_total_channels,)` containing
+        the lower constraint spend for each channel.
+      spend_bound_upper: ndarray of dimension `(n_total_channels,)` containing
+        the upper constraint spend for each channel.
+      selected_times: Sequence of strings representing the time dimensions in
+        `meridian.input_data.time` to use for optimization.
+      round_factor: The round factor used for the optimization grid.
+      use_posterior: Boolean. If `True`, then the incremental outcome is derived
+        from the posterior distribution of the model. Otherwise, the prior
+        distribution is used.
+      use_kpi: Boolean. If `True`, then the incremental outcome is derived from
+        the KPI impact. Otherwise, the incremental outcome is derived from the
+        revenue impact.
+      use_optimal_frequency: Boolean. Whether optimal frequency was used.
+      optimal_frequency: `xr.DataArray` with dimension `n_rf_channels`,
+        containing the optimal frequency per channel, that maximizes mean ROI
+        over the corresponding prior/posterior distribution. Value is `None` if
+        the model 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.
+      batch_size: Max draws per chain in each batch. The calculation is run in
+        batches to avoid memory exhaustion. If a memory error occurs, try
+        reducing `batch_size`. The calculation will generally be faster with
+        larger `batch_size` values.
+
+    Returns:
+      An OptimizationGrid object containing the grid data for optimization.
+    """
+    self._validate_model_fit(use_posterior)
+
+    step_size = 10 ** (-round_factor)
+    (spend_grid, incremental_outcome_grid) = self._create_grids(
+        spend=spend,
+        spend_bound_lower=spend_bound_lower,
+        spend_bound_upper=spend_bound_upper,
+        step_size=step_size,
+        selected_times=selected_times,
+        use_posterior=use_posterior,
+        use_kpi=use_kpi,
+        optimal_frequency=optimal_frequency,
+        batch_size=batch_size,
+    )
+    grid_dataset = self._create_grid_dataset(
+        spend_grid=spend_grid,
+        spend_step_size=step_size,
+        incremental_outcome_grid=incremental_outcome_grid,
+    )
+
+    return OptimizationGrid(
+        _grid_dataset=grid_dataset,
+        spend=spend,
+        use_kpi=use_kpi,
+        use_posterior=use_posterior,
+        use_optimal_frequency=use_optimal_frequency,
+        round_factor=round_factor,
+        optimal_frequency=optimal_frequency,
+        selected_times=selected_times,
+    )
+
+  def _create_grid_dataset(
       self,
       spend_grid: np.ndarray,
       spend_step_size: float,
@@ -1151,39 +1281,6 @@ class BudgetOptimizer:
         attrs={c.SPEND_STEP_SIZE: spend_step_size},
     )
 
-  def _validate_budget(
-      self,
-      fixed_budget: bool,
-      budget: float | None,
-      target_roi: float | None,
-      target_mroi: float | None,
-  ):
-    """Validates the budget optimization arguments."""
-    if fixed_budget:
-      if target_roi is not None:
-        raise ValueError(
-            '`target_roi` is only used for flexible budget scenarios.'
-        )
-      if target_mroi is not None:
-        raise ValueError(
-            '`target_mroi` is only used for flexible budget scenarios.'
-        )
-      if budget is not None and budget <= 0:
-        raise ValueError('`budget` must be greater than zero.')
-    else:
-      if budget is not None:
-        raise ValueError('`budget` is only used for fixed budget scenarios.')
-      if target_roi is None and target_mroi is None:
-        raise ValueError(
-            'Must specify either `target_roi` or `target_mroi` for flexible'
-            ' budget optimization.'
-        )
-      if target_roi is not None and target_mroi is not None:
-        raise ValueError(
-            'Must specify only one of `target_roi` or `target_mroi` for'
-            'flexible budget optimization.'
-        )
-
   def _validate_pct_of_spend(
       self, hist_spend: np.ndarray, pct_of_spend: Sequence[float] | None
   ) -> np.ndarray:
@@ -1377,27 +1474,6 @@ class BudgetOptimizer:
         incremental_outcome_with_mean_median_and_ci[:, 0]
     )
 
-    # expected_outcome here is a tensor with the shape (n_chains, n_draws)
-    expected_outcome = self._analyzer.expected_outcome(
-        use_posterior=use_posterior,
-        new_data=analyzer.DataTensors(
-            media=new_media,
-            reach=new_reach,
-            frequency=new_frequency,
-        ),
-        selected_times=selected_times,
-        use_kpi=use_kpi,
-        batch_size=batch_size,
-    )
-    mean_expected_outcome = tf.reduce_mean(expected_outcome, (0, 1))  # a scalar
-
-    pct_contrib = incremental_outcome / mean_expected_outcome[..., None] * 100
-    pct_contrib_with_mean_median_and_ci = analyzer.get_central_tendency_and_ci(
-        data=pct_contrib,
-        confidence_level=confidence_level,
-        include_median=True,
-    )
-
     aggregated_impressions = self._analyzer.get_aggregated_impressions(
         selected_times=selected_times,
         selected_geos=None,
@@ -1458,10 +1534,6 @@ class BudgetOptimizer:
             [c.CHANNEL, c.METRIC],
             incremental_outcome_with_mean_median_and_ci,
         ),
-        c.PCT_OF_CONTRIBUTION: (
-            [c.CHANNEL, c.METRIC],
-            pct_contrib_with_mean_median_and_ci,
-        ),
         c.EFFECTIVENESS: (
             [c.CHANNEL, c.METRIC],
             effectiveness_with_mean_median_and_ci,
@@ -1651,11 +1723,11 @@ class BudgetOptimizer:
     """Creates spend and incremental outcome grids for optimization algorithm.
 
     Args:
-      spend: np.ndarray with actual spend per media or RF channel.
-      spend_bound_lower: np.ndarray of dimension (`n_total_channels`) containing
-        the lower constraint spend for each channel.
-      spend_bound_upper: np.ndarray of dimension (`n_total_channels`) containing
-        the upper constraint spend for each channel.
+      spend: `np.ndarray` with actual spend per media or RF channel.
+      spend_bound_lower: `np.ndarray` of dimension (`n_total_channels`)
+        containing the lower constraint spend for each channel.
+      spend_bound_upper: `np.ndarray` of dimension (`n_total_channels`)
+        containing the upper constraint spend for each channel.
       step_size: Integer indicating the step size, or interval, between values
         in the spend grid. All media channels have the same step size.
       selected_times: Sequence of strings representing the time dimensions in
@@ -1666,11 +1738,12 @@ class BudgetOptimizer:
       use_kpi: Boolean. If `True`, then the incremental outcome is derived from
         the KPI impact. Otherwise, the incremental outcome is derived from the
         revenue impact.
-      optimal_frequency: xr.DataArray with dimension `n_rf_channels`, containing
-        the optimal frequency per channel, that maximizes posterior mean roi.
-        Value is `None` if the model 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.
+      optimal_frequency: `xr.DataArray` with dimension `n_rf_channels`,
+        containing the optimal frequency per channel, that maximizes mean ROI
+        over the corresponding prior/posterior distribution. Value is `None` if
+        the model 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.
       batch_size: Max draws per chain in each batch. The calculation is run in
         batches to avoid memory exhaustion. If a memory error occurs, try
         reducing `batch_size`. The calculation will generally be faster with
@@ -1678,11 +1751,11 @@ class BudgetOptimizer:
 
     Returns:
       spend_grid: Discrete two-dimensional grid with the number of rows
-        determined by the `spend_constraints` and `step_size`, and the number of
+        determined by the `spend_bound_**` and `step_size`, and the number of
         columns is equal to the number of total channels, containing spend by
         channel.
       incremental_outcome_grid: Discrete two-dimensional grid with the number of
-        rows determined by the `spend_constraints` and `step_size`, and the
+        rows determined by the `spend_bound_**` and `step_size`, and the
         number of columns is equal to the number of total channels, containing
         incremental outcome by channel.
     """
@@ -1700,9 +1773,12 @@ class BudgetOptimizer:
       )
       spend_grid[: len(spend_grid_m), i] = spend_grid_m
     incremental_outcome_grid = np.full([n_grid_rows, n_grid_columns], np.nan)
-    multipliers_grid = tf.cast(
+    multipliers_grid_base = tf.cast(
         tf.math.divide_no_nan(spend_grid, spend), dtype=tf.float32
     )
+    multipliers_grid = np.where(
+        np.isnan(spend_grid), np.nan, multipliers_grid_base
+    )
     for i in range(n_grid_rows):
       self._update_incremental_outcome_grid(
           i=i,
@@ -1824,6 +1900,39 @@ class BudgetOptimizer:
     return spend_optimal
 
 
+def _validate_budget(
+    fixed_budget: bool,
+    budget: float | None,
+    target_roi: float | None,
+    target_mroi: float | None,
+):
+  """Validates the budget optimization arguments."""
+  if fixed_budget:
+    if target_roi is not None:
+      raise ValueError(
+          '`target_roi` is only used for flexible budget scenarios.'
+      )
+    if target_mroi is not None:
+      raise ValueError(
+          '`target_mroi` is only used for flexible budget scenarios.'
+      )
+    if budget is not None and budget <= 0:
+      raise ValueError('`budget` must be greater than zero.')
+  else:
+    if budget is not None:
+      raise ValueError('`budget` is only used for fixed budget scenarios.')
+    if target_roi is None and target_mroi is None:
+      raise ValueError(
+          'Must specify either `target_roi` or `target_mroi` for flexible'
+          ' budget optimization.'
+      )
+    if target_roi is not None and target_mroi is not None:
+      raise ValueError(
+          'Must specify only one of `target_roi` or `target_mroi` for'
+          'flexible budget optimization.'
+      )
+
+
 def _get_round_factor(budget: float, gtol: float) -> int:
   """Function for obtaining number of integer digits to round off of budget.
 
@@ -1888,6 +1997,11 @@ def _exceeds_optimization_constraints(
   if fixed_budget:
     return np.sum(spend) > budget
   elif target_roi is not None:
-    return (np.sum(incremental_outcome) / np.sum(spend)) < target_roi
+    cur_total_roi = np.sum(incremental_outcome) / np.sum(spend)
+    # In addition to the total roi being less than the target roi, the roi of
+    # the current optimization step should also be less than the total roi.
+    # Without the second condition, the optimization algorithm may not have
+    # found the roi point close to the target roi yet.
+    return cur_total_roi < target_roi and roi_grid_point < cur_total_roi
   else:
     return roi_grid_point < target_mroi

meridian/analysis/summarizer.py

@@ -227,8 +227,8 @@ class Summarizer:
         ]
         row_values = [
             '{:.2f}'.format(sliced_table_by_eval_set[c.R_SQUARED].item()),
-            '{:.0%}'.format(sliced_table_by_eval_set[c.MAPE].item()),
-            '{:.0%}'.format(sliced_table_by_eval_set[c.WMAPE].item()),
+            formatter.format_percent(sliced_table_by_eval_set[c.MAPE].item()),
+            formatter.format_percent(sliced_table_by_eval_set[c.WMAPE].item()),
         ]
         return row_values