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

meridian/analysis/optimizer.py

@@ -20,6 +20,7 @@ import functools
 import math
 import os
 from typing import Any, TypeAlias
+import warnings
 
 import altair as alt
 import jinja2
@@ -45,14 +46,53 @@ alt.data_transformers.disable_max_rows()
 _SpendConstraint: TypeAlias = float | Sequence[float]
 
 
+@dataclasses.dataclass(frozen=True)
+class FixedBudgetScenario:
+  """A fixed budget optimization scenario.
+
+  Attributes:
+    total_budget: The total budget for the optimization period. Must be
+      non-negative. If unspecified, it represents historical total spend.
+  """
+
+  total_budget: float | None = None
+
+  def __post_init__(self):
+    if self.total_budget is not None and self.total_budget < 0:
+      raise ValueError('Total budget must be non-negative.')
+
+
+@dataclasses.dataclass(frozen=True)
+class FlexibleBudgetScenario:
+  """A flexible budget optimization scenario.
+
+  Attributes:
+    target_metric: The target metric to optimize for. This should be ROI or
+      mROI.
+    target_value: The target value for the above metric. Must be non-negative.
+  """
+
+  target_metric: str
+  target_value: float
+
+  def __post_init__(self):
+    if self.target_metric not in (c.ROI, c.MROI):
+      raise ValueError(
+          f'Unsupported target metric: {self.target_metric} for flexible budget'
+          ' scenario.'
+      )
+    if self.target_value < 0:
+      raise ValueError('Target value must be non-negative.')
+
+
 @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`.
+    historical_spend: ndarray of shape `(n_paid_channels,)` containing
+      aggregated historical 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.
@@ -67,7 +107,7 @@ class OptimizationGrid:
 
   _grid_dataset: xr.Dataset
 
-  spend: np.ndarray
+  historical_spend: np.ndarray
   use_kpi: bool
   use_posterior: bool
   use_optimal_frequency: bool
@@ -102,6 +142,78 @@ class OptimizationGrid:
     """The spend step size."""
     return self.grid_dataset.attrs[c.SPEND_STEP_SIZE]
 
+  # TODO: b/402950014 - Add per-channel constraints parameter.
+  def optimize(
+      self,
+      scenario: FixedBudgetScenario | FlexibleBudgetScenario,
+  ) -> np.ndarray:
+    """Hill-climbing search algorithm for budget optimization.
+
+    Args:
+      scenario: The optimization scenario with corresponding parameters.
+
+    Returns:
+      optimal_spend: `np.ndarray` with shape `(n_paid_channels,)` containing the
+        media spend that maximizes incremental outcome based on spend
+        constraints for all media and RF channels.
+    """
+    if (
+        isinstance(scenario, FixedBudgetScenario)
+        and scenario.total_budget is None
+    ):
+      rounded_spend = np.round(self.historical_spend, self.round_factor).astype(
+          int
+      )
+      budget = np.sum(rounded_spend)
+      scenario = dataclasses.replace(scenario, total_budget=budget)
+
+    spend = self.spend_grid[0, :].copy()
+    incremental_outcome = self.incremental_outcome_grid[0, :].copy()
+    spend_grid = self.spend_grid[1:, :]
+    incremental_outcome_grid = self.incremental_outcome_grid[1:, :]
+    iterative_roi_grid = np.round(
+        tf.math.divide_no_nan(
+            incremental_outcome_grid - incremental_outcome, spend_grid - spend
+        ),
+        decimals=8,
+    )
+    while True:
+      spend_optimal = spend.astype(int)
+      # If none of the exit criteria are met roi_grid will eventually be filled
+      # with all nans.
+      if np.isnan(iterative_roi_grid).all():
+        break
+      point = np.unravel_index(
+          np.nanargmax(iterative_roi_grid), iterative_roi_grid.shape
+      )
+      row_idx = point[0]
+      media_idx = point[1]
+      spend[media_idx] = spend_grid[row_idx, media_idx]
+      incremental_outcome[media_idx] = incremental_outcome_grid[
+          row_idx, media_idx
+      ]
+      roi_grid_point = iterative_roi_grid[row_idx, media_idx]
+      if _exceeds_optimization_constraints(
+          spend=spend,
+          incremental_outcome=incremental_outcome,
+          roi_grid_point=roi_grid_point,
+          scenario=scenario,
+      ):
+        break
+
+      iterative_roi_grid[0 : row_idx + 1, media_idx] = np.nan
+      iterative_roi_grid[row_idx + 1 :, media_idx] = np.round(
+          tf.math.divide_no_nan(
+              incremental_outcome_grid[row_idx + 1 :, media_idx]
+              - incremental_outcome_grid[row_idx, media_idx],
+              spend_grid[row_idx + 1 :, media_idx]
+              - spend_grid[row_idx, media_idx],
+          ),
+          decimals=8,
+      )
+
+    return spend_optimal
+
 
 @dataclasses.dataclass(frozen=True)
 class OptimizationResults:
@@ -377,7 +489,8 @@ class OptimizationResults:
         .properties(
             title=formatter.custom_title_params(
                 summary_text.SPEND_ALLOCATION_CHART_TITLE
-            )
+            ),
+            width=c.VEGALITE_FACET_DEFAULT_WIDTH
         )
     )
 
@@ -416,7 +529,7 @@ class OptimizationResults:
         tooltip=True, size=c.BAR_SIZE, cornerRadiusEnd=c.CORNER_RADIUS
     ).encode(
         color=alt.condition(
-            alt.expr.datum.spend > 0,
+            alt.datum.spend > 0,
             alt.value(c.CYAN_400),
             alt.value(c.RED_300),
         ),
@@ -461,7 +574,7 @@ class OptimizationResults:
       title = summary_text.INC_KPI_LABEL
     df = self._get_plottable_response_curves_df(n_top_channels=n_top_channels)
     base = (
-        alt.Chart(df)
+        alt.Chart(df, width=c.VEGALITE_FACET_DEFAULT_WIDTH)
         .transform_calculate(
             spend_constraint=(
                 'datum.spend_multiplier >= datum.lower_bound &&'
@@ -1051,6 +1164,9 @@ class BudgetOptimizer:
         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
@@ -1078,7 +1194,7 @@ class BudgetOptimizer:
         )
     )
     optimization_grid = self.create_optimization_grid(
-        spend=hist_spend,
+        historical_spend=hist_spend,
         spend_bound_lower=optimization_lower_bound,
         spend_bound_upper=optimization_upper_bound,
         selected_times=selected_time_dims,
@@ -1089,17 +1205,21 @@ class BudgetOptimizer:
         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=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,
-    )
-    use_historical_budget = budget is None or round(budget) == round(
-        np.sum(hist_spend)
+
+    if fixed_budget:
+      total_budget = None if use_historical_budget else np.sum(rounded_spend)
+      scenario = FixedBudgetScenario(total_budget=total_budget)
+    elif target_roi:
+      scenario = FlexibleBudgetScenario(
+          target_metric=c.ROI, target_value=target_roi
+      )
+    else:
+      scenario = FlexibleBudgetScenario(
+          target_metric=c.MROI, target_value=target_mroi
+      )
+
+    optimal_spend = optimization_grid.optimize(
+        scenario=scenario,
     )
     nonoptimized_data = self._create_budget_dataset(
         use_posterior=use_posterior,
@@ -1141,6 +1261,14 @@ class BudgetOptimizer:
         batch_size=batch_size,
         use_historical_budget=use_historical_budget,
     )
+
+    if not fixed_budget:
+      self._raise_warning_if_target_constraints_not_met(
+          target_roi=target_roi,
+          target_mroi=target_mroi,
+          optimized_data=optimized_data,
+      )
+
     spend_ratio = np.divide(
         spend,
         hist_spend,
@@ -1159,23 +1287,51 @@ class BudgetOptimizer:
         _optimization_grid=optimization_grid,
     )
 
+  def _raise_warning_if_target_constraints_not_met(
+      self,
+      target_roi: float | None,
+      target_mroi: float | None,
+      optimized_data: xr.Dataset,
+  ) -> None:
+    """Raises a warning if the target constraints are not met."""
+    if target_roi:
+      # Total ROI is a scalar value.
+      optimized_roi = optimized_data.attrs[c.TOTAL_ROI]
+      if optimized_roi < target_roi:
+        warnings.warn(
+            f'Target ROI constraint was not met. The target ROI is {target_roi}'
+            f', but the actual ROI is {optimized_roi}.'
+        )
+    elif target_mroi:
+      # Compare each channel's marginal ROI to the target.
+      # optimized_data[c.MROI] is an array of shape (n_channels, 4), where the
+      # last dimension is [mean, median, ci_lo, ci_hi].
+      optimized_mroi = optimized_data[c.MROI][:, 0]
+      if np.any(optimized_mroi < target_mroi):
+        warnings.warn(
+            'Target marginal ROI constraint was not met. The target marginal'
+            f' ROI is {target_mroi}, but the actual channel marginal ROIs are'
+            f' {optimized_mroi}.'
+        )
+
   def create_optimization_grid(
       self,
-      spend: np.ndarray,
+      historical_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,
+      use_optimal_frequency: bool = False,
       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.
+      historical_spend: ndarray of shape `(n_paid_channels,)` with arrgegated
+        historical 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
@@ -1208,7 +1364,7 @@ class BudgetOptimizer:
 
     step_size = 10 ** (-round_factor)
     (spend_grid, incremental_outcome_grid) = self._create_grids(
-        spend=spend,
+        spend=historical_spend,
         spend_bound_lower=spend_bound_lower,
         spend_bound_upper=spend_bound_upper,
         step_size=step_size,
@@ -1226,7 +1382,7 @@ class BudgetOptimizer:
 
     return OptimizationGrid(
         _grid_dataset=grid_dataset,
-        spend=spend,
+        historical_spend=historical_spend,
         use_kpi=use_kpi,
         use_posterior=use_posterior,
         use_optimal_frequency=use_optimal_frequency,
@@ -1810,95 +1966,6 @@ class BudgetOptimizer:
       )
     return (spend_grid, incremental_outcome_grid)
 
-  def _grid_search(
-      self,
-      spend_grid: np.ndarray,
-      incremental_outcome_grid: np.ndarray,
-      budget: float,
-      fixed_budget: bool,
-      target_mroi: float | None = None,
-      target_roi: float | None = None,
-  ) -> np.ndarray:
-    """Hill-climbing search algorithm for budget optimization.
-
-    Args:
-      spend_grid: Discrete grid with dimensions (`grid_length` x
-        `n_total_channels`) containing spend by channel for all media and RF
-        channels, used in the hill-climbing search algorithm.
-      incremental_outcome_grid: Discrete grid with dimensions (`grid_length` x
-        `n_total_channels`) containing incremental outcome by channel for all
-        media and RF channels, used in the hill-climbing search algorithm.
-      budget: Integer indicating the total budget.
-      fixed_budget: Bool indicating whether it's a fixed budget optimization or
-        flexible budget optimization.
-      target_mroi: Optional float indicating the target marginal return on
-        investment (mroi) constraint. This can be translated into "How much can
-        I spend when I have flexible budget until the mroi of each channel hits
-        the target mroi". It's still possible that the mroi of some channels
-        will not be equal to the target mroi due to the feasible range of media
-        spend. However, the mroi will effectively shrink toward the target mroi.
-      target_roi: Optional float indicating the target return on investment
-        (roi) constraint. This can be translated into "How much can I spend when
-        I have a flexible budget until the roi of total media spend hits the
-        target roi".
-
-    Returns:
-      optimal_spend: np.ndarry of dimension (`n_total_channels`) containing the
-        media spend that maximizes incremental outcome based on spend
-        constraints for all media and RF channels.
-      optimal_inc_outcome: np.ndarry of dimension (`n_total_channels`)
-        containing the post optimization incremental outcome per channel for all
-        media and RF channels.
-    """
-    spend = spend_grid[0, :].copy()
-    incremental_outcome = incremental_outcome_grid[0, :].copy()
-    spend_grid = spend_grid[1:, :]
-    incremental_outcome_grid = incremental_outcome_grid[1:, :]
-    iterative_roi_grid = np.round(
-        tf.math.divide_no_nan(
-            incremental_outcome_grid - incremental_outcome, spend_grid - spend
-        ),
-        decimals=8,
-    )
-    while True:
-      spend_optimal = spend.astype(int)
-      # If none of the exit criteria are met roi_grid will eventually be filled
-      # with all nans.
-      if np.isnan(iterative_roi_grid).all():
-        break
-      point = np.unravel_index(
-          np.nanargmax(iterative_roi_grid), iterative_roi_grid.shape
-      )
-      row_idx = point[0]
-      media_idx = point[1]
-      spend[media_idx] = spend_grid[row_idx, media_idx]
-      incremental_outcome[media_idx] = incremental_outcome_grid[
-          row_idx, media_idx
-      ]
-      roi_grid_point = iterative_roi_grid[row_idx, media_idx]
-      if _exceeds_optimization_constraints(
-          fixed_budget,
-          budget,
-          spend,
-          incremental_outcome,
-          roi_grid_point,
-          target_mroi,
-          target_roi,
-      ):
-        break
-
-      iterative_roi_grid[0 : row_idx + 1, media_idx] = np.nan
-      iterative_roi_grid[row_idx + 1 :, media_idx] = np.round(
-          tf.math.divide_no_nan(
-              incremental_outcome_grid[row_idx + 1 :, media_idx]
-              - incremental_outcome_grid[row_idx, media_idx],
-              spend_grid[row_idx + 1 :, media_idx]
-              - spend_grid[row_idx, media_idx],
-          ),
-          decimals=8,
-      )
-    return spend_optimal
-
 
 def _validate_budget(
     fixed_budget: bool,
@@ -1958,13 +2025,10 @@ def _get_round_factor(budget: float, gtol: float) -> int:
 
 
 def _exceeds_optimization_constraints(
-    fixed_budget: bool,
-    budget: float,
     spend: np.ndarray,
     incremental_outcome: np.ndarray,
     roi_grid_point: float,
-    target_mroi: float | None = None,
-    target_roi: float | None = None,
+    scenario: FixedBudgetScenario | FlexibleBudgetScenario,
 ) -> bool:
   """Checks optimization scenario constraints.
 
@@ -1972,36 +2036,30 @@ def _exceeds_optimization_constraints(
     flexibility, target_roi, and target_mroi.
 
   Args:
-    fixed_budget: bool indicating whether it's a fixed budget optimization or
-      flexible budget optimization.
-    budget: integer indicating the total budget.
     spend: np.ndarray with dimensions (`n_total_channels`) containing spend per
       channel for all media and RF channels.
     incremental_outcome: np.ndarray with dimensions (`n_total_channels`)
       containing incremental outcome per channel for all media and RF channels.
     roi_grid_point: float roi for non-optimized optimation step.
-    target_mroi: Optional float indicating the target marginal return on
-      investment (mroi) constraint. This can be translated into "How much can I
-      spend when I have flexible budget until the mroi of each channel hits the
-      target mroi". It's still possible that the mroi of some channels will not
-      be equal to the target mroi due to the feasible range of spend. However,
-      the mroi will effectively shrink toward the target mroi.
-    target_roi: Optional float indicating the target return on investment (roi)
-      constraint. This can be translated into "How much can I spend when I have
-      a flexible budget until the roi of total spend hits the target roi.
+    scenario: FixedBudgetScenario or FlexibleBudgetScenario.
 
   Returns:
     bool indicating whether optimal spend and incremental outcome have been
       found, given the optimization constraints.
   """
-  if fixed_budget:
-    return np.sum(spend) > budget
-  elif target_roi is not None:
+  if isinstance(scenario, FixedBudgetScenario):
+    # total_budget is guaranteed to be not None.
+    return np.sum(spend) > scenario.total_budget
+  elif (
+      isinstance(scenario, FlexibleBudgetScenario)
+      and scenario.target_metric == c.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
+    target_value = scenario.target_value
+    return cur_total_roi < target_value and roi_grid_point < cur_total_roi
   else:
-    return roi_grid_point < target_mroi
+    return roi_grid_point < scenario.target_value

meridian/analysis/summarizer.py

@@ -85,7 +85,7 @@ class Summarizer:
       filepath: The path to the directory where the file will be saved.
       start_date: Optional start date selector, *inclusive*, in _yyyy-mm-dd_
         format.
-      end_date: Optional end date selector, *exclusive* in _yyyy-mm-dd_ format.
+      end_date: Optional end date selector, *inclusive* in _yyyy-mm-dd_ format.
     """
     os.makedirs(filepath, exist_ok=True)
     with open(os.path.join(filepath, filename), 'w') as f:
@@ -128,8 +128,12 @@ class Summarizer:
     template_env.globals[c.START_DATE] = start_date.strftime(
         f'%b {start_date.day}, %Y'
     )
-    template_env.globals[c.END_DATE] = end_date.strftime(
-        f'%b {end_date.day}, %Y'
+
+    interval_days = self._meridian.input_data.time_coordinates.interval_days
+    end_date_adjusted = end_date + pd.Timedelta(days=interval_days)
+
+    template_env.globals[c.END_DATE] = end_date_adjusted.strftime(
+        f'%b {end_date_adjusted.day}, %Y'
     )
 
     html_template = template_env.get_template('summary.html.jinja')

meridian/analysis/test_utils.py

@@ -1813,6 +1813,32 @@ MROI_MEDIA_AND_RF_USE_POSTERIOR_BY_REACH = np.array([
         [0.2282, 0.3271, 0.1354, 1.8194, 0.5598],
     ],
 ])
+MROI_MEDIA_AND_RF_NEW_TIMES_DATA = np.array([
+    [
+        [1.4194793, 1.4562954, 0.42110616, 0.46693847, 2.224705],
+        [1.4079778, 1.4408227, 0.42190424, 0.46729392, 2.2684476],
+        [1.4133729, 1.455379, 0.42965493, 0.46928722, 2.2630167],
+        [1.3786758, 1.4669218, 0.4399548, 0.466466, 2.2499163],
+        [1.3667594, 1.4595027, 0.430115, 0.46791035, 2.2718313],
+        [1.3636469, 1.4838042, 0.43774834, 0.46620503, 2.228661],
+        [1.3479362, 1.5108197, 0.42130333, 0.46699694, 2.2348554],
+        [1.3684787, 1.5252702, 0.4246083, 0.4682973, 2.2124028],
+        [1.3500556, 1.5139565, 0.42371163, 0.46387878, 2.2052019],
+        [1.3509449, 1.5152782, 0.42376328, 0.46421173, 2.2056532],
+    ],
+    [
+        [0.19265468, 0.3131754, 0.11835674, 1.7264867, 0.45867893],
+        [0.19271582, 0.31310934, 0.11833327, 1.7265227, 0.45878735],
+        [0.1927399, 0.3133164, 0.11834618, 1.7260367, 0.45711297],
+        [0.19282141, 0.31354108, 0.11858677, 1.724129, 0.45773327],
+        [0.19184875, 0.31352347, 0.11844476, 1.724147, 0.4579198],
+        [0.19213778, 0.3136204, 0.11846119, 1.7245249, 0.4575424],
+        [0.19298446, 0.3144178, 0.11840369, 1.7243268, 0.45999327],
+        [0.19473709, 0.3146425, 0.1182382, 1.7254068, 0.46479526],
+        [0.19482231, 0.31446627, 0.11806685, 1.7242908, 0.46568453],
+        [0.19479823, 0.31506982, 0.11783329, 1.7254248, 0.46606192],
+    ],
+])
 MROI_MEDIA_ONLY_USE_PRIOR = np.array([[
     [1.0740, 1.3019, 0.7984],
     [0.8990, 0.4201, 0.7120],
@@ -1999,6 +2025,32 @@ SAMPLE_ROI_NEW_DATA = np.array([
         [4.11828271, 1.58598067],
     ],
 ])
+ROI_NEW_TIMES_DATA = np.array([
+    [
+        [1.6587073, 1.6422542, 0.5339541, 0.46695647, 2.2247107],
+        [1.6448834, 1.6238545, 0.5349834, 0.46725115, 2.268456],
+        [1.6512104, 1.6399834, 0.54364294, 0.46939594, 2.2630484],
+        [1.6124083, 1.6505513, 0.55594736, 0.46645072, 2.2499137],
+        [1.597995, 1.6415955, 0.5437353, 0.46789172, 2.2718024],
+        [1.5946435, 1.6684949, 0.5538136, 0.46621037, 2.2286298],
+        [1.5757265, 1.6986614, 0.5317232, 0.4669749, 2.2348094],
+        [1.5993005, 1.7154359, 0.535261, 0.4682574, 2.2124054],
+        [1.5770503, 1.7027655, 0.5336275, 0.4639002, 2.2051802],
+        [1.5781163, 1.704347, 0.53381217, 0.4641966, 2.2056897],
+    ],
+    [
+        [0.22893494, 0.54465544, 0.17262405, 1.726445, 0.4586947],
+        [0.22897178, 0.54465, 0.17261527, 1.7264631, 0.45878458],
+        [0.22901268, 0.5448365, 0.17263621, 1.7260604, 0.45709604],
+        [0.22900137, 0.54496145, 0.17280822, 1.7242719, 0.4577607],
+        [0.22795935, 0.54490256, 0.17272605, 1.7241275, 0.4579781],
+        [0.22818668, 0.5450325, 0.1726518, 1.7245975, 0.45759043],
+        [0.22910665, 0.5459215, 0.17257686, 1.7243998, 0.4600002],
+        [0.23114449, 0.54561883, 0.17233835, 1.7253716, 0.46480042],
+        [0.23121877, 0.5451343, 0.17214388, 1.7242151, 0.46571606],
+        [0.23116706, 0.54571074, 0.17181544, 1.7254194, 0.4660912],
+    ],
+])
 SAMPLE_ROI_KPI = np.array([
     [
         [0.4906, 0.3487],
@@ -2073,34 +2125,34 @@ SAMPLE_MROI = np.array([
 ])
 SAMPLE_MROI_NEW_DATA = np.array([
     [
-        [0.83164197, 0.86531621],
-        [0.52520442, 0.8496893],
-        [0.32174, 0.221467],
-        [2.23112156, 1.5499284],
+        [0.86685735, 0.9019572],
+        [0.5474438, 0.88566875],
+        [0.33536345, 0.23084486],
+        [2.325597, 1.615559],
     ],
     [
-        [1.11224782, 1.26411092],
-        [0.89164674, 1.23331833],
-        [0.11121775, 0.34618538],
-        [2.46114173, 2.2305032],
+        [0.98578817, 1.1203848],
+        [0.79026884, 1.0930933],
+        [0.09857258, 0.306825],
+        [2.1813164, 1.9769008],
     ],
     [
-        [1.26143491, 0.32841554],
-        [0.7384, 0.32490036],
-        [0.48684751, 0.13766211],
-        [3.28485963, 0.52965774],
+        [1.1169803, 0.29080662],
+        [0.65436214, 0.28769404],
+        [0.4310956, 0.12189759],
+        [2.9086902, 0.46900335],
     ],
     [
-        [0.9377, 0.1185],
-        [0.6223, 0.1190],
-        [0.2329, 0.0957],
-        [2.4082, 0.1392],
+        [0.9376944, 0.11894181],
+        [0.6223348, 0.11948171],
+        [0.23284341, 0.09595118],
+        [2.408213, 0.13983254],
     ],
     [
-        [0.5017, 0.1535],
-        [0.3321, 0.1530],
-        [0.2055, 0.1419],
-        [1.0451, 0.1663],
+        [0.501675, 0.15347004],
+        [0.33212814, 0.15300572],
+        [0.20545325, 0.14246973],
+        [1.0451934, 0.16632313],
     ],
     [
         # mROI metric don't make sense for "All Channels".