google-meridian 1.5.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

{google_meridian-1.5.0.dist-info → google_meridian-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-meridian
-Version: 1.5.0
+Version: 1.5.1
 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>
 Project-URL: homepage, https://github.com/google/meridian
@@ -210,7 +210,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.5.0},
+  version = {1.5.1},
   year = {2025},
 }
 ```

{google_meridian-1.5.0.dist-info → google_meridian-1.5.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
-google_meridian-1.5.0.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+google_meridian-1.5.1.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
 meridian/__init__.py,sha256=0fOT5oNZF7-pbiWWGUefV-ysafttieG079m1ijMFQO8,861
 meridian/constants.py,sha256=3OTX4TKp_lLuuO6V2fA2icgoJQxQUHJjIDxH8yBD4Kw,20359
-meridian/version.py,sha256=y8_0XVrWHR9rLHxSjY_gIn3J8QixGcPiCDPA5JnNYSY,644
+meridian/version.py,sha256=kAZOoCSOwL13YeWOWHzABMmvsYhX2egAYQqEeUsPS2M,644
 meridian/analysis/__init__.py,sha256=AM7xpqoeC-mmY4tPIyHisjQ2MICI7v3jSri--DhDqXA,874
 meridian/analysis/analyzer.py,sha256=8x6yrDnk_Sy_-fp9M9ZDZzKXqrszrZ_xmXcA78Tf3AY,224888
 meridian/analysis/optimizer.py,sha256=2_saKikIXuQuwGzNJpkuX2hYpdgcoBYR6_-m1MbbkSM,127223
@@ -10,11 +10,11 @@ meridian/analysis/summary_text.py,sha256=I_smDkZJYp2j77ea-9AIbgeraDa7-qUYyb-IthP
 meridian/analysis/test_utils.py,sha256=pQQPhKertGawgH2ry1hxiV1aAOlVcV5aHoafqQPzS6s,98743
 meridian/analysis/visualizer.py,sha256=MprZXNMOAF1BTJi5zdtHRnSwNZ20YYEe8UL2jGJk64k,94850
 meridian/analysis/review/__init__.py,sha256=cF24EbhiVSs-tvtRf59uVin39tu6aCTTCaeEdv6ISZ8,804
-meridian/analysis/review/checks.py,sha256=QEUVwC8L9Pif3y0B_OVAUpZeN6EnFGKH2oXA_dsdgbc,26893
+meridian/analysis/review/checks.py,sha256=Q-niQrgyird1orFgkjgEqQDef57ooRRKR8IhYFPMXsc,27155
 meridian/analysis/review/configs.py,sha256=5JJ8v6n22GNBmE78xNX6jwdjkZz2qar4Q9YTcVqzcoI,3653
-meridian/analysis/review/constants.py,sha256=9tnnc_vAaJi9mnZ0GrRr86RsVq5fyhBaEtIvOLNmn8A,1498
-meridian/analysis/review/results.py,sha256=ZZiAdFrqySzcbjrCEacBLQS_ddiklZ34yD1BWns5SYI,17418
-meridian/analysis/review/reviewer.py,sha256=6nza-toZhDNWs_x-A6CdN41vYfyhXMk4h_Ckota7Rxg,6766
+meridian/analysis/review/constants.py,sha256=DM6mgDXiLXcyA89EYthWOHHCN6_CP3ey_DuPhP3ZWu4,1497
+meridian/analysis/review/results.py,sha256=HtKW3qw8T2wJ_Ei4wv-qhWTizczD3H_dS0tc9Nik5-4,19252
+meridian/analysis/review/reviewer.py,sha256=llE4ssH4QK4xVZwKcVzrXqEsef2pnCWTKHnmA4sT46M,6009
 meridian/backend/__init__.py,sha256=DaFTfvsqYtkheFvgV2kdPsyJoz8c-X2_ISSMlleHbVk,45411
 meridian/backend/config.py,sha256=B9VQnhBfg9RW04GNbt7F5uCugByenoJzt-keFLLYEp8,3561
 meridian/backend/test_utils.py,sha256=oJNosF_x_BzNuia8LzLFb_YfjGWHRCzR5FXNN5KQ8sw,13738
@@ -45,7 +45,7 @@ meridian/model/spec.py,sha256=hmVz1LZlE1un3Lt2Hx6L8FR7iG8OtL1i6XScCXqvVzE,19684
 meridian/model/transformers.py,sha256=HxlVJitxP-wu-NOHU0tArFUZ4NAO3c7adAYj4Zvqnvo,8363
 meridian/model/eda/__init__.py,sha256=bMj9kd2LWU_LQZAjQv54FFggzdv4CKRYblvc-0cHXc4,768
 meridian/model/eda/constants.py,sha256=maaZ0suGwhWbHIoNqQis9mV4LwlNexyADYx92U2Mrew,15124
-meridian/model/eda/eda_engine.py,sha256=MGrnw2-AocaNW-g4jA1N4wm0di5Hl48MWnJiZbu96JM,88467
+meridian/model/eda/eda_engine.py,sha256=-lz2PLAhujkCfq2IMhDnIFePPEF-oZAScnuvFmgJK-Y,88516
 meridian/model/eda/eda_outcome.py,sha256=xCy0sl92Vge0ANnMqLuadjFTeZlyAs0rBh0zRBUrpzM,11328
 meridian/model/eda/eda_spec.py,sha256=diieYyZH0ee3ZLy0rGFMcWrrgiUrz2HctMwOrmtJR6w,2871
 meridian/templates/card.html.jinja,sha256=AWgKGLPf7qTFVNy-vylXm-_tatzW9ngPk1mJm9sTCPg,1332
@@ -99,14 +99,14 @@ schema/serde/function_registry.py,sha256=GbgC5_9NDcA9Y7nqmdJ-4-LK5JPhhfI50Lmfy5Z
 schema/serde/hyperparameters.py,sha256=0Lgep_lT5Ro6svvLPdR6OyL_qCb0-bRrxJVxsmySmJs,12176
 schema/serde/inference_data.py,sha256=DrwE9hU8LMrl0z8W_sUSIaPrRdym_lu0iOqpT4KZxsA,3623
 schema/serde/marketing_data.py,sha256=yb-fRTe84Sjg7-v3wsvYRRXvrxLSFWSenO0_ikMvUpk,44845
-schema/serde/meridian_serde.py,sha256=VQG1eakJ3nZhT_gndfss_nZlxTlGe5EIWLSEgcaHqV8,16134
+schema/serde/meridian_serde.py,sha256=5q2AkZ52Ew0SJUH9g4VXqWHSwjzVJ_-ChCx6B5FA8CE,16246
 schema/serde/serde.py,sha256=8vUqhJxvZgX9UY3rXTyWJznRgapwDzzaHXDHwV_kKTA,1612
 schema/serde/test_data.py,sha256=7hfEWyvZ9WcAkVAOXt6elX8stJlsfhfd-ASlHo9SRb8,107342
 schema/utils/__init__.py,sha256=OzDmXWCpogCt6EkremIShzTowsZF8dHzfEjkJkE9qfk,767
 schema/utils/date_range_bucketing.py,sha256=14vcRGf3odWT9mBdCykRNmVCEiuUI_1SvVygNzvqBuM,3809
 schema/utils/proto_enum_converter.py,sha256=vCKGQGWfCt6W7GZy7QQRFAj3XqLUQwt_eWZzsX6pA0E,4021
 schema/utils/time_record.py,sha256=-KzHFjvSBUUXsfESPAfcJP_VFxaFLqj90Ac0kgKWfpI,4624
-google_meridian-1.5.0.dist-info/METADATA,sha256=wW-a2DyNSLr6ySi0ola2R-hP2sIt9yt96MFJLrbGGP4,10024
-google_meridian-1.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-google_meridian-1.5.0.dist-info/top_level.txt,sha256=oAi0z-fUuo6p8SnJ0WrojGR2mKOWDz43yr6EjzaXqy8,32
-google_meridian-1.5.0.dist-info/RECORD,,
+google_meridian-1.5.1.dist-info/METADATA,sha256=SWHh9POzkljYJxkNgvQaG0GMHK9BHsjsW0ksaoIjqaI,10024
+google_meridian-1.5.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+google_meridian-1.5.1.dist-info/top_level.txt,sha256=oAi0z-fUuo6p8SnJ0WrojGR2mKOWDz43yr6EjzaXqy8,32
+google_meridian-1.5.1.dist-info/RECORD,,

meridian/analysis/review/checks.py

@@ -15,7 +15,7 @@
 """Implementation of the Model Quality Checks."""
 
 import abc
-from collections.abc import Sequence
+from collections.abc import MutableMapping, Sequence
 import dataclasses
 from typing import Generic, TypeVar
 import warnings
@@ -77,31 +77,16 @@ class ConvergenceCheck(
     if not valid_rhat_items:
       return results.ConvergenceCheckResult(
           case=results.ConvergenceCases.CONVERGED,
-          details={
-              review_constants.RHAT: np.nan,
-              review_constants.PARAMETER: np.nan,
-              review_constants.CONVERGENCE_THRESHOLD: (
-                  self._config.convergence_threshold
-              ),
-          },
+          config=self._config,
+          max_rhat=np.nan,
+          max_parameter=np.nan,
       )
 
     max_parameter, max_rhat = max(max_rhats.items(), key=lambda item: item[1])
 
-    details = {
-        review_constants.RHAT: max_rhat,
-        review_constants.PARAMETER: max_parameter,
-        review_constants.CONVERGENCE_THRESHOLD: (
-            self._config.convergence_threshold
-        ),
-    }
-
     # Case 1: Converged.
     if max_rhat < self._config.convergence_threshold:
-      return results.ConvergenceCheckResult(
-          case=results.ConvergenceCases.CONVERGED,
-          details=details,
-      )
+      case = results.ConvergenceCases.CONVERGED
 
     # Case 2: Not fully converged, but potentially acceptable.
     elif (
@@ -109,17 +94,18 @@ class ConvergenceCheck(
         <= max_rhat
         < self._config.not_fully_convergence_threshold
     ):
-      return results.ConvergenceCheckResult(
-          case=results.ConvergenceCases.NOT_FULLY_CONVERGED,
-          details=details,
-      )
+      case = results.ConvergenceCases.NOT_FULLY_CONVERGED
 
     # Case 3: Not converged and unacceptable.
     else:  # max_rhat >= divergence_threshold
-      return results.ConvergenceCheckResult(
-          case=results.ConvergenceCases.NOT_CONVERGED,
-          details=details,
-      )
+      case = results.ConvergenceCases.NOT_CONVERGED
+
+    return results.ConvergenceCheckResult(
+        case=case,
+        config=self._config,
+        max_rhat=max_rhat,
+        max_parameter=max_parameter,
+    )
 
 
 # ==============================================================================
@@ -131,33 +117,25 @@ class BaselineCheck(
   """Checks for negative baseline probability."""
 
   def run(self) -> results.BaselineCheckResult:
-    prob = self._analyzer.negative_baseline_probability()
-    details = {
-        review_constants.NEGATIVE_BASELINE_PROB: prob,
-        review_constants.NEGATIVE_BASELINE_PROB_FAIL_THRESHOLD: (
-            self._config.negative_baseline_prob_fail_threshold
-        ),
-        review_constants.NEGATIVE_BASELINE_PROB_REVIEW_THRESHOLD: (
-            self._config.negative_baseline_prob_review_threshold
-        ),
-    }
+    prob = float(self._analyzer.negative_baseline_probability())
+
     # Case 1: FAIL
     if prob > self._config.negative_baseline_prob_fail_threshold:
-      return results.BaselineCheckResult(
-          case=results.BaselineCases.FAIL,
-          details=details,
-      )
+      case = results.BaselineCases.FAIL
+
     # Case 2: REVIEW
     elif prob >= self._config.negative_baseline_prob_review_threshold:
-      return results.BaselineCheckResult(
-          case=results.BaselineCases.REVIEW,
-          details=details,
-      )
+      case = results.BaselineCases.REVIEW
+
     # Case 3: PASS
     else:
-      return results.BaselineCheckResult(
-          case=results.BaselineCases.PASS, details=details
-      )
+      case = results.BaselineCases.PASS
+
+    return results.BaselineCheckResult(
+        case=case,
+        config=self._config,
+        negative_baseline_prob=prob,
+    )
 
 
 # ==============================================================================
@@ -189,45 +167,40 @@ class BayesianPPPCheck(
         >= np.abs(total_outcome_actual - total_outcome_expected_mean)
     )
 
-    details = {
-        review_constants.BAYESIAN_PPP: bayesian_ppp,
-    }
-
     if bayesian_ppp >= self._config.ppp_threshold:
-      return results.BayesianPPPCheckResult(
-          case=results.BayesianPPPCases.PASS,
-          details=details,
-      )
+      case = results.BayesianPPPCases.PASS
     else:
-      return results.BayesianPPPCheckResult(
-          case=results.BayesianPPPCases.FAIL,
-          details=details,
-      )
+      case = results.BayesianPPPCases.FAIL
+
+    return results.BayesianPPPCheckResult(
+        case=case,
+        config=self._config,
+        bayesian_ppp=bayesian_ppp,
+    )
 
 
 # ==============================================================================
 # Check: Goodness of Fit
 # ==============================================================================
-def _set_details_from_gof_dataframe(
-    details: dict[str, float],
+def _set_metrics_from_gof_dataframe(
+    metrics: MutableMapping[str, float],
     gof_df: pd.DataFrame,
     geo_granularity: str,
-    suffix: str | None = None,
+    suffix: str,
 ) -> None:
-  """Sets the `details` variable of the GoodnessOfFitCheckResult.
+  """Sets the `metrics` variable of the GoodnessOfFitCheckResult.
 
   This method takes a DataFrame containing goodness of fit metrics and pivots it
-  to a Series, which is then added to the `details` variable of the
+  to a Series, which is then added to the `metrics` variable of the
   `GoodnessOfFitCheckResult`.
 
   Args:
-    details: A dictionary to store the goodness of fit metrics in.
+    metrics: A dictionary to store the goodness of fit metrics in.
     gof_df: A DataFrame containing predictive accuracy of the whole data (if
       holdout set is not used) of filtered to a single evaluation set ("all",
       "train", or "test").
     geo_granularity: The geo granularity of the data ("geo" or "national").
-    suffix: A suffix to add to the metric names (e.g., "all", "train", "test").
-      If None, the metrics are added without a suffix.
+    suffix: A suffix to add to the metric names (e.g., "_train", "_test").
   """
   gof_metrics_pivoted = gof_df.pivot(
       index=constants.GEO_GRANULARITY,
@@ -235,22 +208,15 @@ def _set_details_from_gof_dataframe(
       values=constants.VALUE,
   )
   gof_metrics_series = gof_metrics_pivoted.loc[geo_granularity]
-  if suffix is not None:
-    details[f"{review_constants.R_SQUARED}_{suffix}"] = gof_metrics_series[
-        constants.R_SQUARED
-    ]
-    details[f"{review_constants.MAPE}_{suffix}"] = gof_metrics_series[
-        constants.MAPE
-    ]
-    details[f"{review_constants.WMAPE}_{suffix}"] = gof_metrics_series[
-        constants.WMAPE
-    ]
-  else:
-    details[review_constants.R_SQUARED] = gof_metrics_series[
-        constants.R_SQUARED
-    ]
-    details[review_constants.MAPE] = gof_metrics_series[constants.MAPE]
-    details[review_constants.WMAPE] = gof_metrics_series[constants.WMAPE]
+  metrics[f"{review_constants.R_SQUARED}{suffix}"] = gof_metrics_series[
+      constants.R_SQUARED
+  ]
+  metrics[f"{review_constants.MAPE}{suffix}"] = gof_metrics_series[
+      constants.MAPE
+  ]
+  metrics[f"{review_constants.WMAPE}{suffix}"] = gof_metrics_series[
+      constants.WMAPE
+  ]
 
 
 class GoodnessOfFitCheck(
@@ -269,7 +235,7 @@ class GoodnessOfFitCheck(
     gof_metrics = gof_df[gof_df[constants.GEO_GRANULARITY] == geo_granularity]
     is_holdout = constants.EVALUATION_SET_VAR in gof_df.columns
 
-    details = {}
+    metrics_dict = {}
     case = results.GoodnessOfFitCases.PASS
 
     if is_holdout:
@@ -281,29 +247,71 @@ class GoodnessOfFitCheck(
         set_metrics = gof_metrics[
             gof_metrics[constants.EVALUATION_SET_VAR] == evaluation_set
         ]
-        _set_details_from_gof_dataframe(
-            details=details,
+        _set_metrics_from_gof_dataframe(
+            metrics=metrics_dict,
             gof_df=set_metrics,
             geo_granularity=geo_granularity,
             suffix=suffix,
         )
-        if details[f"{review_constants.R_SQUARED}_{suffix}"] <= 0:
+        if metrics_dict[f"{review_constants.R_SQUARED}{suffix}"] <= 0:
           case = results.GoodnessOfFitCases.REVIEW
+      return results.GoodnessOfFitCheckResult(
+          case=case,
+          metrics=results.GoodnessOfFitMetrics(
+              r_squared=metrics_dict[
+                  f"{review_constants.R_SQUARED}{review_constants.ALL_SUFFIX}"
+              ],
+              mape=metrics_dict[
+                  f"{review_constants.MAPE}{review_constants.ALL_SUFFIX}"
+              ],
+              wmape=metrics_dict[
+                  f"{review_constants.WMAPE}{review_constants.ALL_SUFFIX}"
+              ],
+              r_squared_train=metrics_dict[
+                  f"{review_constants.R_SQUARED}{review_constants.TRAIN_SUFFIX}"
+              ],
+              mape_train=metrics_dict[
+                  f"{review_constants.MAPE}{review_constants.TRAIN_SUFFIX}"
+              ],
+              wmape_train=metrics_dict[
+                  f"{review_constants.WMAPE}{review_constants.TRAIN_SUFFIX}"
+              ],
+              r_squared_test=metrics_dict[
+                  f"{review_constants.R_SQUARED}{review_constants.TEST_SUFFIX}"
+              ],
+              mape_test=metrics_dict[
+                  f"{review_constants.MAPE}{review_constants.TEST_SUFFIX}"
+              ],
+              wmape_test=metrics_dict[
+                  f"{review_constants.WMAPE}{review_constants.TEST_SUFFIX}"
+              ],
+          ),
+          is_holdout=is_holdout,
+      )
     else:
-      _set_details_from_gof_dataframe(
-          details=details,
+      _set_metrics_from_gof_dataframe(
+          metrics=metrics_dict,
           gof_df=gof_metrics,
           geo_granularity=geo_granularity,
-          suffix=None,
+          suffix=review_constants.ALL_SUFFIX,
       )
-      if details[review_constants.R_SQUARED] <= 0:
+      if metrics_dict[review_constants.R_SQUARED] <= 0:
         case = results.GoodnessOfFitCases.REVIEW
-
-    return results.GoodnessOfFitCheckResult(
-        case=case,
-        details=details,
-        is_holdout=is_holdout,
-    )
+      return results.GoodnessOfFitCheckResult(
+          case=case,
+          metrics=results.GoodnessOfFitMetrics(
+              r_squared=metrics_dict[
+                  f"{review_constants.R_SQUARED}{review_constants.ALL_SUFFIX}"
+              ],
+              mape=metrics_dict[
+                  f"{review_constants.MAPE}{review_constants.ALL_SUFFIX}"
+              ],
+              wmape=metrics_dict[
+                  f"{review_constants.WMAPE}{review_constants.ALL_SUFFIX}"
+              ],
+          ),
+          is_holdout=is_holdout,
+      )
 
 
 # ==============================================================================
@@ -475,8 +483,10 @@ def _compute_channel_results(
     channel_results.append(
         results.ROIConsistencyChannelResult(
             case=case,
-            details={},
             channel_name=channel,
+            prior_roi_lo=np.nan,
+            prior_roi_hi=np.nan,
+            posterior_roi_mean=np.nan,
         )
     )
   for i, channel in enumerate(channel_data.all_channels):
@@ -491,14 +501,10 @@ def _compute_channel_results(
     channel_results.append(
         results.ROIConsistencyChannelResult(
             case=case,
-            details={
-                review_constants.PRIOR_ROI_LO: channel_data.prior_roi_los[i],
-                review_constants.PRIOR_ROI_HI: channel_data.prior_roi_his[i],
-                review_constants.POSTERIOR_ROI_MEAN: (
-                    channel_data.posterior_means[i]
-                ),
-            },
             channel_name=channel,
+            prior_roi_lo=channel_data.prior_roi_los[i],
+            prior_roi_hi=channel_data.prior_roi_his[i],
+            posterior_roi_mean=channel_data.posterior_means[i],
         )
     )
   return channel_results
@@ -558,7 +564,7 @@ def _compute_aggregate_result(
 
   return results.ROIConsistencyCheckResult(
       case=aggregate_case,
-      details=aggregate_details,
+      aggregate_details=aggregate_details,
       channel_results=channel_results,
   )
 
@@ -734,7 +740,7 @@ class PriorPosteriorShiftCheck(
         no_shift_channels.append(channel_name)
       channel_results.append(
           results.PriorPosteriorShiftChannelResult(
-              case=case, details={}, channel_name=channel_name
+              case=case, channel_name=channel_name
           )
       )
     return channel_results, no_shift_channels
@@ -752,17 +758,13 @@ class PriorPosteriorShiftCheck(
 
     if no_shift_channels:
       agg_case = results.PriorPosteriorShiftAggregateCases.REVIEW
-      final_details = {
-          "channels_str": ", ".join(
-              f"`{channel}`" for channel in no_shift_channels
-          )
-      }
     else:
       agg_case = results.PriorPosteriorShiftAggregateCases.PASS
-      final_details = {}
 
     return results.PriorPosteriorShiftCheckResult(
-        case=agg_case, details=final_details, channel_results=channel_results
+        case=agg_case,
+        channel_results=channel_results,
+        no_shift_channels=no_shift_channels,
     )
 
   def run(self) -> results.PriorPosteriorShiftCheckResult:

meridian/analysis/review/constants.py

@@ -32,9 +32,9 @@ NEGATIVE_BASELINE_PROB_REVIEW_THRESHOLD = (
 R_SQUARED = "r_squared"
 MAPE = "mape"
 WMAPE = "wmape"
-ALL_SUFFIX = "all"
-TRAIN_SUFFIX = "train"
-TEST_SUFFIX = "test"
+ALL_SUFFIX = ""
+TRAIN_SUFFIX = "_train"
+TEST_SUFFIX = "_test"
 EVALUATION_SET_SUFFIXES = (ALL_SUFFIX, TRAIN_SUFFIX, TEST_SUFFIX)
 MEAN = "mean"
 VARIANCE = "variance"

meridian/analysis/review/results.py

@@ -14,9 +14,13 @@
 
 """Data structures for the Model Quality Checks results."""
 
+import abc
+from collections.abc import Mapping
 import dataclasses
 import enum
 from typing import Any
+
+from meridian.analysis.review import configs
 from meridian.analysis.review import constants
 
 
@@ -58,11 +62,16 @@ class ModelCheckCase(BaseCase):
 
 
 @dataclasses.dataclass(frozen=True)
-class BaseResultData:
+class BaseResultData(abc.ABC):
   """Base class for check result data."""
 
   case: BaseCase
-  details: dict[str, Any]
+
+  @property
+  @abc.abstractmethod
+  def details(self) -> Mapping[str, Any]:
+    """Returns the details for message formatting."""
+    raise NotImplementedError
 
 
 @dataclasses.dataclass(frozen=True)
@@ -145,17 +154,18 @@ class ConvergenceCheckResult(CheckResult):
   """The immutable result of the Convergence Check."""
 
   case: ConvergenceCases
+  config: configs.ConvergenceConfig
+  max_rhat: float
+  max_parameter: str
 
-  def __post_init__(self):
-    if self.case == ConvergenceCases.CONVERGED and (
-        constants.CONVERGENCE_THRESHOLD not in self.details
-    ):
-      raise ValueError(
-          "The message template 'The model has likely converged, as all"
-          " parameters have R-hat values < {convergence_threshold}'. is"
-          " missing required formatting arguments: convergence_threshold."
-          f" Details: {self.details}."
-      )
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """The check result details."""
+    return {
+        constants.RHAT: self.max_rhat,
+        constants.PARAMETER: self.max_parameter,
+        constants.CONVERGENCE_THRESHOLD: self.config.convergence_threshold,
+    }
 
 
 # ==============================================================================
@@ -223,24 +233,21 @@ class BaselineCheckResult(CheckResult):
   """The immutable result of the Baseline Check."""
 
   case: BaselineCases
+  config: configs.BaselineConfig
+  negative_baseline_prob: float
 
-  def __post_init__(self):
-    if self.case is BaselineCases.PASS:
-      return
-    if any(
-        key not in self.details
-        for key in (
-            constants.NEGATIVE_BASELINE_PROB,
-            constants.NEGATIVE_BASELINE_PROB_FAIL_THRESHOLD,
-            constants.NEGATIVE_BASELINE_PROB_REVIEW_THRESHOLD,
-        )
-    ):
-      raise ValueError(
-          "The message template is missing required formatting arguments:"
-          " negative_baseline_prob, negative_baseline_prob_fail_threshold,"
-          " negative_baseline_prob_review_threshold. Details:"
-          f" {self.details}."
-      )
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """The check result details."""
+    return {
+        constants.NEGATIVE_BASELINE_PROB: self.negative_baseline_prob,
+        constants.NEGATIVE_BASELINE_PROB_FAIL_THRESHOLD: (
+            self.config.negative_baseline_prob_fail_threshold
+        ),
+        constants.NEGATIVE_BASELINE_PROB_REVIEW_THRESHOLD: (
+            self.config.negative_baseline_prob_review_threshold
+        ),
+    }
 
 
 # ==============================================================================
@@ -287,14 +294,15 @@ class BayesianPPPCheckResult(CheckResult):
   """The immutable result of the Bayesian Posterior Predictive P-value Check."""
 
   case: BayesianPPPCases
+  config: configs.BayesianPPPConfig
+  bayesian_ppp: float
 
-  def __post_init__(self):
-    if constants.BAYESIAN_PPP not in self.details:
-      raise ValueError(
-          "The message template is missing required formatting arguments:"
-          " bayesian_ppp. Details:"
-          f" {self.details}."
-      )
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """The check result details."""
+    return {
+        constants.BAYESIAN_PPP: self.bayesian_ppp,
+    }
 
 
 # ==============================================================================
@@ -337,55 +345,77 @@ class GoodnessOfFitCases(ModelCheckCase, enum.Enum):
     super().__init__(status, message_template, recommendation)
 
 
+@dataclasses.dataclass(frozen=True)
+class GoodnessOfFitMetrics:
+  """The metrics for the Goodness of Fit Check."""
+
+  r_squared: float
+  mape: float
+  wmape: float
+  r_squared_train: float | None = None
+  mape_train: float | None = None
+  wmape_train: float | None = None
+  r_squared_test: float | None = None
+  mape_test: float | None = None
+  wmape_test: float | None = None
+
+
 @dataclasses.dataclass(frozen=True)
 class GoodnessOfFitCheckResult(CheckResult):
   """The immutable result of the Goodness of Fit Check."""
 
   case: GoodnessOfFitCases
+  metrics: GoodnessOfFitMetrics
   is_holdout: bool = False
 
   def __post_init__(self):
     if self.is_holdout:
-      required_keys = []
-      for suffix in [
-          constants.ALL_SUFFIX,
-          constants.TRAIN_SUFFIX,
-          constants.TEST_SUFFIX,
-      ]:
-        required_keys.extend([
-            f"{constants.R_SQUARED}_{suffix}",
-            f"{constants.MAPE}_{suffix}",
-            f"{constants.WMAPE}_{suffix}",
-        ])
-      if any(key not in self.details for key in required_keys):
+      if any(
+          metric is None
+          for metric in (
+              self.metrics.r_squared_train,
+              self.metrics.mape_train,
+              self.metrics.wmape_train,
+              self.metrics.r_squared_test,
+              self.metrics.mape_test,
+              self.metrics.wmape_test,
+          )
+      ):
         raise ValueError(
             "The message template is missing required formatting arguments for"
-            f" holdout case. Required keys: {required_keys}. Details:"
-            f" {self.details}."
-        )
-    elif any(
-        key not in self.details
-        for key in (
-            constants.R_SQUARED,
-            constants.MAPE,
-            constants.WMAPE,
+            " holdout case. Required keys: r_squared_train, mape_train,"
+            " wmape_train, r_squared_test, mape_test, wmape_test. Metrics:"
+            f" {self.metrics}."
         )
-    ):
-      raise ValueError(
-          "The message template is missing required formatting arguments:"
-          " r_squared, mape, wmape. Details:"
-          f" {self.details}."
-      )
+
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """The check result details."""
+    return {
+        f"{constants.R_SQUARED}{constants.ALL_SUFFIX}": self.metrics.r_squared,
+        f"{constants.MAPE}{constants.ALL_SUFFIX}": self.metrics.mape,
+        f"{constants.WMAPE}{constants.ALL_SUFFIX}": self.metrics.wmape,
+        f"{constants.R_SQUARED}{constants.TRAIN_SUFFIX}": (
+            self.metrics.r_squared_train
+        ),
+        f"{constants.MAPE}{constants.TRAIN_SUFFIX}": self.metrics.mape_train,
+        f"{constants.WMAPE}{constants.TRAIN_SUFFIX}": self.metrics.wmape_train,
+        f"{constants.R_SQUARED}{constants.TEST_SUFFIX}": (
+            self.metrics.r_squared_test
+        ),
+        f"{constants.MAPE}{constants.TEST_SUFFIX}": self.metrics.mape_test,
+        f"{constants.WMAPE}{constants.TEST_SUFFIX}": self.metrics.wmape_test,
+    }
 
   @property
   def recommendation(self) -> str:
-    """Returns the check result message."""
+    """The check result message."""
     if self.is_holdout:
       report_str = (
-          "R-squared = {r_squared_all:.4f} (All),"
+          "R-squared = {r_squared:.4f} (All),"
           " {r_squared_train:.4f} (Train), {r_squared_test:.4f} (Test); MAPE"
-          " = {mape_all:.4f} (All), {mape_train:.4f} (Train),"
-          " {mape_test:.4f} (Test); wMAPE = {wmape_all:.4f} (All),"
+          " = {mape:.4f} (All), {mape_train:.4f} (Train),"
+          " {mape_test:.4f} (Test); wMAPE = {wmape:.4f} (All),"
           " {wmape_train:.4f} (Train), {wmape_test:.4f} (Test)".format(
               **self.details
           )
@@ -450,6 +480,18 @@ class ROIConsistencyChannelResult(ChannelResult):
   """The immutable result of ROI Consistency Check for a single channel."""
 
   case: ROIConsistencyChannelCases
+  prior_roi_lo: float
+  prior_roi_hi: float
+  posterior_roi_mean: float
+
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """Returns the check result details."""
+    return {
+        constants.PRIOR_ROI_LO: self.prior_roi_lo,
+        constants.PRIOR_ROI_HI: self.prior_roi_hi,
+        constants.POSTERIOR_ROI_MEAN: self.posterior_roi_mean,
+    }
 
 
 @dataclasses.dataclass(frozen=True)
@@ -458,6 +500,12 @@ class ROIConsistencyCheckResult(CheckResult):
 
   case: ROIConsistencyAggregateCases
   channel_results: list[ROIConsistencyChannelResult]
+  aggregate_details: Mapping[str, Any]
+
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """Returns the check result details."""
+    return self.aggregate_details
 
 
 # ==============================================================================
@@ -517,6 +565,11 @@ class PriorPosteriorShiftChannelResult(ChannelResult):
 
   case: PriorPosteriorShiftChannelCases
 
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """Returns the check result details."""
+    return {}
+
 
 @dataclasses.dataclass(frozen=True)
 class PriorPosteriorShiftCheckResult(CheckResult):
@@ -524,6 +577,16 @@ class PriorPosteriorShiftCheckResult(CheckResult):
 
   case: PriorPosteriorShiftAggregateCases
   channel_results: list[PriorPosteriorShiftChannelResult]
+  no_shift_channels: list[str]
+
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """Returns the check result details."""
+    return {
+        "channels_str": ", ".join(
+            f"`{channel}`" for channel in self.no_shift_channels
+        )
+    }
 
 
 # ==============================================================================
@@ -567,7 +630,7 @@ class ReviewSummary:
     return "\n".join(report)
 
   @property
-  def checks_status(self) -> dict[str, str]:
+  def checks_status(self) -> Mapping[str, str]:
     """Returns a dictionary of check names and statuses."""
     return {
         result.__class__.__name__: result.case.status.name

meridian/analysis/review/reviewer.py

@@ -29,7 +29,7 @@ CheckType = typing.Type[checks.BaseCheck]
 ConfigInstance = configs.BaseConfig
 ChecksBattery = immutabledict.immutabledict[CheckType, ConfigInstance]
 
-_DEFAULT_POST_CONVERGENCE_CHECKS: ChecksBattery = immutabledict.immutabledict({
+_POST_CONVERGENCE_CHECKS: ChecksBattery = immutabledict.immutabledict({
     checks.BaselineCheck: configs.BaselineConfig(),
     checks.BayesianPPPCheck: configs.BayesianPPPConfig(),
     checks.GoodnessOfFitCheck: configs.GoodnessOfFitConfig(),
@@ -39,39 +39,22 @@ _DEFAULT_POST_CONVERGENCE_CHECKS: ChecksBattery = immutabledict.immutabledict({
 
 
 class ModelReviewer:
-  """Executes a series of quality checks on a Meridian model.
+  """A tool for executing a series of quality checks on a Meridian model.
 
   The reviewer first runs a convergence check. If the model has converged, it
   proceeds to run a battery of post-convergence checks.
 
-  The default battery of post-convergence checks includes:
+  The battery of post-convergence checks includes:
     - BaselineCheck
     - BayesianPPPCheck
     - GoodnessOfFitCheck
     - PriorPosteriorShiftCheck
     - ROIConsistencyCheck
-  Each with its default configuration.
-
-  This battery of checks can be customized by passing a dictionary to the
-  `post_convergence_checks` argument of the constructor, mapping check
-  classes to their configuration instances. For example, to run only the
-  BaselineCheck with a non-default configuration:
-
-  ```python
-    my_checks = {
-        checks.BaselineCheck: configs.BaselineConfig(
-            negative_baseline_prob_review_threshold=0.1,
-            negative_baseline_prob_fail_threshold=0.5,
-        )
-    }
-    reviewer = ModelReviewer(meridian_model, post_convergence_checks=my_checks)
-  ```
   """
 
   def __init__(
       self,
       meridian,
-      post_convergence_checks: ChecksBattery = _DEFAULT_POST_CONVERGENCE_CHECKS,
   ):
     self._meridian = meridian
     self._results: list[results.CheckResult] = []
@@ -79,7 +62,6 @@ class ModelReviewer:
         model_context=meridian.model_context,
         inference_data=meridian.inference_data,
     )
-    self._post_convergence_checks = post_convergence_checks
 
   def _run_and_handle(self, check_class, config):
     instance = check_class(self._meridian, self._analyzer, config)  # pytype: disable=not-instantiable
@@ -139,7 +121,7 @@ class ModelReviewer:
       )
 
     # Run all other checks in sequence.
-    for check_class, config in self._post_convergence_checks.items():
+    for check_class, config in _POST_CONVERGENCE_CHECKS.items():
       if (
           check_class == checks.PriorPosteriorShiftCheck
           and not self._uses_roi_priors()

meridian/model/eda/eda_engine.py

@@ -550,6 +550,7 @@ class EDAEngine:
 
   def __init__(
       self,
+      # TODO: b/476230365 - Remove meridian arg.
       meridian: model.Meridian | None = None,
       spec: eda_spec.EDASpec = eda_spec.EDASpec(),
       *,

meridian/version.py

@@ -14,4 +14,4 @@
 
 """Module for Meridian version."""
 
-__version__ = "1.5.0"
+__version__ = "1.5.1"

schema/serde/meridian_serde.py

@@ -357,7 +357,9 @@ def save_meridian(
   if not _file_exists(os.path.dirname(file_path)):
     _make_dirs(os.path.dirname(file_path))
 
-  with _file_open(file_path, 'wb') as f:
+  mode = 'wb' if file_path.endswith('.binpb') else 'w'
+
+  with _file_open(file_path, mode) as f:
     # Creates an MmmKernel.
     serialized_kernel = MeridianSerde().serialize(
         mmm,
@@ -402,7 +404,9 @@ def load_meridian(
   Returns:
     Model object loaded from the file path.
   """
-  with _file_open(file_path, 'rb') as f:
+  mode = 'rb' if file_path.endswith('.binpb') else 'r'
+
+  with _file_open(file_path, mode) as f:
     if file_path.endswith('.binpb'):
       serialized_model = kernel_pb.MmmKernel.FromString(f.read())
     elif file_path.endswith('.textproto') or file_path.endswith('.txtpb'):