google-meridian 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

meridian/analysis/review/reviewer.py

@@ -0,0 +1,186 @@
+# Copyright 2025 The Meridian Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Implementation of the runner of the Model Quality Checks."""
+
+import typing
+
+import immutabledict
+from meridian import constants
+from meridian.analysis import analyzer as analyzer_module
+from meridian.analysis.review import checks
+from meridian.analysis.review import configs
+from meridian.analysis.review import results
+from meridian.model import prior_distribution
+
+
+CheckType = typing.Type[checks.BaseCheck]
+ConfigInstance = configs.BaseConfig
+ChecksBattery = immutabledict.immutabledict[CheckType, ConfigInstance]
+
+_DEFAULT_POST_CONVERGENCE_CHECKS: ChecksBattery = immutabledict.immutabledict({
+    checks.BaselineCheck: configs.BaselineConfig(),
+    checks.BayesianPPPCheck: configs.BayesianPPPConfig(),
+    checks.GoodnessOfFitCheck: configs.GoodnessOfFitConfig(),
+    checks.PriorPosteriorShiftCheck: configs.PriorPosteriorShiftConfig(),
+    checks.ROIConsistencyCheck: configs.ROIConsistencyConfig(),
+})
+
+
+class ModelReviewer:
+  """Executes 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:
+    - 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] = []
+    self._analyzer = analyzer_module.Analyzer(meridian)
+    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
+    self._results.append(instance.run())
+
+  def _uses_roi_priors(self):
+    """Checks if the model uses ROI priors."""
+    return (
+        self._meridian.n_media_channels > 0
+        and self._meridian.model_spec.effective_media_prior_type
+        == constants.TREATMENT_PRIOR_TYPE_ROI
+    ) or (
+        self._meridian.n_rf_channels > 0
+        and self._meridian.model_spec.effective_rf_prior_type
+        == constants.TREATMENT_PRIOR_TYPE_ROI
+    )
+
+  def _has_custom_roi_priors(self):
+    """Checks if the model uses custom ROI priors."""
+    default_distribution = prior_distribution.PriorDistribution()
+    if (
+        self._meridian.n_media_channels > 0
+        and self._meridian.model_spec.effective_media_prior_type
+        == constants.TREATMENT_PRIOR_TYPE_ROI
+    ):
+      if not prior_distribution.distributions_are_equal(
+          self._meridian.model_spec.prior.roi_m, default_distribution.roi_m
+      ):
+        return True
+    if (
+        self._meridian.n_rf_channels > 0
+        and self._meridian.model_spec.effective_rf_prior_type
+        == constants.TREATMENT_PRIOR_TYPE_ROI
+    ):
+      if not prior_distribution.distributions_are_equal(
+          self._meridian.model_spec.prior.roi_rf, default_distribution.roi_rf
+      ):
+        return True
+    return False
+
+  def run(self) -> results.ReviewSummary:
+    """Executes all checks and generates the final summary."""
+    self._results.clear()
+    self._run_and_handle(checks.ConvergenceCheck, configs.ConvergenceConfig())
+
+    # Stop if the model did not converge.
+    if (
+        self._results
+        and self._results[0].case is results.ConvergenceCases.NOT_CONVERGED
+    ):
+      return results.ReviewSummary(
+          overall_status=results.Status.FAIL,
+          summary_message=(
+              "Failed: Model did not converge. Other checks were skipped."
+          ),
+          results=self._results,
+      )
+
+    # Run all other checks in sequence.
+    for check_class, config in self._post_convergence_checks.items():
+      if (
+          check_class == checks.PriorPosteriorShiftCheck
+          and not self._uses_roi_priors()
+      ):
+        # Skip the Prior-Posterior Shift check if no ROI priors are used.
+        continue
+      if (
+          check_class == checks.ROIConsistencyCheck
+          and not self._has_custom_roi_priors()
+      ):
+        # Skip the ROI Consistency check if no custom ROI priors are provided.
+        continue
+      self._run_and_handle(check_class, config)
+
+    # Determine the final overall status.
+    has_failures = any(
+        res.case.status is results.Status.FAIL for res in self._results
+    )
+    has_reviews = any(
+        res.case.status is results.Status.REVIEW for res in self._results
+    )
+
+    if has_failures and has_reviews:
+      overall_status = results.Status.FAIL
+      summary_message = (
+          "Failed: Quality issues were detected in your model. Follow"
+          " recommendations to address any failed checks and review"
+          " results to determine if further action is needed."
+      )
+    elif has_failures:
+      overall_status = results.Status.FAIL
+      summary_message = (
+          "Failed: Quality issues were detected in your model. Address failed"
+          " checks before proceeding."
+      )
+    elif has_reviews:
+      overall_status = results.Status.PASS
+      summary_message = "Passed with reviews: Review is needed."
+    else:
+      overall_status = results.Status.PASS
+      summary_message = "Passed: No major quality issues were identified."
+
+    return results.ReviewSummary(
+        overall_status=overall_status,
+        summary_message=summary_message,
+        results=self._results,
+    )

meridian/analysis/summarizer.py

@@ -20,6 +20,7 @@ import os
 
 import jinja2
 from meridian import constants as c
+from meridian.analysis import analyzer
 from meridian.analysis import formatter
 from meridian.analysis import summary_text
 from meridian.analysis import visualizer
@@ -59,17 +60,18 @@ RESPONSE_CURVES_CARD_SPEC = formatter.CardSpec(
 class Summarizer:
   """Generates HTML summary visualizations from the model fitting."""
 
-  def __init__(self, meridian: model.Meridian):
+  def __init__(self, meridian: model.Meridian, use_kpi: bool = False):
     """Initialize the visualizer classes that are not time-dependent."""
     self._meridian = meridian
+    self._use_kpi = analyzer.Analyzer(meridian)._use_kpi(use_kpi)
 
   @functools.cached_property
   def _model_fit(self):
-    return visualizer.ModelFit(self._meridian)
+    return visualizer.ModelFit(self._meridian, use_kpi=self._use_kpi)
 
   @functools.cached_property
   def _model_diagnostics(self):
-    return visualizer.ModelDiagnostics(self._meridian)
+    return visualizer.ModelDiagnostics(self._meridian, use_kpi=self._use_kpi)
 
   def output_model_results_summary(
       self,
@@ -153,12 +155,14 @@ class Summarizer:
   ) -> Sequence[str]:
     """Creates the HTML snippets for cards in the summary page."""
     media_summary = visualizer.MediaSummary(
-        self._meridian, selected_times=selected_times
+        self._meridian, selected_times=selected_times, use_kpi=self._use_kpi
+    )
+    media_effects = visualizer.MediaEffects(
+        self._meridian, use_kpi=self._use_kpi
     )
-    media_effects = visualizer.MediaEffects(self._meridian)
     reach_frequency = (
         visualizer.ReachAndFrequency(
-            self._meridian, selected_times=selected_times
+            self._meridian, selected_times=selected_times, use_kpi=self._use_kpi
         )
         if self._meridian.n_rf_channels > 0
         else None
@@ -168,7 +172,9 @@ class Summarizer:
             template_env, selected_times=selected_times
         ),
         self._create_outcome_contrib_card_html(
-            template_env, media_summary, selected_times=selected_times
+            template_env,
+            media_summary,
+            selected_times=selected_times,
         ),
         self._create_performance_breakdown_card_html(
             template_env, media_summary
@@ -525,8 +531,4 @@ class Summarizer:
     ).optimal_frequency
 
   def _kpi_or_revenue(self) -> str:
-    if self._meridian.input_data.revenue_per_kpi is not None:
-      outcome_str = c.REVENUE
-    else:
-      outcome_str = c.KPI.upper()
-    return outcome_str
+    return c.KPI.upper() if self._use_kpi else c.REVENUE

meridian/analysis/templates/chips.html.jinja

@@ -18,4 +18,16 @@ limitations under the License.
   <chip>
     Time period: {{ start_date }} - {{ end_date }}
   </chip>
+  {% if selected_geos %}
+    {%- set geo_count = selected_geos | length %}
+    {%- set full_list = selected_geos | join(', ') %}
+    <chip title="Selected: {{ full_list }}">
+      Selected geos:
+      {%- if geo_count > 5 %}
+        {{ selected_geos[:5] | join(', ') }}, + {{ geo_count - 5 }} more
+      {%- else %}
+        {{ full_list }}
+      {%- endif %}
+    </chip>
+  {% endif %}
 </chips>

meridian/analysis/test_utils.py

@@ -726,8 +726,6 @@ INC_OUTCOME_NON_PAID_USE_PRIOR = np.array([[
         2.224e05,
     ],
 ]])
-
-
 INC_OUTCOME_NON_PAID_USE_POSTERIOR = np.array([
     [
         [
@@ -1055,7 +1053,6 @@ INC_OUTCOME_NON_PAID_USE_POSTERIOR = np.array([
     ],
 ])
 
-
 INC_OUTCOME_NON_MEDIA_MAX = np.array([
     [
         [
@@ -1282,7 +1279,6 @@ INC_OUTCOME_NON_MEDIA_MAX = np.array([
         ],
     ],
 ])
-
 INC_OUTCOME_NON_MEDIA_MIX = np.array([
     [
         [
@@ -1509,7 +1505,6 @@ INC_OUTCOME_NON_MEDIA_MIX = np.array([
         ],
     ],
 ])
-
 INC_OUTCOME_NON_MEDIA_FIXED = np.array([
     [
         [
@@ -1737,6 +1732,33 @@ INC_OUTCOME_NON_MEDIA_FIXED = np.array([
     ],
 ])
 
+EXP_OUTCOME_MEDIA_AND_RF = np.array([
+    [
+        32254.154,
+        32296.66,
+        32331.918,
+        32391.336,
+        32797.367,
+        33077.375,
+        33469.82,
+        33316.707,
+        33251.33,
+        33261.21,
+    ],
+    [
+        53146.668,
+        53151.16,
+        53404.375,
+        53814.035,
+        54136.48,
+        54141.82,
+        54581.93,
+        54777.164,
+        54912.758,
+        54915.656,
+    ],
+])
+
 MROI_MEDIA_AND_RF_USE_PRIOR = np.array([[
     [0.3399, 1.7045, 3.1300, 2.7845, 0.3523],
     [0.4540, 1.3445, 0.9966, 0.2985, 0.4917],

meridian/analysis/visualizer.py

@@ -46,9 +46,10 @@ alt.data_transformers.disable_max_rows()
 class ModelDiagnostics:
   """Generates model diagnostics plots from the Meridian model fitting."""
 
-  def __init__(self, meridian: model.Meridian):
+  def __init__(self, meridian: model.Meridian, use_kpi: bool = False):
     self._meridian = meridian
     self._analyzer = analyzer.Analyzer(meridian)
+    self._use_kpi = self._analyzer._use_kpi(use_kpi)
 
   @functools.lru_cache(maxsize=128)
   def _predictive_accuracy_dataset(
@@ -82,6 +83,7 @@ class ModelDiagnostics:
     return self._analyzer.predictive_accuracy(
         selected_geos=selected_geos_list,
         selected_times=selected_times_list,
+        use_kpi=self._use_kpi,
         batch_size=batch_size,
     )
 
@@ -366,19 +368,23 @@ class ModelFit:
   def __init__(
       self,
       meridian: model.Meridian,
+      use_kpi: bool = False,
       confidence_level: float = c.DEFAULT_CONFIDENCE_LEVEL,
   ):
     """Initializes the dataset based on the model and confidence level.
 
     Args:
       meridian: Media mix model with the raw data from the model fitting.
+      use_kpi: If `True`, plots the incremental KPI. Otherwise, plots the
+        incremental revenue using the revenue per KPI (if available).
       confidence_level: Confidence level for expected outcome credible intervals
         represented as a value between zero and one. Default is `0.9`.
     """
     self._meridian = meridian
     self._analyzer = analyzer.Analyzer(meridian)
+    self._use_kpi = self._analyzer._use_kpi(use_kpi)
     self._model_fit_data = self._analyzer.expected_vs_actual_data(
-        confidence_level=confidence_level
+        use_kpi=self._use_kpi, confidence_level=confidence_level
     )
 
   @property
@@ -430,11 +436,7 @@ class ModelFit:
     Returns:
       An Altair plot showing the model fit.
     """
-    outcome = (
-        c.REVENUE
-        if self._meridian.input_data.revenue_per_kpi is not None
-        else c.KPI.upper()
-    )
+    outcome = c.KPI.upper() if self._use_kpi else c.REVENUE
     self._validate_times_to_plot(selected_times)
     self._validate_geos_to_plot(
         selected_geos, n_top_largest_geos, show_geo_level
@@ -459,10 +461,10 @@ class ModelFit:
     title = summary_text.EXPECTED_ACTUAL_OUTCOME_CHART_TITLE.format(
         outcome=outcome
     )
-    if self._meridian.input_data.revenue_per_kpi is not None:
-      y_axis_label = summary_text.REVENUE_LABEL
-    else:
+    if self._use_kpi:
       y_axis_label = summary_text.KPI_LABEL
+    else:
+      y_axis_label = summary_text.REVENUE_LABEL
     plot = (
         alt.Chart(model_fit_df, width=c.VEGALITE_FACET_EXTRA_LARGE_WIDTH)
         .mark_line()
@@ -638,7 +640,7 @@ class ReachAndFrequency:
       self,
       meridian: model.Meridian,
       selected_times: Sequence[str] | None = None,
-      use_kpi: bool | None = None,
+      use_kpi: bool = False,
   ):
     """Initializes the reach and frequency dataset for the model data.
 
@@ -651,15 +653,7 @@ class ReachAndFrequency:
     self._meridian = meridian
     self._analyzer = analyzer.Analyzer(meridian)
     self._selected_times = selected_times
-    # TODO Adapt the mechanisms to choose between KPI and REVENUE
-    # from Analyzer.
-    if use_kpi is None:
-      self._use_kpi = (
-          meridian.input_data.kpi_type == c.NON_REVENUE
-          and meridian.input_data.revenue_per_kpi is None
-      )
-    else:
-      self._use_kpi = use_kpi
+    self._use_kpi = self._analyzer._use_kpi(use_kpi)
     self._optimal_frequency_data = self._analyzer.optimal_freq(
         selected_times=selected_times,
         use_kpi=self._use_kpi,
@@ -844,6 +838,7 @@ class MediaEffects:
       self,
       meridian: model.Meridian,
       by_reach: bool = True,
+      use_kpi: bool = False,
   ):
     """Initializes the Media Effects based on the model data and params.
 
@@ -852,10 +847,13 @@ class MediaEffects:
       by_reach: For the channel w/ reach and frequency, return the response
         curves by reach given fixed frequency if true; return the response
         curves by frequency given fixed reach if false.
+      use_kpi: If `True`, calculate the incremental KPI. Otherwise, calculate
+        the incremental revenue using the revenue per KPI (if available).
     """
     self._meridian = meridian
     self._analyzer = analyzer.Analyzer(meridian)
     self._by_reach = by_reach
+    self._use_kpi = self._analyzer._use_kpi(use_kpi)
 
   @functools.lru_cache(maxsize=128)
   def response_curves_data(
@@ -891,13 +889,12 @@ class MediaEffects:
       A Dataset displaying the response curves data.
     """
     selected_times_list = list(selected_times) if selected_times else None
-    use_kpi = self._meridian.input_data.revenue_per_kpi is None
     return self._analyzer.response_curves(
         spend_multipliers=list(np.arange(0, 2.2, c.RESPONSE_CURVE_STEP_SIZE)),
         confidence_level=confidence_level,
         selected_times=selected_times_list,
         by_reach=by_reach,
-        use_kpi=use_kpi,
+        use_kpi=self._use_kpi,
     )
 
   @functools.lru_cache(maxsize=128)
@@ -1022,10 +1019,11 @@ class MediaEffects:
         selected_times=selected_times,
         by_reach=by_reach,
     )
