google-meridian 1.0.9__py3-none-any.whl → 1.1.0__py3-none-any.whl

meridian/analysis/optimizer.py

@@ -98,6 +98,8 @@ class OptimizationGrid:
     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.
+    start_date: The start date of the optimization period.
+    end_date: The end date of the optimization period.
     gtol: Float indicating the acceptable relative error for the budget used in
       the grid setup. The budget is rounded by `10*n`, where `n` is the smallest
       integer such that `(budget - rounded_budget)` is less than or equal to
@@ -117,10 +119,12 @@ class OptimizationGrid:
   use_kpi: bool
   use_posterior: bool
   use_optimal_frequency: bool
+  start_date: tc.Date
+  end_date: tc.Date
   gtol: float
   round_factor: int
   optimal_frequency: np.ndarray | None
-  selected_times: Sequence[str] | Sequence[bool] | None
+  selected_times: Sequence[str] | None
 
   @property
   def grid_dataset(self) -> xr.Dataset:
@@ -190,7 +194,7 @@ class OptimizationGrid:
       variables:
         * `optimized`: media spend that maximizes incremental outcome based
         on spend constraints for all media and RF channels.
-        * `non_optimized`: Channel-level spend.
+        * `non_optimized`: rounded channel-level spend.
 
     Raises:
       A warning if the budget's rounding should be different from the grid's
@@ -227,7 +231,7 @@ class OptimizationGrid:
             spend_constraint_upper=spend_constraint_upper,
         )
     )
-    self._check_optimization_bounds(
+    self.check_optimization_bounds(
         lower_bound=optimization_lower_bound,
         upper_bound=optimization_upper_bound,
     )
@@ -236,16 +240,16 @@ class OptimizationGrid:
       warnings.warn(
           'Optimization accuracy may suffer owing to budget level differences.'
           ' Consider creating a new grid with smaller `gtol` if you intend to'
-          " shrink budgets significantly. It's only a problem when you use a"
-          ' smaller budget, for which the intended step size is meant to be'
-          ' smaller for one or more channels.'
+          ' shrink total budget significantly across optimization runs.'
+          ' It is only a problem when you use a much smaller budget, '
+          ' for which the intended step size is smaller. '
       )
     (spend_grid, incremental_outcome_grid) = self._trim_grid(
         spend_bound_lower=optimization_lower_bound,
         spend_bound_upper=optimization_upper_bound,
     )
+    rounded_spend = np.round(spend, self.round_factor).astype(int)
     if isinstance(scenario, FixedBudgetScenario):
-      rounded_spend = np.round(spend, self.round_factor)
       scenario = dataclasses.replace(
           scenario, total_budget=np.sum(rounded_spend)
       )
@@ -259,7 +263,7 @@ class OptimizationGrid:
         coords={c.CHANNEL: self.channels},
         data_vars={
             c.OPTIMIZED: ([c.CHANNEL], optimal_spend.data),
-            c.NON_OPTIMIZED: ([c.CHANNEL], spend),
+            c.NON_OPTIMIZED: ([c.CHANNEL], rounded_spend),
         },
     )
 
@@ -345,8 +349,10 @@ class OptimizationGrid:
     grid coverage and they are rounded using this grid's round factor.
 
     Args:
-      spend_bound_lower: The lower bound of spend for each channel.
-      spend_bound_upper: The upper bound of spend for each channel.
+      spend_bound_lower: The lower bound of spend for each channel. Must be in
+        the same order as `self.channels`.
+      spend_bound_upper: The upper bound of spend for each channel. Must be in
+        the same order as `self.channels`.
 
     Returns:
       updated_spend: The updated spend grid with valid spend values moved up to
@@ -383,7 +389,7 @@ class OptimizationGrid:
 
     return (updated_spend, updated_incremental_outcome)
 
