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

{google_meridian-1.0.8.dist-info → google_meridian-1.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-meridian
-Version: 1.0.8
+Version: 1.0.9
 Summary: Google's open source mixed marketing model library, helps you understand your return on investment and direct your ad spend with confidence. 
 Author-email: The Meridian Authors <no-reply@google.com>
 License: 
@@ -393,7 +393,7 @@ To cite this repository:
   author = {Google Meridian Marketing Mix Modeling Team},
   title = {Meridian: Marketing Mix Modeling},
   url = {https://github.com/google/meridian},
-  version = {1.0.8},
+  version = {1.0.9},
   year = {2025},
 }
 ```

{google_meridian-1.0.8.dist-info → google_meridian-1.0.9.dist-info}/RECORD

@@ -1,14 +1,14 @@
-google_meridian-1.0.8.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-meridian/__init__.py,sha256=d85YKzKshDwbViGr-BG7DJhNJh8a-dVF87y83gnTv7I,714
-meridian/constants.py,sha256=vhJI7R3kTGIHkLzkyx3i6ZnpcAXdAo4ath1eBS6cQHQ,15197
+google_meridian-1.0.9.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+meridian/__init__.py,sha256=b7KL3QTlpVq4JvFAzhv7fcEUz6iiBqeGwZrzLv_JLjI,714
+meridian/constants.py,sha256=OHzrSdGcburXB1miI9oPZ_6mdf6wokKq2zhzwo9YA84,15434
 meridian/analysis/__init__.py,sha256=-FooDZ5OzePpyTVkvRoWQx_xBaRR_hjVLny9H8-kkyQ,836
-meridian/analysis/analyzer.py,sha256=HyFJlTUYsv03skU4SiPvqjwevq7TXabwtD9VhoGObsw,200181
+meridian/analysis/analyzer.py,sha256=nFODFwnrR2QC2FiEX11UgMGrVHkud_KzUsTpKUtQiSo,203965
 meridian/analysis/formatter.py,sha256=F8OYxD2bH13zV10JY63j2ugCOj-DpTXhyJr43n5ukr8,7270
-meridian/analysis/optimizer.py,sha256=NwHb5PBhHye4XtPhh0qv0ZMCq6LwErZXFa86BwmtKLs,90115
-meridian/analysis/summarizer.py,sha256=jkESRdbH1U3ij-aBdV1JFTYNVJdfALmji5G4jmK4oMs,18403
+meridian/analysis/optimizer.py,sha256=SVZJjO0nZjWL62PoeuIBf5_iPdDMdgmA3fuY1R8pEsU,98126
+meridian/analysis/summarizer.py,sha256=PPin1hKvcdGuzNOlXOsCtCO0JzawyBb26g4LEFptRh0,18883
 meridian/analysis/summary_text.py,sha256=n6a-DTZxtS3WvdI_pDEK7lvO3MRUX3h83GzuVnG6sQ4,12438
 meridian/analysis/test_utils.py,sha256=xai8oxXu51PDsiQ-ZYTnN_eSLsGu0BUOS8rDTcc6v-E,77719
-meridian/analysis/visualizer.py,sha256=_40uBa6QMJSjfwsvswcbGRUN3Urr_Vs16XiwpWETAfc,92624
+meridian/analysis/visualizer.py,sha256=KgqdqbYkvo1vY0u-JGuIYEpwMR1xUvJToG1QcIaVuPo,94138
 meridian/analysis/templates/card.html.jinja,sha256=pv4MVbQ25CcvtZY-LH7bFW0OSeHobkeEkAleB1sfQ14,1284
 meridian/analysis/templates/chart.html.jinja,sha256=87i0xnXHRBoLLxBpKv2i960TLToWq4r1aVQZqaXIeMQ,1086
 meridian/analysis/templates/chips.html.jinja,sha256=Az0tQwF_-b03JDLyOzpeH-8fb-6jgJgbNfnUUSm-q6E,645
@@ -28,14 +28,14 @@ meridian/model/__init__.py,sha256=bvx8vvXolktsCTDKViU9U1v85pgNWF3haDowTKy11d4,98
 meridian/model/adstock_hill.py,sha256=b_YYhqci6ndgi602FFXmx2f12ceC4N0tp338nMMtm54,9283
 meridian/model/knots.py,sha256=r7PPaJM96d5pkoOeV9crIOgkM0-rh24mWMvypMiV4aQ,8054
 meridian/model/media.py,sha256=Gjr4jm0y_6pFy7aa_oKIuuZ8P7F56e3ZB-3o6msApeA,11876
-meridian/model/model.py,sha256=hA6HSaH2cd7Zgm8_JX3Jd79bWQSk8BtdqfEm5C9e3oQ,43323
+meridian/model/model.py,sha256=CgBzyR8KWE3lPecaCTg0FF16booUOpsE3ARNcm5KrFc,43875
 meridian/model/model_test_data.py,sha256=dqS_vDQUg811UGmyr8ZgWp8VTIra-krA7A2erQlfPlU,12488
 meridian/model/posterior_sampler.py,sha256=uUNMdxyoK0LT6hNKiAxEEl-1X0SyBMz-o_Sao5q5Ts8,23228
-meridian/model/prior_distribution.py,sha256=6fqx_XIM0DSQICd65XaSRhelsjvZ4ariBfeyOeoKld8,39075
+meridian/model/prior_distribution.py,sha256=h-L6hLOC-bM9ciYCvbZbDN7-3-30AwHBbo06KsSwDiY,39934
 meridian/model/prior_sampler.py,sha256=zGSAQviFO3s2GcVbfG9EfXxo_SNFBFbTQC3e-QBFzio,23079
 meridian/model/spec.py,sha256=xaHxfCLWLnWMAkMy2ouDoqGBHI_4tzzX8AaJOsKdu7Q,8878
 meridian/model/transformers.py,sha256=te3OJixprWLtv7O00a9GZWE4waTS94NNLVo3tWIl1-k,7420
-google_meridian-1.0.8.dist-info/METADATA,sha256=DaSRL6L3xb0AiZBw22nbxDbFqvm2thApTpiEzffGe-o,22055
-google_meridian-1.0.8.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-google_meridian-1.0.8.dist-info/top_level.txt,sha256=nwaCebZvvU34EopTKZsjK0OMTFjVnkf4FfnBN_TAc0g,9
-google_meridian-1.0.8.dist-info/RECORD,,
+google_meridian-1.0.9.dist-info/METADATA,sha256=N6Y923SR6L6T5Py0xVpNwZm0lBl-mXWC2oCnYq903pM,22055
+google_meridian-1.0.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+google_meridian-1.0.9.dist-info/top_level.txt,sha256=nwaCebZvvU34EopTKZsjK0OMTFjVnkf4FfnBN_TAc0g,9
+google_meridian-1.0.9.dist-info/RECORD,,

meridian/__init__.py

@@ -14,7 +14,7 @@
 
 """Meridian API."""
 
-__version__ = "1.0.8"
+__version__ = "1.0.9"
 
 
 from meridian import analysis

meridian/analysis/analyzer.py

@@ -63,6 +63,8 @@ class DataTensors(tf.experimental.ExtensionType):
     controls: Optional tensor with dimensions `(n_geos, n_times, n_controls)`.
     revenue_per_kpi: Optional tensor with dimensions `(n_geos, T)` for any time
       dimension `T`.
+    time: Optional tensor of time coordinates in the "YYYY-mm-dd" string format
+      for time dimension `T`.
   """
 
   media: Optional[tf.Tensor]
@@ -76,6 +78,7 @@ class DataTensors(tf.experimental.ExtensionType):
   non_media_treatments: Optional[tf.Tensor]
   controls: Optional[tf.Tensor]
   revenue_per_kpi: Optional[tf.Tensor]
+  time: Optional[tf.Tensor]
 
   def __init__(
       self,
@@ -90,6 +93,7 @@ class DataTensors(tf.experimental.ExtensionType):
       non_media_treatments: Optional[tf.Tensor] = None,
       controls: Optional[tf.Tensor] = None,
       revenue_per_kpi: Optional[tf.Tensor] = None,
+      time: Optional[Sequence[str] | tf.Tensor] = None,
   ):
     self.media = tf.cast(media, tf.float32) if media is not None else None
     self.media_spend = (
@@ -130,6 +134,7 @@ class DataTensors(tf.experimental.ExtensionType):
         if revenue_per_kpi is not None
         else None
     )
+    self.time = tf.cast(time, tf.string) if time is not None else None
 
   def __validate__(self):
     self._validate_n_dims()
@@ -241,6 +246,8 @@ class DataTensors(tf.experimental.ExtensionType):
               f"New `{field.name}` must have 1 or 3 dimensions. Found"
               f" {tensor.ndim} dimensions."
           )
+      elif field.name == constants.TIME:
+        _check_n_dims(tensor, field.name, 1)
       else:
         _check_n_dims(tensor, field.name, 3)
 
@@ -283,7 +290,7 @@ class DataTensors(tf.experimental.ExtensionType):
     for var_name in required_fields:
       new_tensor = getattr(self, var_name)
       if new_tensor is not None and new_tensor.shape[0] != meridian.n_geos:
-        # Skip spend data with only 1 dimension of (n_channels).
+        # Skip spend and time data with only 1 dimension.
         if new_tensor.ndim == 1:
           continue
         raise ValueError(
@@ -296,7 +303,7 @@ class DataTensors(tf.experimental.ExtensionType):
   ):
     """Validates the channel dimension of the specified data variables."""
     for var_name in required_fields:
-      if var_name == constants.REVENUE_PER_KPI:
+      if var_name in [constants.REVENUE_PER_KPI, constants.TIME]:
         continue
       new_tensor = getattr(self, var_name)
       old_tensor = getattr(meridian.input_data, var_name)
@@ -317,12 +324,24 @@ class DataTensors(tf.experimental.ExtensionType):
       old_tensor = getattr(meridian.input_data, var_name)
 
       # Skip spend data with only 1 dimension of (n_channels).
-      if new_tensor is not None and new_tensor.ndim == 1:
+      if (
+          var_name in [constants.MEDIA_SPEND, constants.RF_SPEND]
+          and new_tensor is not None
+          and new_tensor.ndim == 1
+      ):
         continue
 
       if new_tensor is not None:
         assert old_tensor is not None
-        if new_tensor.shape[1] != old_tensor.shape[1]:
+        if (
+            var_name == constants.TIME
+            and new_tensor.shape[0] != old_tensor.shape[0]
+        ):
+          raise ValueError(
+              f"New `{var_name}` is expected to have {old_tensor.shape[0]}"
+              f" time periods. Found {new_tensor.shape[0]} time periods."
+          )
+        elif new_tensor.ndim > 1 and new_tensor.shape[1] != old_tensor.shape[1]:
           raise ValueError(
               f"New `{var_name}` is expected to have {old_tensor.shape[1]}"
               f" time periods. Found {new_tensor.shape[1]} time periods."
@@ -345,12 +364,24 @@ class DataTensors(tf.experimental.ExtensionType):
       if old_tensor is None:
         continue
       # Skip spend data with only 1 dimension of (n_channels).
-      if new_tensor is not None and new_tensor.ndim == 1:
+      if (
+          var_name in [constants.MEDIA_SPEND, constants.RF_SPEND]
+          and new_tensor is not None
+          and new_tensor.ndim == 1
+      ):
         continue
 
       if new_tensor is None:
         missing_params.append(var_name)
-      elif new_tensor.shape[1] != new_n_times:
+      elif var_name == constants.TIME and new_tensor.shape[0] != new_n_times:
+        raise ValueError(
+            "If the time dimension of any variable in `new_data` is "
+            "modified, then all variables must be provided with the same "
+            f"number of time periods. `{var_name}` has {new_tensor.shape[1]} "
+            "time periods, which does not match the modified number of time "
+            f"periods, {new_n_times}.",
+        )
+      elif new_tensor.ndim > 1 and new_tensor.shape[1] != new_n_times:
         raise ValueError(
             "If the time dimension of any variable in `new_data` is "
             "modified, then all variables must be provided with the same "
@@ -390,6 +421,10 @@ class DataTensors(tf.experimental.ExtensionType):
         old_tensor = meridian.controls
       elif var_name == constants.REVENUE_PER_KPI:
         old_tensor = meridian.revenue_per_kpi
+      elif var_name == constants.TIME:
+        old_tensor = tf.convert_to_tensor(
+            meridian.input_data.time.values.tolist(), dtype=tf.string
+        )
       else:
         continue
 
@@ -4663,11 +4698,11 @@ class Analyzer:
 
   def get_historical_spend(
       self,
-      selected_times: Sequence[str] | None,
+      selected_times: Sequence[str] | None = None,
       include_media: bool = True,
       include_rf: bool = True,
   ) -> xr.DataArray:
-    """Gets the aggregated historical spend based on the time period.
+    """Deprecated. Gets the aggregated historical spend based on the time.
 
     Args:
       selected_times: The time period to get the historical spends. If None, the
@@ -4681,6 +4716,51 @@ class Analyzer:
       An `xr.DataArray` with the coordinate `channel` and contains the data
       variable `spend`.
 
+    Raises:
+      ValueError: A ValueError is raised when `include_media` and `include_rf`
+      are both False.
+    """
+    warnings.warn(
+        "`get_historical_spend` is deprecated. Please use "
+        "`get_aggregated_spend` with `new_data=None` instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return self.get_aggregated_spend(
+        selected_times=selected_times,
+        include_media=include_media,
+        include_rf=include_rf,
+    )
+
+  def get_aggregated_spend(
+      self,
+      new_data: DataTensors | None = None,
+      selected_times: Sequence[str] | Sequence[bool] | None = None,
+      include_media: bool = True,
+      include_rf: bool = True,
+  ) -> xr.DataArray:
+    """Gets the aggregated spend based on the selected time.
+
+    Args:
+      new_data: An optional `DataTensors` object containing the new `media`,
+        `media_spend`, `reach`, `frequency`, `rf_spend` tensors. If `None`, the
+        existing tensors from the Meridian object are used. If `new_data`
+        argument is used, then the aggregated spend is computed using the values
+        of the tensors passed in the `new_data` argument and the original values
+        of all the remaining tensors.  If any of the tensors in `new_data` is
+        provided with a different number of time periods than in `InputData`,
+        then all tensors must be provided with the same number of time periods.
+      selected_times: The time period to get the aggregated spends. If None, the
+        spend will be aggregated over all time periods.
+      include_media: Whether to include spends for paid media channels that do
+        not have R&F data.
+      include_rf: Whether to include spends for paid media channels with R&F
+        data.
+
+    Returns:
+      An `xr.DataArray` with the coordinate `channel` and contains the data
+      variable `spend`.
+
     Raises:
       ValueError: A ValueError is raised when `include_media` and `include_rf`
       are both False.
@@ -4689,6 +4769,11 @@ class Analyzer:
       raise ValueError(
           "At least one of include_media or include_rf must be True."
       )
+    new_data = new_data or DataTensors()
+    required_tensors_names = constants.PAID_CHANNELS + constants.SPEND_DATA
+    filled_data = new_data.validate_and_fill_missing_data(
+        required_tensors_names, self._meridian
+    )
 
     empty_da = xr.DataArray(
         dims=[constants.CHANNEL], coords={constants.CHANNEL: []}
@@ -4709,8 +4794,8 @@ class Analyzer:
     else:
       aggregated_media_spend = self._impute_and_aggregate_spend(
           selected_times,
-          self._meridian.media_tensors.media,
-          self._meridian.media_tensors.media_spend,
+          filled_data.media,
+          filled_data.media_spend,
           list(self._meridian.input_data.media_channel.values),
       )
 
@@ -4723,18 +4808,16 @@ class Analyzer:
         or self._meridian.rf_tensors.rf_spend is None
     ):
       warnings.warn(
-          "Requested spends for paid media channels with R&F data, but but the"
+          "Requested spends for paid media channels with R&F data, but the"
           " channels are not available.",
       )
       aggregated_rf_spend = empty_da
     else:
-      rf_execution_values = (
-          self._meridian.rf_tensors.reach * self._meridian.rf_tensors.frequency
-      )
+      rf_execution_values = filled_data.reach * filled_data.frequency
       aggregated_rf_spend = self._impute_and_aggregate_spend(
           selected_times,
           rf_execution_values,
-          self._meridian.rf_tensors.rf_spend,
+          filled_data.rf_spend,
           list(self._meridian.input_data.rf_channel.values),
       )
 
@@ -4744,7 +4827,7 @@ class Analyzer:
 
   def _impute_and_aggregate_spend(
       self,
-      selected_times: Sequence[str] | None,
+      selected_times: Sequence[str] | Sequence[bool] | None,
       media_execution_values: tf.Tensor,
       channel_spend: tf.Tensor,
       channel_names: Sequence[str],
@@ -4759,7 +4842,7 @@ class Analyzer:
     argument, its values only affect the output when imputation is required.
 
     Args:
-      selected_times: The time period to get the historical spend.
+      selected_times: The time period to get the aggregated spend.
       media_execution_values: The media execution values over all time points.
       channel_spend: The spend over all time points. Its shape can be `(n_geos,
         n_times, n_media_channels)` or `(n_media_channels,)` if the data is
@@ -4775,17 +4858,24 @@ class Analyzer:
         "selected_times": selected_times,
         "aggregate_geos": True,
         "aggregate_times": True,
+        "flexible_time_dim": True,
     }
 
     if channel_spend.ndim == 3:
       aggregated_spend = self.filter_and_aggregate_geos_and_times(
           channel_spend,
+          has_media_dim=True,
           **dim_kwargs,
       ).numpy()
     # channel_spend.ndim can only be 3 or 1.
     else:
       # media spend can have more time points than the model time points
-      media_exe_values = media_execution_values[:, -self._meridian.n_times :, :]
+      if media_execution_values.shape[1] == self._meridian.n_media_times:
+        media_exe_values = media_execution_values[
+            :, -self._meridian.n_times :, :
+        ]
+      else:
+        media_exe_values = media_execution_values
       # Calculates CPM over all times and geos if the spend does not have time
       # and geo dimensions.
       target_media_exe_values = self.filter_and_aggregate_geos_and_times(

meridian/analysis/optimizer.py

@@ -28,6 +28,7 @@ from meridian import constants as c
 from meridian.analysis import analyzer
 from meridian.analysis import formatter
 from meridian.analysis import summary_text
+from meridian.data import time_coordinates as tc
 from meridian.model import model
 import numpy as np
 import pandas as pd
@@ -119,7 +120,7 @@ class OptimizationGrid:
   gtol: float
   round_factor: int
   optimal_frequency: np.ndarray | None
-  selected_times: list[str] | None
+  selected_times: Sequence[str] | Sequence[bool] | None
 
   @property
   def grid_dataset(self) -> xr.Dataset:
@@ -621,7 +622,7 @@ class OptimizationResults:
     # by adjusting the domain of the y-axis so that the incremental outcome does
     # not start at 0. Calculate the total decrease in incremental outcome to pad
     # the y-axis from the non-optimized total incremental outcome value.
-    sum_decr = sum(df[df.incremental_outcome < 0].incremental_outcome)
+    sum_decr = df[df.incremental_outcome < 0].incremental_outcome.sum()
     y_padding = float(f'1e{int(math.log10(-sum_decr))}') if sum_decr < 0 else 2
     domain_scale = [
         self.nonoptimized_data.total_incremental_outcome + sum_decr - y_padding,
@@ -1016,8 +1017,16 @@ class OptimizationResults:
 
   def _gen_optimization_summary(self) -> str:
     """Generates HTML optimization summary output (as sanitized content str)."""
-    self.template_env.globals[c.START_DATE] = self.optimized_data.start_date
-    self.template_env.globals[c.END_DATE] = self.optimized_data.end_date
+    start_date = tc.normalize_date(self.optimized_data.start_date)
+    self.template_env.globals[c.START_DATE] = start_date.strftime(
+        f'%b {start_date.day}, %Y'
+    )
+    interval_days = self.meridian.input_data.time_coordinates.interval_days
+    end_date = tc.normalize_date(self.optimized_data.end_date)
+    end_date_adjusted = end_date + pd.Timedelta(days=interval_days)
+    self.template_env.globals[c.END_DATE] = end_date_adjusted.strftime(
+        f'%b {end_date_adjusted.day}, %Y'
+    )
 
     html_template = self.template_env.get_template('summary.html.jinja')
     return html_template.render(
@@ -1265,6 +1274,7 @@ class BudgetOptimizer:
 
   def optimize(
       self,
+      new_data: analyzer.DataTensors | None = None,
       use_posterior: bool = True,
       selected_times: tuple[str | None, str | None] | None = None,
       fixed_budget: bool = True,
@@ -1282,18 +1292,50 @@ class BudgetOptimizer:
   ) -> OptimizationResults:
     """Finds the optimal budget allocation that maximizes outcome.
 
-    Outcome is typically revenue, but when the KPI is not revenue and "revenue
-    per KPI" data is not available, then Meridian defines the Outcome to be the
-    KPI itself.
+    Optimization depends on the following:
+    1. Flighting pattern (the relative allocation of a channels' media units
+       across geos and time periods, which is held fixed for each channel)
+    2. Cost per media unit (This is assumed to be constant for each channel, and
+       can optionally vary by geo and/or time period)
+    3. `pct_of_spend` (center of the spend box constraint for each channel)
+    4. `budget` (total budget used for fixed budget scenarios)
+
+    By default, these values are assigned based on the historical data. The
+    `pct_of_spend` and `budget` are optimization arguments that can be
+    overridden directly. Passing `new_data.media` (or `new_data.reach` or
+    `new_data.frequency`) will override both the flighting pattern and cost per
+    media unit. Passing `new_data.spend` (or `new_data.rf_spend) will only
+    override the cost per media unit.
+
+    If `new_data` is passed with a different number of time periods than the
+    historical data, then all of the optimization parameters will be inferred
+    from it. Default values for `pct_of_spend` and `budget` (if
+    `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.
 
     Args:
+      new_data: An optional `DataTensors` container with optional tensors:
+        `media`, `reach`, `frequency`, `media_spend`, `rf_spend`,
+        `revenue_per_kpi`, and `time`. If `None`, the original tensors from the
+        Meridian object are used. If `new_data` is provided, the optimization is
+        run on the versions of the tensors in `new_data` and the original
+        versions of all the remaining tensors. If any of the tensors in
+        `new_data` is provided with a different number of time periods than in
+        `InputData`, then all tensors must be provided with the same number of
+        time periods and the `time` tensor must be provided.
       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. By default, all times periods are used. Either start
+        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.
       fixed_budget: Boolean indicating whether it's a fixed budget optimization
@@ -1310,7 +1352,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.
+        argument. If using `new_data`, this argument is ignored.
       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
@@ -1368,6 +1410,7 @@ class BudgetOptimizer:
     if spend_constraint_upper is None:
       spend_constraint_upper = spend_constraint_default
     optimization_grid = self.create_optimization_grid(
+        new_data=new_data,
         selected_times=selected_times,
         budget=budget,
         pct_of_spend=pct_of_spend,
@@ -1403,6 +1446,7 @@ class BudgetOptimizer:
         spend.non_optimized, optimization_grid.round_factor
     ).astype(int)
     nonoptimized_data = self._create_budget_dataset(
+        new_data=new_data,
         use_posterior=use_posterior,
         use_kpi=use_kpi,
         hist_spend=optimization_grid.historical_spend,
@@ -1413,6 +1457,7 @@ class BudgetOptimizer:
         use_historical_budget=use_historical_budget,
     )
     nonoptimized_data_with_optimal_freq = self._create_budget_dataset(
+        new_data=new_data,
         use_posterior=use_posterior,
         use_kpi=use_kpi,
         hist_spend=optimization_grid.historical_spend,
@@ -1431,6 +1476,7 @@ class BudgetOptimizer:
     elif target_mroi:
       constraints[c.TARGET_MROI] = target_mroi
     optimized_data = self._create_budget_dataset(
+        new_data=new_data,
         use_posterior=use_posterior,
         use_kpi=use_kpi,
         hist_spend=optimization_grid.historical_spend,
@@ -1476,6 +1522,7 @@ class BudgetOptimizer:
 
   def create_optimization_grid(
       self,
+      new_data: xr.Dataset | None = None,
       use_posterior: bool = True,
       selected_times: tuple[str | None, str | None] | None = None,
       budget: float | None = None,
@@ -1490,13 +1537,25 @@ class BudgetOptimizer:
     """Creates a OptimizationGrid for optimization.
 
     Args:
+      new_data: An optional `DataTensors` container with optional tensors:
+        `media`, `reach`, `frequency`, `media_spend`, `rf_spend`,
+        `revenue_per_kpi`, and `time`. If `None`, the original tensors from the
+        Meridian object are used. If `new_data` is provided, the grid is created
+        using the versions of the tensors in `new_data` and the original
+        versions of all the remaining tensors. If any of the tensors in
+        `new_data` is provided with a different number of time periods than in
+        `InputData`, then all tensors must be provided with the same number of
+        time periods and the `time` tensor must be provided.
       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. By default, all times periods are used. Either start
+        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.
       budget: Number indicating the total budget for the fixed budget scenario.
@@ -1510,7 +1569,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.
+        argument. If using `new_data`, this argument is ignored.
       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
@@ -1545,16 +1604,20 @@ class BudgetOptimizer:
       An OptimizationGrid object containing the grid data for optimization.
     """
     self._validate_model_fit(use_posterior)
-    if selected_times is not None:
-      start_date, end_date = selected_times
-      selected_time_dims = self._meridian.expand_selected_time_dims(
-          start_date=start_date,
-          end_date=end_date,
-      )
-    else:
-      selected_time_dims = None
-    hist_spend = self._analyzer.get_historical_spend(
-        selected_time_dims,
+    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
+    )
+
+    selected_time_dims = self._validate_selected_times(
+        selected_times, 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,
         include_media=self._meridian.n_media_channels > 0,
         include_rf=self._meridian.n_rf_channels > 0,
     ).data
@@ -1579,6 +1642,7 @@ class BudgetOptimizer:
     if self._meridian.n_rf_channels > 0 and use_optimal_frequency:
       optimal_frequency = tf.convert_to_tensor(
           self._analyzer.optimal_freq(
+              new_data=filled_data.filter_fields(c.RF_DATA),
               use_posterior=use_posterior,
               selected_times=selected_time_dims,
               use_kpi=use_kpi,
@@ -1595,6 +1659,7 @@ class BudgetOptimizer:
         spend_bound_upper=optimization_upper_bound,
         step_size=step_size,
         selected_times=selected_time_dims,
+        new_data=filled_data.filter_fields(c.PAID_DATA),
         use_posterior=use_posterior,
         use_kpi=use_kpi,
         optimal_frequency=optimal_frequency,
@@ -1658,10 +1723,40 @@ class BudgetOptimizer:
         attrs={c.SPEND_STEP_SIZE: spend_step_size},
     )
 
+  def _validate_selected_times(
+      self,
+      selected_times: tuple[str | None, str | None] | None,
+      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
+
+    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 = new_data.time.numpy().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,
       optimal_frequency: Sequence[float] | None = None,
   ) -> tuple[
       tf.Tensor | None,
@@ -1686,6 +1781,11 @@ class BudgetOptimizer:
     Args:
       hist_spend: historical spend data.
       spend: new optimized spend data.
+      new_data: An optional `DataTensors` object containing the new `media`,
+        `reach`, and `frequency` tensors. If `None`, the existing tensors from
+        the Meridian object are used. If any of the tensors is provided with a
+        different number of time periods than in `InputData`, then all tensors
+        must be provided with the same number of time periods.
       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,
@@ -1696,13 +1796,18 @@ class BudgetOptimizer:
       Tuple of tf.tensors (new_media, new_media_spend, new_reach, new_frequency,
       new_rf_spend).
     """
+    new_data = new_data or analyzer.DataTensors()
+    filled_data = new_data.validate_and_fill_missing_data(
+        c.PAID_CHANNELS,
+        self._meridian,
+    )
     if self._meridian.n_media_channels > 0:
       new_media = (
           tf.math.divide_no_nan(
               spend[: self._meridian.n_media_channels],
               hist_spend[: self._meridian.n_media_channels],
           )
-          * self._meridian.media_tensors.media
+          * filled_data.media
       )
       new_media_spend = tf.convert_to_tensor(
           spend[: self._meridian.n_media_channels]
@@ -1711,9 +1816,7 @@ class BudgetOptimizer:
       new_media = None
       new_media_spend = None
     if self._meridian.n_rf_channels > 0:
-      rf_media = (
-          self._meridian.rf_tensors.reach * self._meridian.rf_tensors.frequency
-      )
+      rf_media = filled_data.reach * filled_data.frequency
       new_rf_media = (
           tf.math.divide_no_nan(
               spend[-self._meridian.n_rf_channels :],
@@ -1722,7 +1825,7 @@ class BudgetOptimizer:
           * rf_media
       )
       frequency = (
-          self._meridian.rf_tensors.frequency
+          filled_data.frequency
           if optimal_frequency is None
           else optimal_frequency
       )
@@ -1742,9 +1845,10 @@ class BudgetOptimizer:
       self,
       hist_spend: np.ndarray,
       spend: np.ndarray,
+      new_data: analyzer.DataTensors | None = None,
       use_posterior: bool = True,
       use_kpi: bool = False,
-      selected_times: Sequence[str] | None = None,
+      selected_times: Sequence[str] | Sequence[bool] | None = None,
       optimal_frequency: Sequence[float] | None = None,
       attrs: Mapping[str, Any] | None = None,
       confidence_level: float = c.DEFAULT_CONFIDENCE_LEVEL,
@@ -1752,15 +1856,22 @@ class BudgetOptimizer:
       use_historical_budget: bool = True,
   ) -> xr.Dataset:
     """Creates the budget dataset."""
+    new_data = new_data or analyzer.DataTensors()
+    filled_data = new_data.validate_and_fill_missing_data(
+        c.PAID_DATA + (c.TIME,),
+        self._meridian,
+    )
     spend = tf.convert_to_tensor(spend, dtype=tf.float32)
     hist_spend = tf.convert_to_tensor(hist_spend, dtype=tf.float32)
     (new_media, new_media_spend, new_reach, new_frequency, new_rf_spend) = (
         self._get_incremental_outcome_tensors(
-            hist_spend, spend, optimal_frequency
+            hist_spend,
+            spend,
+            new_data=filled_data.filter_fields(c.PAID_CHANNELS),
+            optimal_frequency=optimal_frequency,
         )
     )
     budget = np.sum(spend)
-    all_times = self._meridian.input_data.time.values.tolist()
 
     # incremental_outcome here is a tensor with the shape
     # (n_chains, n_draws, n_channels)
@@ -1770,6 +1881,7 @@ class BudgetOptimizer:
             media=new_media,
             reach=new_reach,
             frequency=new_frequency,
+            revenue_per_kpi=filled_data.revenue_per_kpi,
         ),
         selected_times=selected_times,
         use_kpi=use_kpi,
@@ -1792,6 +1904,9 @@ class BudgetOptimizer:
     )
 
     aggregated_impressions = self._analyzer.get_aggregated_impressions(
+        new_data=analyzer.DataTensors(
+            media=new_media, reach=new_reach, frequency=new_frequency
+        ),
         selected_times=selected_times,
         selected_geos=None,
         aggregate_times=True,
@@ -1799,10 +1914,11 @@ class BudgetOptimizer:
         optimal_frequency=optimal_frequency,
         include_non_paid_channels=False,
     )
-    effectiveness = incremental_outcome / aggregated_impressions
     effectiveness_with_mean_median_and_ci = (
         analyzer.get_central_tendency_and_ci(
-            data=effectiveness,
+            data=tf.math.divide_no_nan(
+                incremental_outcome, aggregated_impressions
+            ),
             confidence_level=confidence_level,
             include_median=True,
         )
@@ -1822,6 +1938,7 @@ class BudgetOptimizer:
                 frequency=new_frequency,
                 media_spend=new_media_spend,
                 rf_spend=new_rf_spend,
+                revenue_per_kpi=filled_data.revenue_per_kpi,
             ),
             selected_times=selected_times,
             batch_size=batch_size,
@@ -1860,6 +1977,18 @@ class BudgetOptimizer:
         c.CPIK: ([c.CHANNEL, c.METRIC], cpik),
     }
 
+    all_times = (
+        filled_data.time.numpy().astype(str).tolist()
+        if filled_data.time is not None
+        else self._meridian.input_data.time.values.tolist()
+    )
+    if selected_times is not None and all(
+        isinstance(time, bool) for time in selected_times
+    ):
+      selected_times = [
+          time for time, selected in zip(all_times, selected_times) if selected
+      ]
+
     attributes = {
         c.START_DATE: min(selected_times) if selected_times else all_times[0],
         c.END_DATE: max(selected_times) if selected_times else all_times[-1],
@@ -1889,7 +2018,8 @@ class BudgetOptimizer:
       i: int,
       incremental_outcome_grid: np.ndarray,
       multipliers_grid: tf.Tensor,
-      selected_times: Sequence[str],
+      new_data: analyzer.DataTensors | None = None,
+      selected_times: Sequence[str] | Sequence[bool] | None = None,
       use_posterior: bool = True,
       use_kpi: bool = False,
       optimal_frequency: xr.DataArray | None = None,
@@ -1904,8 +2034,16 @@ class BudgetOptimizer:
         number of columns is equal to the number of total channels, containing
         incremental outcome by channel.
       multipliers_grid: A grid derived from spend.
-      selected_times: Sequence of strings representing the time dimensions in
-        `meridian.input_data.time` to use for optimization.
+      new_data: An optional `DataTensors` object containing the new `media`,
+        `reach`, `frequency`, and `revenue_per_kpi` tensors. If `None`, the
+        existing tensors from the Meridian object are used. If any of the
+        tensors is provided with a different number of time periods than in
+        `InputData`, then all tensors must be provided with the same number of
+        time periods.
+      selected_times: Optional list of times to optimize. This can either be a
+        string list containing a subset of time dimension coordinates from
+        `InputData.time` or a boolean list with length equal to the time
+        dimension of the tensor. By default, all time periods are included.
       use_posterior: Boolean. If `True`, then the incremental outcome is derived
         from the posterior distribution of the model. Otherwise, the prior
         distribution is used.
@@ -1922,10 +2060,14 @@ class BudgetOptimizer:
         reducing `batch_size`. The calculation will generally be faster with
         larger `batch_size` values.
     """
+    new_data = new_data or analyzer.DataTensors()
+    filled_data = new_data.validate_and_fill_missing_data(
+        c.PAID_DATA, self._meridian
+    )
     if self._meridian.n_media_channels > 0:
       new_media = (
           multipliers_grid[i, : self._meridian.n_media_channels]
-          * self._meridian.media_tensors.media
+          * filled_data.media
       )
     else:
       new_media = None
@@ -1934,20 +2076,18 @@ class BudgetOptimizer:
       new_frequency = None
       new_reach = None
     elif optimal_frequency is not None:
-      new_frequency = (
-          tf.ones_like(self._meridian.rf_tensors.frequency) * optimal_frequency
-      )
+      new_frequency = tf.ones_like(filled_data.frequency) * optimal_frequency
       new_reach = tf.math.divide_no_nan(
           multipliers_grid[i, -self._meridian.n_rf_channels :]
-          * self._meridian.rf_tensors.reach
-          * self._meridian.rf_tensors.frequency,
+          * filled_data.reach
+          * filled_data.frequency,
           new_frequency,
       )
     else:
-      new_frequency = self._meridian.rf_tensors.frequency
+      new_frequency = filled_data.frequency
       new_reach = (
           multipliers_grid[i, -self._meridian.n_rf_channels :]
-          * self._meridian.rf_tensors.reach
+          * filled_data.reach
       )
 
     # incremental_outcome returns a three dimensional tensor with dims
@@ -1960,6 +2100,7 @@ class BudgetOptimizer:
                 media=new_media,
                 reach=new_reach,
                 frequency=new_frequency,
+                revenue_per_kpi=filled_data.revenue_per_kpi,
             ),
             selected_times=selected_times,
             use_kpi=use_kpi,
@@ -1976,7 +2117,8 @@ class BudgetOptimizer:
       spend_bound_lower: np.ndarray,
       spend_bound_upper: np.ndarray,
       step_size: int,
-      selected_times: Sequence[str],
+      new_data: analyzer.DataTensors | None = None,
+      selected_times: Sequence[str] | Sequence[bool] | None = None,
       use_posterior: bool = True,
       use_kpi: bool = False,
       optimal_frequency: xr.DataArray | None = None,
@@ -1992,8 +2134,16 @@ class BudgetOptimizer:
         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
-        `meridian.input_data.time` to use for optimization.
+      new_data: An optional `DataTensors` object containing the new `media`,
+        `reach`, `frequency`, and `revenue_per_kpi` tensors. If `None`, the
+        existing tensors from the Meridian object are used. If any of the
+        tensors is provided with a different number of time periods than in
+        `InputData`, then all tensors must be provided with the same number of
+        time periods.
+      selected_times: Optional list of times to optimize. This can either be a
+        string list containing a subset of time dimension coordinates from
+        `InputData.time` or a boolean list with length equal to the time
+        dimension of the tensor. By default, all time periods are included.
       use_posterior: Boolean. If `True`, then the incremental outcome is derived
         from the posterior distribution of the model. Otherwise, the prior
         distribution is used.
@@ -2047,6 +2197,7 @@ class BudgetOptimizer:
           incremental_outcome_grid=incremental_outcome_grid,
           multipliers_grid=multipliers_grid,
           selected_times=selected_times,
+          new_data=new_data,
           use_posterior=use_posterior,
           use_kpi=use_kpi,
           optimal_frequency=optimal_frequency,

meridian/analysis/summarizer.py

@@ -167,7 +167,9 @@ class Summarizer:
         self._create_model_fit_card_html(
             template_env, selected_times=selected_times
         ),
-        self._create_outcome_contrib_card_html(template_env, media_summary),
+        self._create_outcome_contrib_card_html(
+            template_env, media_summary, selected_times=selected_times
+        ),
         self._create_performance_breakdown_card_html(
             template_env, media_summary
         ),
@@ -267,16 +269,30 @@ class Summarizer:
       self,
       template_env: jinja2.Environment,
       media_summary: visualizer.MediaSummary,
+      selected_times: Sequence[str] | None,
   ) -> str:
     """Creates the HTML snippet for the Outcome Contrib card."""
     outcome = self._kpi_or_revenue()
 
+    num_selected_times = (
+        self._meridian.n_times
+        if selected_times is None
+        else len(selected_times)
+    )
+    time_granularity = (
+        c.WEEKLY
+        if num_selected_times < c.QUARTERLY_SUMMARY_THRESHOLD_WEEKS
+        else c.QUARTERLY
+    )
+
     channel_contrib_area_chart = formatter.ChartSpec(
         id=summary_text.CHANNEL_CONTRIB_BY_TIME_CHART_ID,
         description=summary_text.CHANNEL_CONTRIB_BY_TIME_CHART_DESCRIPTION.format(
             outcome=outcome
         ),
-        chart_json=media_summary.plot_channel_contribution_area_chart().to_json(),
+        chart_json=media_summary.plot_channel_contribution_area_chart(
+            time_granularity=time_granularity
+        ).to_json(),
     )
 
     channel_contrib_bump_chart = formatter.ChartSpec(
@@ -284,7 +300,9 @@ class Summarizer:
         description=summary_text.CHANNEL_CONTRIB_RANK_CHART_DESCRIPTION.format(
             outcome=outcome
         ),
-        chart_json=media_summary.plot_channel_contribution_bump_chart().to_json(),
+        chart_json=media_summary.plot_channel_contribution_bump_chart(
+            time_granularity=time_granularity
+        ).to_json(),
     )
     channel_drivers_chart = formatter.ChartSpec(
         id=summary_text.CHANNEL_DRIVERS_CHART_ID,

meridian/analysis/visualizer.py

@@ -465,14 +465,14 @@ class ModelFit:
     else:
       y_axis_label = summary_text.KPI_LABEL
     plot = (
-        alt.Chart(model_fit_df, width=c.VEGALITE_FACET_DEFAULT_WIDTH)
+        alt.Chart(model_fit_df, width=c.VEGALITE_FACET_EXTRA_LARGE_WIDTH)
         .mark_line()
         .encode(
             x=alt.X(
                 f'{c.TIME}:T',
                 title='Time period',
                 axis=alt.Axis(
-                    format='%Y %b',
+                    format=c.QUARTER_FORMAT,
                     grid=False,
                     tickCount=8,
                     domainColor=c.GREY_300,
@@ -1657,18 +1657,36 @@ class MediaSummary:
     self._marginal_roi_by_reach = marginal_roi_by_reach
     self._non_media_baseline_values = non_media_baseline_values
 
-  def plot_channel_contribution_area_chart(self) -> alt.Chart:
+  def plot_channel_contribution_area_chart(
+      self, time_granularity: str = c.QUARTERLY
+  ) -> alt.Chart:
     """Plots a stacked area chart of the contribution share per channel by time.
 
+    Args:
+      time_granularity: The granularity for the time axis. Options are `weekly`
+        or `quarterly`. Defaults to `quarterly`.
+
     Returns:
       An Altair plot showing the contribution share per channel by time.
+
+    Raises:
+      ValueError: If time_granularity is not one of the allowed constants.
     """
+    if time_granularity not in c.TIME_GRANULARITIES:
+      raise ValueError(
+          f'time_granularity must be one of {c.TIME_GRANULARITIES}'
+      )
+
+    x_axis_format = (
+        c.DATE_FORMAT if time_granularity == c.WEEKLY else c.QUARTER_FORMAT
+    )
+
     outcome_df = self._transform_contribution_metrics(
         include_non_paid=True, aggregate_times=False
     )
 
     # Ensure proper ordering for the stacked area chart. Baseline should be at
-    # the bottom.  Separate the *stacking* order from the *legend* order.
+    # the bottom. Separate the *stacking* order from the *legend* order.
     stack_order = sorted([
         channel
         for channel in outcome_df[c.CHANNEL].unique()
@@ -1691,7 +1709,7 @@ class MediaSummary:
     )
 
     plot = (
-        alt.Chart(outcome_df, width=c.VEGALITE_FACET_LARGE_WIDTH)
+        alt.Chart(outcome_df, width=c.VEGALITE_FACET_EXTRA_LARGE_WIDTH)
         .mark_area()
         .transform_calculate(
             sort_channel=f'indexof({stack_order}, datum.channel)'
@@ -1701,7 +1719,7 @@ class MediaSummary:
                 f'{c.TIME}:T',
                 title='Time period',
                 axis=alt.Axis(
-                    format='%Y Q%q',
+                    format=x_axis_format,
                     grid=False,
                     tickCount=8,
                     domainColor=c.GREY_300,
@@ -1730,12 +1748,13 @@ class MediaSummary:
                     labelFontSize=c.AXIS_FONT_SIZE,
                     labelFont=c.FONT_ROBOTO,
                     title=None,
+                    orient='bottom',
                 ),
                 scale=alt.Scale(domain=legend_order),
                 sort=legend_order,
             ),
             tooltip=[
-                alt.Tooltip(f'{c.TIME}:T', format='%Y-%m-%d'),
+                alt.Tooltip(f'{c.TIME}:T', format=c.DATE_FORMAT),
                 c.CHANNEL,
                 alt.Tooltip(f'{c.INCREMENTAL_OUTCOME}:Q', format=',.2f'),
             ],
@@ -1751,16 +1770,31 @@ class MediaSummary:
     )
     return plot
 
-  def plot_channel_contribution_bump_chart(self) -> alt.Chart:
-    """Plots a bump chart of channel contribution rank over time (Quarterly).
+  def plot_channel_contribution_bump_chart(
+      self, time_granularity: str = c.QUARTERLY
+  ) -> alt.Chart:
+    """Plots a bump chart of channel contribution rank over time.
 
     This chart shows the relative rank of each channel's contribution,
-    including the baseline, based on incremental outcome at the end of each
+    including the baseline, based on incremental outcome. Depending on the
+    time_granularity, ranks are shown either weekly or at the end of each
     quarter. Rank 1 represents the highest contribution.
 
+    Args:
+      time_granularity: The granularity for the time axis. Options are `weekly`
+        or `quarterly`. Defaults to `quarterly`.
+
     Returns:
-      An Altair plot showing the contribution rank per channel by quarter.
+      An Altair plot showing the contribution rank per channel by time.
+
+    Raises:
+      ValueError: If time_granularity is not one of the allowed constants.
     """
+    if time_granularity not in c.TIME_GRANULARITIES:
+      raise ValueError(
+          f'time_granularity must be one of {c.TIME_GRANULARITIES}'
+      )
+
     outcome_df = self._transform_contribution_metrics(
         include_non_paid=True, aggregate_times=False
     )
@@ -1770,30 +1804,37 @@ class MediaSummary:
         method='first', ascending=False
     )
 
-    # Filter data to keep only the last available date within each quarter
-    # for a quarterly view of ranking changes.
-    unique_times = pd.Series(outcome_df[c.TIME].unique()).sort_values()
-    quarters = unique_times.dt.to_period('Q')
-    quarterly_dates = unique_times[~quarters.duplicated(keep='last')]
-    quarterly_rank_df = outcome_df[
-        outcome_df[c.TIME].isin(quarterly_dates)
-    ].copy()
+    if time_granularity == c.QUARTERLY:
+      # Filter data to keep only the last available date within each quarter
+      # for a quarterly view of ranking changes.
+      unique_times = pd.Series(outcome_df[c.TIME].unique()).sort_values()
+      quarters = unique_times.dt.to_period('Q')
+      quarterly_dates = unique_times[~quarters.duplicated(keep='last')]
+      plot_df = outcome_df[outcome_df[c.TIME].isin(quarterly_dates)].copy()
+      x_axis_format = c.QUARTER_FORMAT
+      tooltip_time_format = c.QUARTER_FORMAT
+      tooltip_time_title = 'Quarter'
+    else:
+      plot_df = outcome_df.copy()
+      x_axis_format = c.DATE_FORMAT
+      tooltip_time_format = c.DATE_FORMAT
+      tooltip_time_title = 'Week'
 
     legend_order = [c.BASELINE] + sorted([
         channel
-        for channel in quarterly_rank_df[c.CHANNEL].unique()
+        for channel in plot_df[c.CHANNEL].unique()
         if channel != c.BASELINE
     ])
 
     plot = (
-        alt.Chart(quarterly_rank_df, width=c.VEGALITE_FACET_DEFAULT_WIDTH)
+        alt.Chart(plot_df, width=c.VEGALITE_FACET_EXTRA_LARGE_WIDTH)
         .mark_line(point=True)
         .encode(
             x=alt.X(
                 f'{c.TIME}:T',
                 title='Time period',
                 axis=alt.Axis(
-                    format='%Y Q%q',
+                    format=x_axis_format,
                     grid=False,
                     domainColor=c.GREY_300,
                 ),
@@ -1819,12 +1860,17 @@ class MediaSummary:
                     labelFontSize=c.AXIS_FONT_SIZE,
                     labelFont=c.FONT_ROBOTO,
                     title=None,
+                    orient='bottom',
                 ),
                 scale=alt.Scale(domain=legend_order),
                 sort=legend_order,
             ),
             tooltip=[
-                alt.Tooltip(f'{c.TIME}:T', format='%Y Q%q', title='Quarter'),
+                alt.Tooltip(
+                    f'{c.TIME}:T',
+                    format=tooltip_time_format,
+                    title=tooltip_time_title,
+                ),
                 alt.Tooltip(f'{c.CHANNEL}:N', title='Channel'),
                 alt.Tooltip('rank:O', title='Rank'),
                 alt.Tooltip(

meridian/constants.py

@@ -51,6 +51,8 @@ GREY_300 = '#DADCE0'
 
 # Example: "2024-01-09"
 DATE_FORMAT = '%Y-%m-%d'
+# Example: "2024 Apr"
+QUARTER_FORMAT = '%Y %b'
 
 # Input data variables.
 KPI = 'kpi'
@@ -95,12 +97,8 @@ POSSIBLE_INPUT_DATA_ARRAY_NAMES = (
     + MEDIA_INPUT_DATA_ARRAY_NAMES
     + RF_INPUT_DATA_ARRAY_NAMES
 )
-PAID_DATA = (
-    MEDIA,
-    REACH,
-    FREQUENCY,
-    REVENUE_PER_KPI,
-)
+PAID_CHANNELS = (MEDIA, REACH, FREQUENCY)
+PAID_DATA = PAID_CHANNELS + (REVENUE_PER_KPI,)
 NON_PAID_DATA = (
     ORGANIC_MEDIA,
     ORGANIC_REACH,
@@ -112,11 +110,7 @@ SPEND_DATA = (
     RF_SPEND,
 )
 PERFORMANCE_DATA = PAID_DATA + SPEND_DATA
-IMPRESSIONS_DATA = (
-    MEDIA,
-    REACH,
-    FREQUENCY,
-) + NON_PAID_DATA
+IMPRESSIONS_DATA = PAID_CHANNELS + NON_PAID_DATA
 RF_DATA = (
     REACH,
     FREQUENCY,
@@ -622,3 +616,10 @@ CARD_STATS = 'stats'
 # VegaLite common params.
 VEGALITE_FACET_DEFAULT_WIDTH = 400
 VEGALITE_FACET_LARGE_WIDTH = 500
+VEGALITE_FACET_EXTRA_LARGE_WIDTH = 900
+
+# Time Granularity Constants
+WEEKLY = 'weekly'
+QUARTERLY = 'quarterly'
+TIME_GRANULARITIES = frozenset({WEEKLY, QUARTERLY})
+QUARTERLY_SUMMARY_THRESHOLD_WEEKS = 52

meridian/model/model.py

@@ -149,6 +149,7 @@ class Meridian:
     self._validate_paid_media_prior_type()
     self._validate_geo_invariants()
     self._validate_time_invariants()
+    self._validate_kpi_transformer()
 
   @property
   def input_data(self) -> data.InputData:
@@ -410,6 +411,7 @@ class Meridian:
         set_total_media_contribution_prior=set_total_media_contribution_prior,
         kpi=np.sum(self.input_data.kpi.values),
         total_spend=agg_total_spend,
+        media_effects_dist=self.media_effects_dist,
     )
 
   @functools.cached_property
@@ -825,6 +827,19 @@ class Meridian:
           " the listed variables that do not vary across time."
       )
 
+  def _validate_kpi_transformer(self):
+    """Validates the KPI transformer."""
+    if (
+        self.kpi_transformer.population_scaled_stdev == 0
+        and self.model_spec.paid_media_prior_type
+        in constants.PAID_MEDIA_ROI_PRIOR_TYPES
+    ):
+      kpi = "kpi" if self.is_national else "population_scaled_kpi"
+      raise ValueError(
+          f"`{kpi}` cannot be constant with"
+          f" {self.model_spec.paid_media_prior_type} prior type."
+      )
+
   def adstock_hill_media(
       self,
       media: tf.Tensor,  # pylint: disable=redefined-outer-name

meridian/model/prior_distribution.py

@@ -455,6 +455,7 @@ class PriorDistribution:
       set_total_media_contribution_prior: bool,
       kpi: float,
       total_spend: np.ndarray,
+      media_effects_dist: str,
   ) -> PriorDistribution:
     """Returns a new `PriorDistribution` with broadcast distribution attributes.
 
@@ -480,6 +481,8 @@ class PriorDistribution:
         `set_total_media_contribution_prior=True`.
       total_spend: Spend per media channel summed across geos and time. Required
         if `set_total_media_contribution_prior=True`.
+      media_effects_dist: A string to specify the distribution of media random
+        effects across geos.
 
     Returns:
       A new `PriorDistribution` broadcast from this prior distribution,
@@ -757,6 +760,7 @@ class PriorDistribution:
       )
     else:
       roi_m_converted = self.roi_m
+    _check_for_negative_effect(roi_m_converted, media_effects_dist)
     roi_m = tfp.distributions.BatchBroadcast(
         roi_m_converted, n_media_channels, name=constants.ROI_M
     )
@@ -777,13 +781,15 @@ class PriorDistribution:
       )
     else:
       roi_rf_converted = self.roi_rf
+    _check_for_negative_effect(roi_rf_converted, media_effects_dist)
     roi_rf = tfp.distributions.BatchBroadcast(
         roi_rf_converted, n_rf_channels, name=constants.ROI_RF
     )
-
+    _check_for_negative_effect(self.mroi_m, media_effects_dist)
     mroi_m = tfp.distributions.BatchBroadcast(
         self.mroi_m, n_media_channels, name=constants.MROI_M
     )
+    _check_for_negative_effect(self.mroi_rf, media_effects_dist)
     mroi_rf = tfp.distributions.BatchBroadcast(
         self.mroi_rf, n_rf_channels, name=constants.MROI_RF
     )
@@ -885,6 +891,21 @@ def _get_total_media_contribution_prior(
   return tfp.distributions.LogNormal(lognormal_mu, lognormal_sigma, name=name)
 
 
+def _check_for_negative_effect(
+    dist: tfp.distributions.Distribution, media_effects_dist: str
+):
+  """Checks for negative effect in the model."""
+  if (
+      media_effects_dist == constants.MEDIA_EFFECTS_LOG_NORMAL
+      and np.any(dist.cdf(0)) > 0
+  ):
+    raise ValueError(
+        'Media priors must have non-negative support when'
+        f' `media_effects_dist`="{media_effects_dist}". Found negative effect'
+        f' in {dist.name}.'
+    )
+
+
 def distributions_are_equal(
     a: tfp.distributions.Distribution, b: tfp.distributions.Distribution
 ) -> bool: