google-meridian 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

{google_meridian-1.1.3.dist-info → google_meridian-1.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-meridian
-Version: 1.1.3
+Version: 1.1.5
 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: 
@@ -397,7 +397,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.1.3},
+  version = {1.1.5},
   year = {2025},
 }
 ```

{google_meridian-1.1.3.dist-info → google_meridian-1.1.5.dist-info}/RECORD

@@ -1,11 +1,11 @@
-google_meridian-1.1.3.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+google_meridian-1.1.5.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
 meridian/__init__.py,sha256=XROKwHNVQvEa371QCXAHik5wN_YKObOdJQX9bJ2c4M4,832
-meridian/constants.py,sha256=VAVHyGfm9FyDd0dWomfqK5XYDUt9qJx7SAM4rzDh3RQ,17195
-meridian/version.py,sha256=CUTXDDaOfXFTukX_ywPK6Q3PiK9hMyJbmJRBeb5ez7c,644
+meridian/constants.py,sha256=YE5h3qKH8e2lI3d9vWxc5TsSHUm5bHcz1Lq-2LurJnw,17204
+meridian/version.py,sha256=PWF9Cv3V4ldFs0FOhaSlKgPdbBYCdiiaNLeQLulJrpE,644
 meridian/analysis/__init__.py,sha256=nGBYz7k9FVdadO_WVGMKJcfq7Yy_TuuP8zgee4i9pSA,836
-meridian/analysis/analyzer.py,sha256=FY_SvnkmEqqCIS37UXB3bvaQi-U3BwLcSWhH1puTzdQ,206003
+meridian/analysis/analyzer.py,sha256=L7XyCTd4e_Bqfi8a0bW1WaXjH2ZvSVTPs0VP12a209c,206559
 meridian/analysis/formatter.py,sha256=ENIdR1CRiaVqIGEXx1HcnsA4ewgDD_nhsYCweJAThaw,7270
-meridian/analysis/optimizer.py,sha256=P4uMcV9ByqMapqa1TEqcnu-3NyTH9fR8QLszdKxRAFc,107801
+meridian/analysis/optimizer.py,sha256=6L_FniWmqVgJlsFX-t3i8z_AO6mMftirtg_ZoOCaw8Y,118291
 meridian/analysis/summarizer.py,sha256=IthOUTMufGvAvbxiDhaKwe7uYCyiTyiQ8vgdmUtdevs,18855
 meridian/analysis/summary_text.py,sha256=I_smDkZJYp2j77ea-9AIbgeraDa7-qUYyb-IthP2qO4,12438
 meridian/analysis/test_utils.py,sha256=ES1r1akhRjD4pf2oTaGqzDfGNu9weAcLv6UZRuIkfEc,77699
@@ -21,10 +21,10 @@ meridian/analysis/templates/summary.html.jinja,sha256=LuENVDHYIpNo4pzloYaCR2K9XN
 meridian/analysis/templates/table.html.jinja,sha256=mvLMZx92RcD2JAS2w2eZtfYG-6WdfwYVo7pM8TbHp4g,1176
 meridian/data/__init__.py,sha256=StIe-wfYnnbfUbKtZHwnAQcRQUS8XCZk_PCaEzw90Ww,929
 meridian/data/arg_builder.py,sha256=Kqlt88bOqFj6D3xNwvWo4MBwNwcDFHzd-wMfEOmLoPU,3741
-meridian/data/data_frame_input_data_builder.py,sha256=3m6wrcC0psmD2ijsXk3R4uByA0Tu2gJxZBGaTS6Z7Io,22040
+meridian/data/data_frame_input_data_builder.py,sha256=_hexZMFAuAowgo6FaOGElHSFHqhGnHQwEEBcwnT3zUE,27295
 meridian/data/input_data.py,sha256=teJPKTBfW-AzBWgf_fEO_S_Z1J_veqQkCvctINaid6I,39749
-meridian/data/input_data_builder.py,sha256=08E_MZLrCzwfjvjPWFVs7o_094vVJ5o6VmbTfrg4NUM,25602
-meridian/data/load.py,sha256=B-12fBhsghN7wj0A9IWyT7BVogIXjuUDDvR34JJFwPM,45157
+meridian/data/input_data_builder.py,sha256=tbZjVXPDfmtndVyJA0fmzGzZwZb0RCEjXOTXb-ga8Nc,25648
+meridian/data/load.py,sha256=X2nmYCC-7A0RUgmdolTqCt0TD3NEZabQ5oGv-TugE00,40129
 meridian/data/nd_array_input_data_builder.py,sha256=lfpmnENGuSGKyUd7bDGAwoLqHqteOKmHdKl0VI2wCQA,16341
 meridian/data/test_utils.py,sha256=6GJrPmeaF4uzMxxRgzERGv4g1XMUHwI0s7qDVMZUjuI,55565
 meridian/data/time_coordinates.py,sha256=C5A5fscSLjPH6G9YT8OspgIlCrkMY7y8dMFEt3tNSnE,9874
@@ -34,14 +34,14 @@ meridian/model/__init__.py,sha256=9NFfqUE5WgFc-9lQMkbfkwwV-bQIz0tsQ_3Jyq0A4SU,98
 meridian/model/adstock_hill.py,sha256=20A_6rbDUAADEkkHspB7JpCm5tYfYS1FQ6hJMLu21Pk,9283
 meridian/model/knots.py,sha256=KPEgnb-UdQQ4QBugOYEke-zBgEghgTmeCMoeiJ30meY,8054
 meridian/model/media.py,sha256=3BaPX8xYAFMEvf0mz3mBSCIDWViIs7M218nrCklc6Fk,14099
-meridian/model/model.py,sha256=BlLPyskHrEx5D71mUZFbNxS2VjkQgaiaE6hLKvQ5D3A,61489
+meridian/model/model.py,sha256=XxVJaJtfUnCWI6gM7hWC6yC64yXECi91r1LHP2B23SQ,61216
 meridian/model/model_test_data.py,sha256=hDDTEzm72LknW9c5E_dNsy4Mm4Tfs6AirhGf_QxykFs,15552
 meridian/model/posterior_sampler.py,sha256=K49zWTTelME2rL1JLeFAdMPzL0OwrBvyAXA3oR-kgSI,27801
-meridian/model/prior_distribution.py,sha256=IEDU1rabcmKNY8lxwbbO4OUAlMHPIMa7flM_zsu3DLM,42417
-meridian/model/prior_sampler.py,sha256=cmu6jG-bSEkYDkjVUxl3iSxrL7r-LN7a77cb2Vc0LoA,23218
+meridian/model/prior_distribution.py,sha256=1Qh7jQ2py7tdhLPDyeQzZ0doU6NhQRVaA0lGZNnOVZA,42554
+meridian/model/prior_sampler.py,sha256=by41y2g56jEeJ1cxJi_s45uaUBySgf7wtL5u7-GpVE8,23325
 meridian/model/spec.py,sha256=0HNiMQUWQpYvWYOZr1_fj2ah8tH-bEyfEjoqgBZ9Lc0,18049
 meridian/model/transformers.py,sha256=nRjzq1fQG0ypldxboM7Gqok6WSAXAS1witRXoAzeH9Q,7763
-google_meridian-1.1.3.dist-info/METADATA,sha256=5W_XWui7q5gH68OC3Z-PXbDOeBftDbWuhqznNv7fOAk,22201
-google_meridian-1.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-google_meridian-1.1.3.dist-info/top_level.txt,sha256=nwaCebZvvU34EopTKZsjK0OMTFjVnkf4FfnBN_TAc0g,9
-google_meridian-1.1.3.dist-info/RECORD,,
+google_meridian-1.1.5.dist-info/METADATA,sha256=FfS9XdL_j8tmV1xBvGavFjNJTdivXFGnQy23JLuTcuY,22201
+google_meridian-1.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+google_meridian-1.1.5.dist-info/top_level.txt,sha256=nwaCebZvvU34EopTKZsjK0OMTFjVnkf4FfnBN_TAc0g,9
+google_meridian-1.1.5.dist-info/RECORD,,

meridian/analysis/analyzer.py

@@ -59,16 +59,20 @@ class DataTensors(tf.experimental.ExtensionType):
   Attributes:
     media: Optional tensor with dimensions `(n_geos, T, n_media_channels)` for
       any time dimension `T`.
-    media_spend: Optional tensor with dimensions `(n_geos, T, n_media_channels)`
-      for any time dimension `T`.
+    media_spend: Optional tensor with dimensions `(n_media_channels,)` or
+      `(n_geos, T, n_media_channels)` for any time dimension `T`. If the object
+      includes variables with modified time periods, then this tensor must be
+      provided at the geo and time granularity.
     reach: Optional tensor with dimensions `(n_geos, T, n_rf_channels)` for any
       time dimension `T`.
     frequency: Optional tensor with dimensions `(n_geos, T, n_rf_channels)` for
       any time dimension `T`.
     rf_impressions: Optional tensor with dimensions `(n_geos, T, n_rf_channels)`
       for any time dimension `T`.
-    rf_spend: Optional tensor with dimensions `(n_geos, T, n_rf_channels)` for
-      any time dimension `T`.
+    rf_spend: Optional tensor with dimensions `(n_rf_channels,)` or `(n_geos, T,
+      n_rf_channels)` for any time dimension `T`. If the object includes
+      variables with modified time periods, then this tensor must be provided at
+      the geo and time granularity.
     organic_media: Optional tensor with dimensions `(n_geos, T,
       n_organic_media_channels)` for any time dimension `T`.
     organic_reach: Optional tensor with dimensions `(n_geos, T,
@@ -406,13 +410,6 @@ class DataTensors(tf.experimental.ExtensionType):
 
       if old_tensor is None:
         continue
-      # Skip spend data with only 1 dimension of (n_channels).
-      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)
@@ -424,6 +421,16 @@ class DataTensors(tf.experimental.ExtensionType):
             "time periods, which does not match the modified number of time "
             f"periods, {new_n_times}.",
         )
+      elif (
+          var_name in [constants.MEDIA_SPEND, constants.RF_SPEND]
+          and new_tensor.ndim == 1
+      ):
+        raise ValueError(
+            "If the time dimension of any variable in `new_data` is modified, "
+            "then spend variables must be provided at the geo and time "
+            "granularity with thee same number of time periods as the other "
+            f"new data variables. Found `{var_name}` with only 1 dimension."
+        )
       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 "

meridian/analysis/optimizer.py

@@ -1368,7 +1368,10 @@ class BudgetOptimizer:
         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.
+        time periods and the `time` tensor must be provided. In this case, spend
+        tensors must be provided with `geo` and `time` granularity. If
+        `use_optimal_frequency` is `True`, `new_data.frequency` does not need to
+        be provided and is ignored. The optimal frequency is used instead.
       use_posterior: Boolean. If `True`, then the budget is optimized based on
         the posterior distribution of the model. Otherwise, the prior
         distribution is used.
@@ -1427,7 +1430,7 @@ class BudgetOptimizer:
         or equal to `(budget * gtol)`. `gtol` must be less than 1.
       use_optimal_frequency: If `True`, uses `optimal_frequency` calculated by
         trained Meridian model for optimization. If `False`, uses historical
-        frequency.
+        frequency or `new_data.frequency` if provided.
       use_kpi: If `True`, runs the optimization on KPI. Defaults to revenue.
       confidence_level: The threshold for computing the confidence intervals.
       batch_size: Maximum draws per chain in each batch. The calculation is run
@@ -1596,6 +1599,142 @@ class BudgetOptimizer:
         _optimization_grid=optimization_grid,
     )
 
+  def create_optimization_tensors(
+      self,
+      time: Sequence[str] | tf.Tensor,
+      cpmu: tf.Tensor | None = None,
+      media: tf.Tensor | None = None,
+      media_spend: tf.Tensor | None = None,
+      cprf: tf.Tensor | None = None,
+      rf_impressions: tf.Tensor | None = None,
+      frequency: tf.Tensor | None = None,
+      rf_spend: tf.Tensor | None = None,
+      revenue_per_kpi: tf.Tensor | None = None,
+      use_optimal_frequency: bool = True,
+  ) -> analyzer.DataTensors:
+    """Creates a `DataTensors` for optimizations from CPM and flighting data.
+
+    CPM is broken down into cost per media unit, `cpmu`, for the media channels
+    and cost per impression (reach * frequency), `cprf`, for the reach and
+    frequency channels.
+
+    The flighting pattern can be specified as the spend flighting or the media
+    units flighting pattern at the time or geo and time granularity. If data is
+    passed without a geo dimension, then the values are interpreted as
+    national-level totals. If the model is a geo-level model, then the values
+    are allocated across geos based on the population used in the model.
+
+    Below are the different combinations of tensors that can be provided:
+      For media:
+      1) `media`, `cpmu` (media units flighting pattern)
+      2) `media_spend`, `cpmu` (spend flighting pattern)
+
+      For R&F:
+      If `use_optimal_frequency=True`, `frequency` should not be provided.
+      Frequency input is not required for the optimization, so the new
+      `DataTensors` object will be created with `frequuency` arbitrarily set to
+      1 and `reach=rf_impressions`.
+      1) `rf_impressions`, `cprf` (impressions flighting pattern)
+      2) `rf_spend`, `cprf` (spend flighting pattern)
+
+      If `use_optimal_frequency=False`:
+      1) `rf_impressions`, `frequency`, `cprf` (impressions flighting pattern)
+      2) `rf_spend`, `frequency`, `cprf` (spend flighting pattern)
+
+
+    Args:
+      time: A sequence or tensor of time coordinates in the "YYYY-mm-dd" string
+        format.
+      cpmu: A tensor of cost per media unit with dimensions `(n_media_channels),
+        `(T, n_media_channels)` or `(n_geos, T, n_media_channels)` for any time
+        dimension `T`.
+      media: An optional tensor of media unit values with dimensions `(T,
+        n_media_channels)` or `(n_geos, T, n_media_channels)` for any time
+        dimension `T`.
+      media_spend: A tensor of media spend values with dimensions `(T,
+        n_media_channels)` or `(n_geos, T, n_media_channels)` for any time
+        dimension `T`.
+      cprf: A tensor of cost per impression (reach * frequency) with dimensions
+        `(n_rf_channels), `(T, n_rf_channels)` or `(n_geos, T, n_rf_channels)`
+        for any time dimension `T`.
+      rf_impressions: A tensor of impressions (reach * frequency) values with
+        dimensions `(T, n_rf_channels)` or `(n_geos, T, n_rf_channels)` for any
+        time dimension `T`.
+      frequency: A tensor of frequency values with dimensions `(n_rf_channels)`,
+        `(T, n_rf_channels)` or `(n_geos, T, n_rf_channels)` for any time
+        dimension `T`. If `use_optimal_frequency=True`, then this tensor should
+        not be provided and the optimal frequency will be calculated and used.
+      rf_spend: A tensor of rf spend values with dimensions `(T, n_rf_channels)`
+        or `(n_geos, T, n_rf_channels)` for any time dimension `T`.
+      revenue_per_kpi: A tensor of revenue per KPI values with dimensions `()`,
+        `(T)`, or `(n_geos, T)` for any time dimension `T`.
+      use_optimal_frequency: Boolean. If `True`, the optiaml frequency will be
+        used in the optimization and a frequency value should not be provided.
+        In this case, `reach=rf_impressions` and `frequency=1` (by arbitrary
+        convention) in the new data. If `False`, the frequency value must be
+        provided.
+
+    Returns:
+      A `DataTensors` object with optional tensors `media`, `reach`,
+      `frequency`, `media_spend`, `rf_spend`, `revenue_per_kpi`, and `time`.
+    """
+    self._validate_optimization_tensors(
+        cpmu=cpmu,
+        cprf=cprf,
+        media=media,
+        rf_impressions=rf_impressions,
+        frequency=frequency,
+        media_spend=media_spend,
+        rf_spend=rf_spend,
+        revenue_per_kpi=revenue_per_kpi,
+        use_optimal_frequency=use_optimal_frequency,
+    )
+    n_times = time.shape[0] if isinstance(time, tf.Tensor) else len(time)
+    n_geos = self._meridian.n_geos
+    revenue_per_kpi = (
+        _expand_tensor(revenue_per_kpi, (n_geos, n_times))
+        if revenue_per_kpi is not None
+        else None
+    )
+
+    tensors = {}
+    if media is not None:
+      cpmu = _expand_tensor(cpmu, (n_geos, n_times, media.shape[-1]))
+      tensors[c.MEDIA] = self._allocate_tensor_by_population(media)
+      tensors[c.MEDIA_SPEND] = tensors[c.MEDIA] * cpmu
+    if media_spend is not None:
+      cpmu = _expand_tensor(cpmu, (n_geos, n_times, media_spend.shape[-1]))
+      tensors[c.MEDIA_SPEND] = self._allocate_tensor_by_population(media_spend)
+      tensors[c.MEDIA] = tensors[c.MEDIA_SPEND] / cpmu
+    if rf_impressions is not None:
+      shape = (n_geos, n_times, rf_impressions.shape[-1])
+      cprf = _expand_tensor(cprf, shape)
+      allocated_impressions = self._allocate_tensor_by_population(
+          rf_impressions
+      )
+      tensors[c.RF_SPEND] = allocated_impressions * cprf
+      if use_optimal_frequency:
+        frequency = tf.ones_like(allocated_impressions)
+      tensors[c.FREQUENCY] = _expand_tensor(frequency, shape)
+      tensors[c.REACH] = tf.math.divide_no_nan(
+          allocated_impressions, tensors[c.FREQUENCY]
+      )
+    if rf_spend is not None:
+      shape = (n_geos, n_times, rf_spend.shape[-1])
+      cprf = _expand_tensor(cprf, shape)
+      tensors[c.RF_SPEND] = self._allocate_tensor_by_population(rf_spend)
+      impressions = tf.math.divide_no_nan(tensors[c.RF_SPEND], cprf)
+      if use_optimal_frequency:
+        frequency = tf.ones_like(impressions)
+      tensors[c.FREQUENCY] = _expand_tensor(frequency, shape)
+      tensors[c.REACH] = tf.math.divide_no_nan(
+          impressions, tensors[c.FREQUENCY]
+      )
+    if revenue_per_kpi is not None:
+      tensors[c.REVENUE_PER_KPI] = revenue_per_kpi
+    tensors[c.TIME] = tf.convert_to_tensor(time)
+    return analyzer.DataTensors(**tensors)
+
   def _validate_grid(
       self,
       new_data: analyzer.DataTensors | None,
@@ -1990,8 +2129,6 @@ class BudgetOptimizer:
       tf.Tensor | None,
       tf.Tensor | None,
       tf.Tensor | None,
-      tf.Tensor | None,
-      tf.Tensor | None,
   ]:
     """Gets the tensors for incremental outcome, based on spend data.
 
@@ -1999,12 +2136,11 @@ class BudgetOptimizer:
     incremental_outcome() for creating budget data. new_media is calculated
     assuming a constant cpm between historical spend and optimization spend.
     new_reach and new_frequency are calculated by first multiplying them
-    together and getting rf_media(impressions), and then calculating
-    new_rf_media given the same formula for new_media. new_frequency is
-    optimal_frequency if optimal_frequency is not none, and
-    self._meridian.rf_tensors.frequency otherwise. new_reach is calculated using
-    (new_rf_media / new_frequency). new_spend and new_rf_spend are taken from
-    their respective indexes in spend.
+    together and getting `rf_impressions`, and then calculating
+    `new_rf_impressions` given the same formula for `new_media`. `new_frequency`
+    is `optimal_frequency` if `optimal_frequency` is not None, and
+    `self._meridian.rf_tensors.frequency` otherwise. `new_reach` is calculated
+    using `new_rf_impressions / new_frequency`.
 
     Args:
       hist_spend: historical spend data.
@@ -2021,8 +2157,7 @@ class BudgetOptimizer:
         frequency is used for the optimization scenario.
 
     Returns:
-      Tuple of tf.tensors (new_media, new_media_spend, new_reach, new_frequency,
-      new_rf_spend).
+      Tuple of tf.tensors (new_media, new_reach, new_frequency).
     """
     new_data = new_data or analyzer.DataTensors()
     filled_data = new_data.validate_and_fill_missing_data(
@@ -2037,37 +2172,29 @@ class BudgetOptimizer:
           )
           * filled_data.media
       )