-    if self._meridian.input_data.revenue_per_kpi is not None:
-      y_axis_label = summary_text.INC_OUTCOME_LABEL
-    else:
-      y_axis_label = summary_text.INC_KPI_LABEL
+    y_axis_label = (
+        summary_text.INC_KPI_LABEL
+        if self._use_kpi
+        else summary_text.INC_OUTCOME_LABEL
+    )
     base = (
         alt.Chart(response_curves_df, width=c.VEGALITE_FACET_DEFAULT_WIDTH)
         .transform_calculate(
@@ -1404,6 +1402,7 @@ class MediaSummary:
       selected_times: Sequence[str] | None = None,
       marginal_roi_by_reach: bool = True,
       non_media_baseline_values: Sequence[float] | None = None,
+      use_kpi: bool = False,
   ):
     """Initializes the media summary metrics based on the model data and params.
 
@@ -1423,6 +1422,7 @@ class MediaSummary:
         value which will be used as baseline for the given channel. If `None`,
         the values defined with `ModelSpec.non_media_baseline_values` will be
         used.
+      use_kpi: If `True`, use KPI instead of revenue.
     """
     self._meridian = meridian
     self._analyzer = analyzer.Analyzer(meridian)
@@ -1430,6 +1430,7 @@ class MediaSummary:
     self._selected_times = selected_times
     self._marginal_roi_by_reach = marginal_roi_by_reach
     self._non_media_baseline_values = non_media_baseline_values
+    self._use_kpi = self._analyzer._use_kpi(use_kpi)
 
   @property
   def paid_summary_metrics(self):
@@ -1464,7 +1465,7 @@ class MediaSummary:
     return self._analyzer.summary_metrics(
         selected_times=self._selected_times,
         marginal_roi_by_reach=self._marginal_roi_by_reach,
-        use_kpi=self._meridian.input_data.revenue_per_kpi is None,
+        use_kpi=self._use_kpi,
         confidence_level=self._confidence_level,
         include_non_paid_channels=False,
         aggregate_times=aggregate_times,
@@ -1497,7 +1498,7 @@ class MediaSummary:
     """
     return self._analyzer.summary_metrics(
         selected_times=self._selected_times,
-        use_kpi=self._meridian.input_data.revenue_per_kpi is None,
+        use_kpi=self._use_kpi,
         confidence_level=self._confidence_level,
         include_non_paid_channels=True,
         non_media_baseline_values=self._non_media_baseline_values,
@@ -1509,6 +1510,7 @@ class MediaSummary:
       include_prior: bool = True,
       include_posterior: bool = True,
       include_non_paid_channels: bool = False,
+      currency: str = c.DEFAULT_CURRENCY,
   ) -> pd.DataFrame:
     """Returns a formatted dataframe table of the summary metrics.
 
@@ -1525,6 +1527,7 @@ class MediaSummary:
         reported. If `False`, only the paid channels (media, reach and
         frequency) are included but the summary contains also the metrics
         dependent on spend. Default: `False`.
+      currency: The currency to use for the monetary values. Default: `'$'`.
 
     Returns:
       pandas.DataFrame of formatted summary metrics.
@@ -1534,7 +1537,7 @@ class MediaSummary:
           'At least one of `include_posterior` or `include_prior` must be True.'
       )
 
-    use_revenue = self._meridian.input_data.revenue_per_kpi is not None
+    use_revenue = not self._use_kpi
     distribution = [c.PRIOR] * include_prior + [c.POSTERIOR] * include_posterior
 
     percentage_metrics = [
@@ -1607,7 +1610,7 @@ class MediaSummary:
     # Format monetary values.
     for k in monetary_metrics:
       if k in df.columns:
-        df[k] = '$' + df[k].astype(str)
+        df[k] = currency + df[k].astype(str)
 
     # Format the model result data variables as central_tendency (ci_lo, ci_hi).
     index_vars = [c.CHANNEL, c.DISTRIBUTION]
@@ -1720,11 +1723,7 @@ class MediaSummary:
             ),
             y=alt.Y(
                 f'{c.INCREMENTAL_OUTCOME}:Q',
-                title=(
-                    c.REVENUE.title()
-                    if self._meridian.input_data.revenue_per_kpi is not None
-                    else c.KPI.upper()
-                ),
+                title=(c.KPI.upper() if self._use_kpi else c.REVENUE.title()),
                 axis=alt.Axis(
                     ticks=False,
                     domain=False,
@@ -1890,11 +1889,7 @@ class MediaSummary:
     Returns:
       An Altair plot showing the contributions per channel.
     """
-    outcome = (
-        c.REVENUE.title()
-        if self._meridian.input_data.revenue_per_kpi is not None
-        else c.KPI.upper()
-    )
+    outcome = c.KPI.upper() if self._use_kpi else c.REVENUE.title()
     outcome_df = self.contribution_metrics(include_non_paid=True)
     pct = c.PCT_OF_CONTRIBUTION
     value = c.INCREMENTAL_OUTCOME
@@ -1907,7 +1902,7 @@ class MediaSummary:
     num_channels = len(outcome_df[c.CHANNEL])
 
     base = (
-        alt.Chart(outcome_df, width=c.VEGALITE_FACET_LARGE_WIDTH)
+        alt.Chart(outcome_df)
         .transform_window(
             sum_outcome=f'sum({c.PCT_OF_CONTRIBUTION})',
             kwargs=f'lead({c.CHANNEL})',
@@ -1923,7 +1918,10 @@ class MediaSummary:
             y=alt.Y(
                 f'{c.CHANNEL}:N',
                 axis=alt.Axis(
-                    ticks=False, labelPadding=c.PADDING_10, domain=False
+                    ticks=False,
+                    labelPadding=c.PADDING_10,
+                    domain=False,
+                    labelLimit=0,
                 ),
                 title=None,
                 sort=None,
@@ -1966,6 +1964,7 @@ class MediaSummary:
             title=formatter.custom_title_params(
                 summary_text.CHANNEL_DRIVERS_CHART_TITLE
             ),
+            width=c.VEGALITE_FACET_LARGE_WIDTH,
             height=c.BAR_SIZE * num_channels
             + c.BAR_SIZE * 2 * c.SCALED_PADDING,
         )
@@ -2028,11 +2027,7 @@ class MediaSummary:
     Returns:
       An Altair plot showing the spend versus outcome percentages per channel.
     """
-    outcome = (
-        c.REVENUE
-        if self._meridian.input_data.revenue_per_kpi is not None
-        else c.KPI.upper()
-    )
+    outcome = c.KPI.upper() if self._use_kpi else c.REVENUE
     df = self._transform_contribution_spend_metrics()
     domain = [
         f'% {outcome.title() if outcome == c.REVENUE else outcome}',
@@ -2556,10 +2551,10 @@ class MediaSummary:
       A dataframe of spend and outcome percentages and ROI per channel.
     """
     paid_summary_metrics = self.get_paid_summary_metrics()
-    if self._meridian.input_data.revenue_per_kpi is not None:
-      outcome = summary_text.REVENUE_LABEL
-    else:
+    if self._use_kpi:
       outcome = summary_text.KPI_LABEL
+    else:
+      outcome = summary_text.REVENUE_LABEL
     total_media_outcome = (
         paid_summary_metrics[c.INCREMENTAL_OUTCOME]
         .sel(