-  def _check_optimization_bounds(
+  def check_optimization_bounds(
       self,
       lower_bound: np.ndarray,
       upper_bound: np.ndarray,
@@ -392,9 +398,9 @@ class OptimizationGrid:
 
     Args:
       lower_bound: `np.ndarray` of shape `(n_channels,)` containing the lower
-        bound for each channel.
+        bound for each channel. Must be in the same order as `self.channels`.
       upper_bound: `np.ndarray` of shape `(n_channels,)` containing the upper
-        bound for each channel.
+        bound for each channel. Must be in the same order as `self.channels`.
 
     Raises:
       ValueError: If the spend grid does not fit within the optimization bounds.
@@ -1138,21 +1144,26 @@ class OptimizationResults:
         - self.nonoptimized_data.total_incremental_outcome
     )
     inc_outcome_prefix = '+' if inc_outcome_diff > 0 else ''
+    currency = '$' if outcome == c.REVENUE else ''
     non_optimized_inc_outcome = formatter.StatsSpec(
         title=summary_text.NON_OPTIMIZED_INC_OUTCOME_LABEL.format(
             outcome=outcome
         ),
-        stat=formatter.format_monetary_num(
-            self.nonoptimized_data.total_incremental_outcome,
+        stat=formatter.compact_number(
+            n=self.nonoptimized_data.total_incremental_outcome,
+            precision=0,
+            currency=currency,
         ),
     )
     optimized_inc_outcome = formatter.StatsSpec(
         title=summary_text.OPTIMIZED_INC_OUTCOME_LABEL.format(outcome=outcome),
-        stat=formatter.format_monetary_num(
-            self.optimized_data.total_incremental_outcome,
+        stat=formatter.compact_number(
+            n=self.optimized_data.total_incremental_outcome,
+            precision=0,
+            currency=currency,
         ),
         delta=inc_outcome_prefix
-        + formatter.format_monetary_num(inc_outcome_diff),
+        + formatter.compact_number(inc_outcome_diff, 0, currency),
     )
     return [
         non_optimized_budget,
@@ -1276,7 +1287,10 @@ class BudgetOptimizer:
       self,
       new_data: analyzer.DataTensors | None = None,
       use_posterior: bool = True,
+      # TODO: b/409550413 - Remove this argument.
       selected_times: tuple[str | None, str | None] | None = None,
+      start_date: tc.Date = None,
+      end_date: tc.Date = None,
       fixed_budget: bool = True,
       budget: float | None = None,
       pct_of_spend: Sequence[float] | None = None,
@@ -1289,6 +1303,7 @@ class BudgetOptimizer:
       use_kpi: bool = False,
       confidence_level: float = c.DEFAULT_CONFIDENCE_LEVEL,
       batch_size: int = c.DEFAULT_BATCH_SIZE,
+      optimization_grid: OptimizationGrid | None = None,
   ) -> OptimizationResults:
     """Finds the optimal budget allocation that maximizes outcome.
 
@@ -1313,8 +1328,15 @@ class BudgetOptimizer:
     `fixed_budget=True`) will be inferred from the `new_data`, but can be
     overridden using the `pct_of_spend` and `budget` arguments.
 
-    If `selected_times` is specified, then the default values are inferred based
-    on the subset of time periods specified.
+    If `start_date` or `end_date` is specified, then the default values are
+    inferred based on the subset of time periods specified. Both start and end
+    time selectors should align with the Meridian time dimension coordinates in
+    the underlying model if optimizing the original data. If `new_data` is
+    provided with a different number of time periods than in `InputData`, then
+    the start and end time coordinates must match the time dimensions in
+    `new_data.time`. By default, all times periods are used. Either start or
+    end time component can be `None` to represent the first or the last time
+    coordinate, respectively.
 
     Args:
       new_data: An optional `DataTensors` container with optional tensors:
@@ -1329,15 +1351,13 @@ class BudgetOptimizer:
       use_posterior: Boolean. If `True`, then the budget is optimized based on
         the posterior distribution of the model. Otherwise, the prior
         distribution is used.
-      selected_times: Tuple containing the start and end time dimension
-        coordinates for the duration to run the optimization on. Selected time
-        values should align with the Meridian time dimension coordinates in the
-        underlying model if optimizing the original data. If `new_data` is
-        provided with a different number of time periods than in `InputData`,
-        then the start and end time coordinates must match the time dimensions
-        in `new_data.time`. By default, all times periods are used. Either start
-        or end time component can be `None` to represent the first or the last
-        time coordinate, respectively.
+      selected_times: Deprecated. Tuple containing the start and end time
+        dimension coordinates for the duration to run the optimization on.
+        Please Use `start_date` and `end_date` instead.
+      start_date: Optional start date selector, *inclusive*, in _yyyy-mm-dd_
+        format. Default is `None`, i.e. the first time period.
+      end_date: Optional end date selector, *inclusive* in _yyyy-mm-dd_ format.
+        Default is `None`, i.e. the last time period.
       fixed_budget: Boolean indicating whether it's a fixed budget optimization
         or flexible budget optimization. Defaults to `True`. If `False`, must
         specify either `target_roi` or `target_mroi`.
@@ -1352,7 +1372,7 @@ class BudgetOptimizer:
         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. If using `new_data`, this argument is ignored.
+        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. If given as a channel-indexed array, the order must
@@ -1389,11 +1409,27 @@ class BudgetOptimizer:
         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.
+      optimization_grid: An `OptimizationGrid` object containing the grid
+        information. Grid creating is a time consuming part of optimization.
+        Creating one grid and running various optimizations on it can save time.
+        If `None` or grid doesn't match the optimization arguments, a new grid
+        will be created.
 
     Returns:
       An `OptimizationResults` object containing optimized budget allocation
       datasets, along with some of the intermediate values used to derive them.
     """
+    if selected_times is not None:
+      warnings.warn(
+          '`selected_times` is deprecated. Please use `start_date` and'
+          ' `end_date` instead.',
+          DeprecationWarning,
+          stacklevel=2,
+      )
+      deprecated_start_date, deprecated_end_date = selected_times
+      start_date = start_date or deprecated_start_date
+      end_date = end_date or deprecated_end_date
+
     _validate_budget(
         fixed_budget=fixed_budget,
         budget=budget,
@@ -1409,19 +1445,36 @@ class BudgetOptimizer:
       spend_constraint_lower = spend_constraint_default
     if spend_constraint_upper is None:
       spend_constraint_upper = spend_constraint_default
-    optimization_grid = self.create_optimization_grid(
+    use_grid_arg = optimization_grid is not None and self._validate_grid(
         new_data=new_data,
-        selected_times=selected_times,
+        use_posterior=use_posterior,
+        start_date=start_date,
+        end_date=end_date,
         budget=budget,
         pct_of_spend=pct_of_spend,
         spend_constraint_lower=spend_constraint_lower,
         spend_constraint_upper=spend_constraint_upper,
         gtol=gtol,
-        use_posterior=use_posterior,
-        use_kpi=use_kpi,
         use_optimal_frequency=use_optimal_frequency,
-        batch_size=batch_size,
+        use_kpi=use_kpi,
+        optimization_grid=optimization_grid,
     )
+    if optimization_grid is None or not use_grid_arg:
+      optimization_grid = self.create_optimization_grid(
+          new_data=new_data,
+          start_date=start_date,
+          end_date=end_date,
+          budget=budget,
+          pct_of_spend=pct_of_spend,
+          spend_constraint_lower=spend_constraint_lower,
+          spend_constraint_upper=spend_constraint_upper,
+          gtol=gtol,
+          use_posterior=use_posterior,
+          use_kpi=use_kpi,
+          use_optimal_frequency=use_optimal_frequency,
+          batch_size=batch_size,
+      )
+
     if fixed_budget:
       scenario = FixedBudgetScenario(total_budget=budget)
     elif target_roi:
@@ -1442,26 +1495,24 @@ class BudgetOptimizer:
     use_historical_budget = budget is None or np.isclose(
         budget, np.sum(optimization_grid.historical_spend)
     )
-    rounded_spend = np.round(
-        spend.non_optimized, optimization_grid.round_factor
-    ).astype(int)
+    new_data = new_data or analyzer.DataTensors()
     nonoptimized_data = self._create_budget_dataset(
-        new_data=new_data,
+        new_data=new_data.filter_fields(c.PAID_DATA + (c.TIME,)),
         use_posterior=use_posterior,
         use_kpi=use_kpi,
         hist_spend=optimization_grid.historical_spend,
-        spend=rounded_spend,
+        spend=spend.non_optimized,
         selected_times=optimization_grid.selected_times,
         confidence_level=confidence_level,
         batch_size=batch_size,
         use_historical_budget=use_historical_budget,
     )
     nonoptimized_data_with_optimal_freq = self._create_budget_dataset(
-        new_data=new_data,
+        new_data=new_data.filter_fields(c.PAID_DATA + (c.TIME,)),
         use_posterior=use_posterior,
         use_kpi=use_kpi,
         hist_spend=optimization_grid.historical_spend,
-        spend=rounded_spend,
+        spend=spend.non_optimized,
         selected_times=optimization_grid.selected_times,
         optimal_frequency=optimization_grid.optimal_frequency,
         confidence_level=confidence_level,
@@ -1476,7 +1527,7 @@ class BudgetOptimizer:
     elif target_mroi:
       constraints[c.TARGET_MROI] = target_mroi
     optimized_data = self._create_budget_dataset(
-        new_data=new_data,
+        new_data=new_data.filter_fields(c.PAID_DATA + (c.TIME,)),
         use_posterior=use_posterior,
         use_kpi=use_kpi,
         hist_spend=optimization_grid.historical_spend,
@@ -1520,11 +1571,139 @@ class BudgetOptimizer:
         _optimization_grid=optimization_grid,
     )
 
+  def _validate_grid(
+      self,
+      new_data: analyzer.DataTensors | None,
+      use_posterior: bool,
+      start_date: tc.Date,
+      end_date: tc.Date,
+      budget: float | None,
+      pct_of_spend: Sequence[float] | None,
+      spend_constraint_lower: _SpendConstraint,
+      spend_constraint_upper: _SpendConstraint,
+      gtol: float,
+      use_optimal_frequency: bool,
+      use_kpi: bool,
+      optimization_grid: OptimizationGrid,
+  ) -> bool:
+    """Checks if the grid is valid for the optimization scenario."""
+
+    if use_posterior != optimization_grid.use_posterior:
+      warnings.warn(
+          'Given optimization grid was created with `use_posterior` ='
+          f' {optimization_grid.use_posterior}, but optimization was called'
+          f' with `use_posterior` = {use_posterior}. A new grid will be'
+          ' created.'
+      )
+      return False
+
+    if use_kpi != optimization_grid.use_kpi:
+      warnings.warn(
+          'Given optimization grid was created with `use_kpi` ='
+          f' {optimization_grid.use_kpi}, but optimization was called'
+          f' with `use_kpi` = {use_kpi}. A new grid will be'
+          ' created.'
+      )
+      return False
+
+    if use_optimal_frequency != optimization_grid.use_optimal_frequency:
+      warnings.warn(
+          'Given optimization grid was created with `use_optimal_frequency` ='
+          f' {optimization_grid.use_optimal_frequency}, but optimization was'
+          f' called with `use_optimal_frequency` = {use_optimal_frequency}. A'
+          ' new grid will be created.'
+      )
+      return False
+
+    if (
+        start_date != optimization_grid.start_date
+        or end_date != optimization_grid.end_date
+    ):
+      warnings.warn(
+          'Given optimization grid was created with `start_date` ='
+          f' {optimization_grid.start_date} and `end_date` ='
+          f' {optimization_grid.end_date}, but optimization was called with'
+          f' `start_date` = {start_date} and `end_date` = {end_date}. A new'
+          ' grid will be created.'
+      )
+      return False
+
+    if new_data is None:
+      new_data = analyzer.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
+    )
+    paid_channels = self._meridian.input_data.get_all_paid_channels()
+    if not np.array_equal(paid_channels, optimization_grid.channels):
+      warnings.warn(
+          'Given optimization grid was created with `channels` ='
+          f' {optimization_grid.channels}, but optimization request was'
+          f' resolved with `channels` = {paid_channels}. A new grid will be'
+          ' created.'
+      )
+      return False
+
+    n_channels = len(optimization_grid.channels)
+    selected_times = self._validate_selected_times(
+        start_date=start_date,
+        end_date=end_date,
+        new_data=new_data,
+    )
+    hist_spend = self._analyzer.get_aggregated_spend(
+        new_data=filled_data.filter_fields(c.PAID_CHANNELS + c.SPEND_DATA),
+        selected_times=selected_times,
+        include_media=self._meridian.n_media_channels > 0,
+        include_rf=self._meridian.n_rf_channels > 0,
+    ).data
+    budget = budget or np.sum(hist_spend)
+    valid_pct_of_spend = _validate_pct_of_spend(
+        n_channels=n_channels,
+        hist_spend=hist_spend,
+        pct_of_spend=pct_of_spend,
+    )
+    spend = budget * valid_pct_of_spend
+    (optimization_lower_bound, optimization_upper_bound) = (
+        _get_optimization_bounds(
+            n_channels=n_channels,
+            spend=spend,
+            round_factor=optimization_grid.round_factor,
+            spend_constraint_lower=spend_constraint_lower,
+            spend_constraint_upper=spend_constraint_upper,
+        )
+    )
+    try:
+      optimization_grid.check_optimization_bounds(
+          lower_bound=optimization_lower_bound,
+          upper_bound=optimization_upper_bound,
+      )
+    except ValueError as e:
+      warnings.warn(
+          'Optimization called with bounds that are not within the grid. A new'
+          f' grid will be created. Error message: {str(e)}'
+      )
+      return False
+
+    round_factor = _get_round_factor(budget, gtol)
+    if round_factor != optimization_grid.round_factor:
+      warnings.warn(
+          'Optimization accuracy may suffer owing to budget level differences.'
+          ' Consider creating a new grid with smaller `gtol` if you intend to'
+          ' shrink total budget significantly across optimization runs.'
+          ' It is only a problem when you use a much smaller budget, '
+          ' for which the intended step size is smaller.'
+      )
+
+    return True
+
   def create_optimization_grid(
       self,
       new_data: xr.Dataset | None = None,
       use_posterior: bool = True,
+      # TODO: b/409550413 - Remove this argument.
       selected_times: tuple[str | None, str | None] | None = None,
+      start_date: tc.Date = None,
+      end_date: tc.Date = None,
       budget: float | None = None,
       pct_of_spend: Sequence[float] | None = None,
       spend_constraint_lower: _SpendConstraint = c.SPEND_CONSTRAINT_DEFAULT,
@@ -1536,6 +1715,16 @@ class BudgetOptimizer:
   ) -> OptimizationGrid:
     """Creates a OptimizationGrid for optimization.
 
+    If `start_date` or `end_date` is specified, then the default values are
+    inferred based on the subset of time periods specified. Both start and end
+    time selectors should align with the Meridian time dimension coordinates in
+    the underlying model if optimizing the original data. If `new_data` is
+    provided with a different number of time periods than in `InputData`, then
+    the start and end time coordinates must match the time dimensions in
+    `new_data.time`. By default, all times periods are used. Either start or
+    end time component can be `None` to represent the first or the last time
+    coordinate, respectively.
+
     Args:
       new_data: An optional `DataTensors` container with optional tensors:
         `media`, `reach`, `frequency`, `media_spend`, `rf_spend`,
@@ -1549,15 +1738,12 @@ class BudgetOptimizer:
       use_posterior: Boolean. If `True`, then the incremental outcome is derived
         from the posterior distribution of the model. Otherwise, the prior
         distribution is used.
-      selected_times: Tuple containing the start and end time dimension
-        coordinates for the duration to run the optimization on. Selected time
-        values should align with the Meridian time dimension coordinates in the
-        underlying model if optimizing the original data. If `new_data` is
-        provided with a different number of time periods than in `InputData`,
-        then the start and end time coordinates must match the time dimensions
-        in `new_data.time`. By default, all times periods are used. Either start
-        or end time component can be `None` to represent the first or the last
-        time coordinate, respectively.
+      selected_times: Deprecated. Tuple containing the start and end time
+        dimension coordinates. Please Use `start_date` and `end_date` instead.
+      start_date: Optional start date selector, *inclusive*, in _yyyy-mm-dd_
+        format. Default is `None`, i.e. the first time period.
+      end_date: Optional end date selector, *inclusive* in _yyyy-mm-dd_ format.
+        Default is `None`, i.e. the last time period.
       budget: Number indicating the total budget for the fixed budget scenario.
         Defaults to the historical budget.
       pct_of_spend: Numeric list of size `n_paid_channels` containing the
@@ -1569,7 +1755,7 @@ class BudgetOptimizer:
         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. If using `new_data`, this argument is ignored.
+        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. If given as a channel-indexed array, the order must
@@ -1607,17 +1793,29 @@ class BudgetOptimizer:
     if new_data is None:
       new_data = analyzer.DataTensors()
 
+    if selected_times is not None:
+      warnings.warn(
+          '`selected_times` is deprecated. Please use `start_date` and'
+          ' `end_date` instead.',
+          DeprecationWarning,
+          stacklevel=2,
+      )
+      deprecated_start_date, deprecated_end_date = selected_times
+      start_date = start_date or deprecated_start_date
+      end_date = end_date or deprecated_end_date
+
     required_tensors = c.PERFORMANCE_DATA + (c.TIME,)
     filled_data = new_data.validate_and_fill_missing_data(
         required_tensors_names=required_tensors, meridian=self._meridian
     )
-
-    selected_time_dims = self._validate_selected_times(
-        selected_times, filled_data
+    selected_times = self._validate_selected_times(
+        start_date=start_date,
+        end_date=end_date,
+        new_data=filled_data,
     )
     hist_spend = self._analyzer.get_aggregated_spend(
         new_data=filled_data.filter_fields(c.PAID_CHANNELS + c.SPEND_DATA),
-        selected_times=selected_time_dims,
+        selected_times=selected_times,
         include_media=self._meridian.n_media_channels > 0,
         include_rf=self._meridian.n_rf_channels > 0,
     ).data
@@ -1644,7 +1842,7 @@ class BudgetOptimizer:
           self._analyzer.optimal_freq(
               new_data=filled_data.filter_fields(c.RF_DATA),
               use_posterior=use_posterior,
-              selected_times=selected_time_dims,
+              selected_times=selected_times,
               use_kpi=use_kpi,
           ).optimal_frequency,
           dtype=tf.float32,
@@ -1658,7 +1856,7 @@ class BudgetOptimizer:
         spend_bound_lower=optimization_lower_bound,
         spend_bound_upper=optimization_upper_bound,
         step_size=step_size,
-        selected_times=selected_time_dims,
+        selected_times=selected_times,
         new_data=filled_data.filter_fields(c.PAID_DATA),
         use_posterior=use_posterior,
         use_kpi=use_kpi,
@@ -1677,10 +1875,12 @@ class BudgetOptimizer:
         use_kpi=use_kpi,
         use_posterior=use_posterior,
         use_optimal_frequency=use_optimal_frequency,
+        start_date=start_date,
+        end_date=end_date,
         gtol=gtol,
         round_factor=round_factor,
         optimal_frequency=optimal_frequency,
-        selected_times=selected_time_dims,
+        selected_times=selected_times,
     )
 
   def _create_grid_dataset(
@@ -1725,13 +1925,11 @@ class BudgetOptimizer:
 
   def _validate_selected_times(
       self,
-      selected_times: tuple[str | None, str | None] | None,
+      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 selected_times is None:
-      return None
-    start_date, end_date = selected_times
     if start_date is None and end_date is None:
       return None
 
@@ -2358,7 +2556,7 @@ def _validate_budget(
     budget: float | None,
     target_roi: float | None,
     target_mroi: float | None,
-):
+) -> None:
   """Validates the budget optimization arguments."""
   if fixed_budget:
     if target_roi is not None:

meridian/analysis/summarizer.py

@@ -75,8 +75,8 @@ class Summarizer:
       self,
       filename: str,
       filepath: str,
-      start_date: tc.Date | None = None,
-      end_date: tc.Date | None = None,
+      start_date: tc.Date = None,
+      end_date: tc.Date = None,
   ):
     """Generates and saves the HTML results summary output.
 
@@ -93,8 +93,8 @@ class Summarizer:
 
   def _gen_model_results_summary(
       self,
-      start_date: tc.Date | None = None,
-      end_date: tc.Date | None = None,
+      start_date: tc.Date = None,
+      end_date: tc.Date = None,
   ) -> str:
     """Generate HTML results summary output (as sanitized content str)."""
     all_dates = self._meridian.input_data.time_coordinates.all_dates