-      new_media_spend = tf.convert_to_tensor(
-          spend[: self._meridian.n_media_channels]
-      )
     else:
       new_media = None
-      new_media_spend = None
     if self._meridian.n_rf_channels > 0:
-      rf_media = filled_data.reach * filled_data.frequency
-      new_rf_media = (
+      rf_impressions = filled_data.reach * filled_data.frequency
+      new_rf_impressions = (
           tf.math.divide_no_nan(
               spend[-self._meridian.n_rf_channels :],
               hist_spend[-self._meridian.n_rf_channels :],
           )
-          * rf_media
+          * rf_impressions
       )
       frequency = (
           filled_data.frequency
           if optimal_frequency is None
           else optimal_frequency
       )
-      new_reach = tf.math.divide_no_nan(new_rf_media, frequency)
-      new_frequency = tf.math.divide_no_nan(new_rf_media, new_reach)
-      new_rf_spend = tf.convert_to_tensor(
-          spend[-self._meridian.n_rf_channels :]
-      )
+      new_reach = tf.math.divide_no_nan(new_rf_impressions, frequency)
+      new_frequency = tf.math.divide_no_nan(new_rf_impressions, new_reach)
     else:
       new_reach = None
       new_frequency = None
-      new_rf_spend = None
 
-    return (new_media, new_media_spend, new_reach, new_frequency, new_rf_spend)
+    return (new_media, new_reach, new_frequency)
 
   def _create_budget_dataset(
       self,
@@ -2091,7 +2218,7 @@ class BudgetOptimizer:
     )
     spend_tensor = 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) = (
+    (new_media, new_reach, new_frequency) = (
         self._get_incremental_outcome_tensors(
             hist_spend,
             spend_tensor,
@@ -2100,18 +2227,30 @@ class BudgetOptimizer:
         )
     )
     budget = np.sum(spend_tensor)
+    inc_outcome_data = analyzer.DataTensors(
+        media=new_media,
+        reach=new_reach,
+        frequency=new_frequency,
+        revenue_per_kpi=filled_data.revenue_per_kpi,
+    )
 
     # incremental_outcome here is a tensor with the shape
     # (n_chains, n_draws, n_channels)
     incremental_outcome = self._analyzer.incremental_outcome(
         use_posterior=use_posterior,
-        new_data=analyzer.DataTensors(
-            media=new_media,
-            reach=new_reach,
-            frequency=new_frequency,
-            revenue_per_kpi=filled_data.revenue_per_kpi,
-        ),
+        new_data=inc_outcome_data,
+        selected_times=selected_times,
+        use_kpi=use_kpi,
+        batch_size=batch_size,
+        include_non_paid_channels=False,
+    )
+    incremental_increase = 0.01
+    mroi_numerator = self._analyzer.incremental_outcome(
+        new_data=inc_outcome_data,
         selected_times=selected_times,
+        scaling_factor0=1.0,
+        scaling_factor1=1 + incremental_increase,
+        use_posterior=use_posterior,
         use_kpi=use_kpi,
         batch_size=batch_size,
         include_non_paid_channels=False,
@@ -2158,20 +2297,8 @@ class BudgetOptimizer:
         include_median=True,
     )
     marginal_roi = analyzer.get_central_tendency_and_ci(
-        data=self._analyzer.marginal_roi(
-            use_posterior=use_posterior,
-            new_data=analyzer.DataTensors(
-                media=new_media,
-                reach=new_reach,
-                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,
-            by_reach=True,
-            use_kpi=use_kpi,
+        data=tf.math.divide_no_nan(
+            mroi_numerator, spend_tensor * incremental_increase
         ),
         confidence_level=confidence_level,
         include_median=True,
@@ -2452,6 +2579,100 @@ class BudgetOptimizer:
       )
     return (spend_grid, incremental_outcome_grid)
 
+  def _validate_optimization_tensors(
+      self,
+      cpmu: tf.Tensor | None = None,
+      cprf: tf.Tensor | None = None,
+      media: tf.Tensor | None = None,
+      rf_impressions: tf.Tensor | None = None,
+      frequency: tf.Tensor | None = None,
+      media_spend: tf.Tensor | None = None,
+      rf_spend: tf.Tensor | None = None,
+      revenue_per_kpi: tf.Tensor | None = None,
+      use_optimal_frequency: bool = True,
+  ):
+    """Validates the tensors needed for optimization."""
+    if (media is not None or media_spend is not None) and cpmu is None:
+      raise ValueError(
+          'If `media` or `media_spend` is provided, then `cpmu` must also be'
+          ' provided.'
+      )
+    if (rf_impressions is not None or rf_spend is not None) and cprf is None:
+      raise ValueError(
+          'If `reach` and `frequency` or `rf_spend` is provided, then `cprf`'
+          ' must also be provided.'
+      )
+    if media is not None and media_spend is not None:
+      raise ValueError('Only one of `media` or `media_spend` can be provided.')
+    if rf_impressions is not None and rf_spend is not None:
+      raise ValueError(
+          'Only one of `rf_impressions` or `rf_spend` can be provided.'
+      )
+    if use_optimal_frequency and frequency is not None:
+      raise ValueError(
+          'If `use_optimal_frequency` is `True`, then `frequency` must not be'
+          ' provided.'
+      )
+    if not use_optimal_frequency and frequency is None:
+      if rf_impressions is not None or rf_spend is not None:
+        raise ValueError(
+            'If `use_optimal_frequency` is `False`, then `frequency` must be'
+            ' provided.'
+        )
+
+    n_geos = [
+        t.shape[0]
+        for t in [
+            cpmu,
+            cprf,
+            media,
+            rf_impressions,
+            frequency,
+            media_spend,
+            rf_spend,
+        ]
+        if t is not None and t.ndim == 3
+    ]
+    if revenue_per_kpi is not None and revenue_per_kpi.ndim == 2:
+      n_geos.append(revenue_per_kpi.shape[0])
+    if any(n_geo != self._meridian.n_geos for n_geo in n_geos):
+      raise ValueError(
+          'All tensors with a geo dimension must have the same number of geos'
+          ' as in `meridian.InputData`.'
+      )
+
+  def _allocate_tensor_by_population(
+      self, tensor: tf.Tensor, required_ndim: int = 3
+  ):
+    """Allocates a tensor of shape (time,) or (time, channel) by the population.
+
+    Args:
+      tensor: A tensor of shape (time,) or (time, channel).
+      required_ndim: The required number of dimensions for the tensor.
+
+    Returns:
+      The scaled tensor of shape (geo, time) or (geo, time, channel).
+    """
+    if tensor.ndim == required_ndim:
+      return tensor
+
+    if tensor.ndim != required_ndim - 1:
+      raise ValueError(
+          'Tensor must have 1 less than the required number of dimensions, '
+          f'{required_ndim}, in order to be allocated by population. Found '
+          f'{tensor.ndim} dimensions.'
+      )
+
+    population = self._meridian.population
+    normalized_population = population / tf.reduce_sum(population)
+    if tensor.ndim == 1:
+      reshaped_population = normalized_population[:, tf.newaxis]
+      reshaped_tensor = tensor[tf.newaxis, :]
+    else:
+      reshaped_population = normalized_population[:, tf.newaxis, tf.newaxis]
+      reshaped_tensor = tensor[tf.newaxis, :, :]
+    return reshaped_tensor * reshaped_population
+
 
 def _validate_pct_of_spend(
     n_channels: int,
@@ -2705,3 +2926,27 @@ def _raise_warning_if_target_constraints_not_met(
           f' ROI is {target_mroi}, but the actual channel marginal ROIs are'
           f' {optimized_mroi}.'
       )
+
+
+def _expand_tensor(tensor: tf.Tensor, required_shape: tuple[int, ...]):
+  """Expands a tensor to the required number of dimensions."""
+  if tensor.shape == required_shape:
+    return tensor
+  if tensor.ndim == 0:
+    return tf.fill(required_shape, tensor)
+
+  # Tensor must be less than or equal to the required number of dimensions and
+  # the shape must match the required shape excluding the difference in number
+  # of dims.
+  if tensor.ndim <= len(required_shape) and list(tensor.shape) == list(
+      required_shape[-tensor.ndim :]
+  ):
+    n_tile_dims = len(required_shape) - tensor.ndim
+    repeats = list(required_shape[:n_tile_dims]) + [1] * tensor.ndim
+    reshaped_tensor = tf.reshape(tensor, [1] * n_tile_dims + list(tensor.shape))
+    return tf.tile(reshaped_tensor, repeats)
+
+  raise ValueError(
+      f'Cannot expand tensor with shape {tensor.shape} to target'
+      f' {required_shape}.'
+  )

meridian/constants.py

@@ -71,6 +71,8 @@ ORGANIC_FREQUENCY = 'organic_frequency'
 NON_MEDIA_TREATMENTS = 'non_media_treatments'
 REVENUE = 'revenue'
 NON_REVENUE = 'non_revenue'
+CPMU = 'cpmu'
+CPRF = 'cprf'
 REQUIRED_INPUT_DATA_ARRAY_NAMES = (
     KPI,
     POPULATION,
@@ -216,9 +218,10 @@ PAID_MEDIA_ROI_PRIOR_TYPES = frozenset(
 # Represents a 1% increase in spend.
 MROI_FACTOR = 1.01
 
-NATIONAL_MODEL_SPEC_ARGS = immutabledict.immutabledict(
-    {MEDIA_EFFECTS_DIST: MEDIA_EFFECTS_NORMAL, UNIQUE_SIGMA_FOR_EACH_GEO: False}
-)
+NATIONAL_MODEL_SPEC_ARGS = immutabledict.immutabledict({
+    MEDIA_EFFECTS_DIST: MEDIA_EFFECTS_NORMAL,
+    UNIQUE_SIGMA_FOR_EACH_GEO: False,
+})
 
 NATIONAL_ANALYZER_PARAMETERS_DEFAULTS = immutabledict.immutabledict(
     {'aggregate_geos': True, 'geos_to_include': None}
@@ -229,7 +232,6 @@ NATIONAL_ANALYZER_PARAMETERS_DEFAULTS = immutabledict.immutabledict(
 CHAIN = 'chain'
 DRAW = 'draw'
 KNOTS = 'knots'
-SIGMA_DIM = 'sigma_dim'
 
 
 # Model parameters.