Rapports sur les tests

Il existe deux façons principales de générer des rapports sur les tests A/B standards :

• Rapports de test directs : interrogez la ressource experiment pour obtenir des métriques. Cette option fournit des métriques pour les groupes de contrôle et les groupes de traitement dans une seule réponse, ainsi que des données de comparaison statistiques telles que l'impact et les valeurs p. Il s'agit de la seule façon de générer des rapports sur les tests intracampagnes.
• Rapports sur les campagnes : interrogez la ressource campaign pour obtenir des métriques, en utilisant campaign.experiment_type pour distinguer les campagnes de base et les campagnes de test. Cette option n'est disponible que pour les tests qui utilisent des campagnes de contrôle et de traitement distinctes, comme les tests gérés par le système.

Pour les tests standards, ce guide se concentre principalement sur les rapports de test directs, qui sont compatibles avec tous les types de tests qui prennent en charge les rapports. Pour les études de mesure de l'impact, vous pouvez également générer des rapports sur le Brand Lift, le Conversion Lift et le Search Lift à l'aide de ressources de mesure de l'impact dédiées.

Rapports de test directs

Vous pouvez interroger directement la ressource experiment pour récupérer les métriques de performances et les comparaisons statistiques entre vos groupes de contrôle et vos groupes de traitement.

Métriques et pertinence statistique

Pour les métriques de base telles que les clics, les impressions, le coût, les conversions et la valeur de conversion, la ressource experiment fournit à la fois des métriques de traitement (par exemple, metrics.clicks) et des métriques de contrôle (par exemple, metrics.control_clicks) sur la même ligne.

Elle fournit également des champs pour vous aider à évaluer la pertinence statistique de toute différence entre les groupes :

• metrics.*_p_value: probabilité que les résultats observés se produisent si le test n'avait aucun effet réel sur la métrique. Une valeur p plus faible indique une pertinence statistique plus élevée.
• metrics.*_point_estimate: impact estimé en pourcentage (positif ou négatif) de la métrique donnée pour le groupe de traitement par rapport au groupe de contrôle. Avec margin_of_error, ils décrivent un intervalle de confiance avec un niveau de confiance prescrit pour la différence estimée. La quantité estimée est (traitement / contrôle - 1). L'estimation ponctuelle est le centre de l'intervalle de confiance.
• metrics.*_margin_of_error: rayon de l'intervalle de confiance, centré sur point_estimate. Il est calculé pour un niveau de confiance prescrit, qui dépend du type de test.

Les champs de métriques de base suivants sont compatibles avec la ressource experiment, y compris une valeur de groupe de traitement, une valeur de groupe de contrôle et les champs de statistiques listés précédemment :

• clicks
• impressions
• cost_micros
• conversions
• cost_per_conversion
• conversion_value
• conversion_value_per_cost

Pour les conversions, en particulier, les champs statistiques sont disponibles via les champs absolute_change suivants, plutôt que sous forme de valeurs relatives :

• metrics.conversions_absolute_change_p_value: valeur p de l'hypothèse nulle selon laquelle le test n'a aucun effet sur la variation absolue des conversions. Plage de 0 à 1.
• metrics.conversions_absolute_change_point_estimate: estimation ponctuelle lors de l'estimation de l'effet du test sur la variation absolue des conversions.
• metrics.conversions_absolute_change_margin_of_error: marge d'erreur lors de l'estimation de l'effet du test sur la variation absolue des conversions.

Pour obtenir de l'aide sur la création de requêtes valides pour la ressource experiment, utilisez l' outil de création de requêtes Google Ads.

Exemple de requête

La requête GAQL suivante récupère les métriques clés d'un test :

SELECT
  experiment.experiment_id,
  experiment.name,
  experiment.type,
  metrics.clicks,
  metrics.control_clicks,
  metrics.clicks_point_estimate,
  metrics.clicks_margin_of_error,
  metrics.clicks_p_value,
  metrics.conversions,
  metrics.control_conversions,
  metrics.conversions_absolute_change_point_estimate,
  metrics.conversions_absolute_change_margin_of_error,
  metrics.conversions_absolute_change_p_value
FROM experiment
WHERE experiment.experiment_id = EXPERIMENT_ID

Interpréter les résultats

Vous pouvez utiliser les champs de valeur p, d'estimation ponctuelle et de marge d'erreur pour déterminer si votre test a généré des résultats statistiquement significatifs. Par exemple, si conversions_absolute_change_p_value est inférieur au seuil que vous avez choisi (par exemple, 0.05 pour une confiance de 95 %) et que conversions_absolute_change_point_estimate - conversions_absolute_change_margin_of_error est supérieur à zéro, le groupe de traitement est nettement plus performant que le groupe de contrôle en termes de conversions.

Voici un extrait de code Python qui montre comment évaluer les résultats en fonction de la valeur p et des estimations de l'impact :

private void evaluateExperiment(
    GoogleAdsClient googleAdsClient, long customerId, GoogleAdsRow row) {
  Metrics metrics = row.getMetrics();
  String experimentResourceName = row.getExperiment().getResourceName();

  // 1. Evaluate conversion success as a primary success signal if available.
  // - Point Estimate: Represents the estimated average lift or difference in conversions.
  // - Margin of Error: Outlines the confidence interval bounds. Note that the margin_of_error
  //   provided by the API is calculated for a preset confidence level which is set based on the
  //   experiment type.
  // - Lower Bound: (Point Estimate - Margin of Error). If this value is above 0,
  //   we have statistical significance that performance has improved.
  double convPValue = metrics.getConversionsAbsoluteChangePValue();
  double convLift = metrics.getConversionsAbsoluteChangePointEstimate();
  double convError = metrics.getConversionsAbsoluteChangeMarginOfError();
  double convLowerBound = convLift - convError;

  if (convPValue <= P_VALUE_THRESHOLD) {
    if (convLowerBound > 0) {
      System.out.printf(
          "Significant Success: Conversions increased. Even at the lower bound, the lift is %.2f."
              + " Promoting changes.%n",
          convLowerBound);
      promoteExperiment(googleAdsClient, customerId, experimentResourceName);
      return;
    } else if ((convLift + convError) < 0) {
      System.out.printf(
          "Significant Decline: Even the upper bound (%.2f) is below zero. Ending experiment.%n",
          convLift + convError);
      endExperiment(googleAdsClient, customerId, experimentResourceName);
      return;
    }
  }

  // 2. Fall back to evaluating click metrics if conversions are inconclusive.
  double clickPValue = metrics.getClicksPValue();
  double clickLift = metrics.getClicksPointEstimate();
  double clickError = metrics.getClicksMarginOfError();
  double clickLowerBound = clickLift - clickError;

  if (clickPValue <= P_VALUE_THRESHOLD && clickLowerBound > 0) {
    System.out.printf("Click volume is significantly up (+%.1f%%).%n", clickLift * 100);

    // Graduation is only supported for separate campaign experiments, not
    // intra-campaign experiments where there is no separate treatment campaign.
    ExperimentType experimentType = row.getExperiment().getType();
    if (experimentType != ExperimentType.ADOPT_BROAD_MATCH_KEYWORDS
        && experimentType != ExperimentType.ADOPT_AI_MAX) {
      System.out.println("Graduating treatment campaign for further manual analysis.");
      graduateExperiment(googleAdsClient, customerId, experimentResourceName);
    } else {
      System.out.println(
          "Intra-campaign trial detected: graduation is not supported. Continuing to run the"
              + " experiment to gather more conversion data.");
    }
  } else {
    // 3. Print status if no action was taken.
    System.out.printf(
        "Inconclusive: No significant lift in Conversions (p=%.2f) or Clicks (p=%.2f). Current"
            + " estimated lift: %.2f +/- %.2f. Allowing the experiment to continue running.%n",
        convPValue, clickPValue, convLift, convError);
  }
}
EvaluateAndUpdateExperiment.java
      

private static void EvaluateExperiment(GoogleAdsClient client, long customerId, GoogleAdsRow row)
{
    // This function evaluates performance metrics and immediately takes action
    // to update the experiment's status (promote, end, or graduate) if
    // statistical significance thresholds are met.
    var metrics = row.Metrics;
    string experimentResourceName = row.Experiment.ResourceName;

    bool hasConvMetrics = metrics.HasConversionsAbsoluteChangePValue
        && metrics.HasConversionsAbsoluteChangePointEstimate
        && metrics.HasConversionsAbsoluteChangeMarginOfError;

    bool hasClickMetrics = metrics.HasClicksPValue
        && metrics.HasClicksPointEstimate
        && metrics.HasClicksMarginOfError;

    // 1. Evaluate conversion success as a primary success signal if available.
    // - Point Estimate: Represents the estimated average lift or difference in conversions.
    // - Margin of Error: Outlines the confidence interval bounds. Note that the margin_of_error
    //   provided by the API is calculated for a preset confidence level which is set based on
    //   the experiment type.
    // - Lower Bound: (Point Estimate - Margin of Error). If this value is above 0,
    //   we have statistical significance that performance has improved.
    if (hasConvMetrics)
    {
        double convPValue = metrics.ConversionsAbsoluteChangePValue;
        double convLift = metrics.ConversionsAbsoluteChangePointEstimate;
        double convError = metrics.ConversionsAbsoluteChangeMarginOfError;
        double convLowerBound = convLift - convError;

        if (convPValue <= P_VALUE_THRESHOLD)
        {
            if (convLowerBound > 0)
            {
                Console.WriteLine(
                    $"Significant Success: Conversions increased. Even at the lower" +
                    $" bound, the lift is {convLowerBound:F2}. Promoting changes.");
                PromoteExperiment(client, customerId, experimentResourceName);
                return;
            }
            else if ((convLift + convError) < 0)
            {
                Console.WriteLine(
                    $"Significant Decline: Even the upper bound ({convLift + convError:F2}) " +
                    $"is below zero. Ending experiment.");
                EndExperiment(client, customerId, experimentResourceName);
                return;
            }
        }
    }

    // 2. Evaluate click volume as a secondary signal.
    // This is helpful as an early indicator or for lower-volume accounts.
    if (hasClickMetrics)
    {
        double clickPValue = metrics.ClicksPValue;
        double clickLift = metrics.ClicksPointEstimate;
        double clickError = metrics.ClicksMarginOfError;
        double clickLowerBound = clickLift - clickError;

        if (clickPValue <= P_VALUE_THRESHOLD && clickLowerBound > 0)
        {
            // We have a directional winner: high confidence in more traffic,
            // but not enough data to confirm conversion impact yet.
            Console.WriteLine(
                $"Click volume is significantly up (+{clickLift * 100:F1}%).");

            // Graduation is only supported for separate campaign experiments, not
            // intra-campaign experiments where there is no separate treatment campaign.
            if (row.Experiment.Type != ExperimentType.AdoptBroadMatchKeywords
                && row.Experiment.Type != ExperimentType.AdoptAiMax)
            {
                Console.WriteLine("Graduating treatment campaign for further manual analysis.");
                GraduateExperiment(client, customerId, experimentResourceName);
            }
            else
            {
                Console.WriteLine(
                    "Intra-campaign trial detected: graduation is not supported. " +
                    "Continuing to run the experiment to gather more conversion data.");
            }
            return;
        }
    }

    // 3. Print status if no action was taken.
    if (hasConvMetrics || hasClickMetrics)
    {
        string convStatus = hasConvMetrics
            ? $"Conversions (p={metrics.ConversionsAbsoluteChangePValue:F2}, " +
              $"lift={metrics.ConversionsAbsoluteChangePointEstimate:F2} +/- " +
              $"{metrics.ConversionsAbsoluteChangeMarginOfError:F2})"
            : "Conversions (not populated)";

        string clickStatus = hasClickMetrics
            ? $"Clicks (p={metrics.ClicksPValue:F2}, " +
              $"lift={metrics.ClicksPointEstimate:F2} +/- " +
              $"{metrics.ClicksMarginOfError:F2})"
            : "Clicks (not populated)";

        Console.WriteLine(
            $"Inconclusive: No significant action taken. {convStatus}, {clickStatus}. " +
            "Allowing the experiment to continue running.");
    }
    else
    {
        Console.WriteLine(
            "Conversion and click performance metrics are not yet populated. " +
            "Allowing the experiment to continue running.");
    }
}
EvaluateAndUpdateExperiment.cs
      

This example is not yet available in PHP; you can take a look at the other languages.
    

def evaluate_experiment(
    client: GoogleAdsClient, customer_id: str, row: GoogleAdsRow
) -> None:
    """Evaluates the performance of the experiment and updates it accordingly
    (for example, promotes, ends, or graduates).

    Checks conversion and click metrics against statistical significance thresholds
    to determine the appropriate action to take on the experiment.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        row: a GoogleAdsRow containing the experiment and metrics.
    """
    # This function evaluates performance metrics and immediately takes action
    # to update the experiment's status (promote, end, or graduate) if
    # statistical significance thresholds are met.
    metrics = row.metrics
    experiment_resource_name = row.experiment.resource_name

    has_conv_metrics = (
        "conversions_absolute_change_p_value" in metrics
        and "conversions_absolute_change_point_estimate" in metrics
        and "conversions_absolute_change_margin_of_error" in metrics
    )
    has_click_metrics = (
        "clicks_p_value" in metrics
        and "clicks_point_estimate" in metrics
        and "clicks_margin_of_error" in metrics
    )

    # 1. Evaluate conversion success as a primary success signal if available.
    # - Point Estimate: Represents the estimated average lift or difference in conversions.
    # - Margin of Error: Outlines the confidence interval bounds. Note that the margin_of_error provided by the API is calculated for a preset confidence level which is set based on the experiment type.
    # - Lower Bound: (Point Estimate - Margin of Error). If this value is above 0,
    #   we have statistical significance that performance has improved.
    if has_conv_metrics:
        conv_p_value = metrics.conversions_absolute_change_p_value
        conv_lift = metrics.conversions_absolute_change_point_estimate
        conv_error = metrics.conversions_absolute_change_margin_of_error
        conv_lower_bound = conv_lift - conv_error

        if conv_p_value <= P_VALUE_THRESHOLD:
            if conv_lower_bound > 0:
                print(
                    "Significant Success: Conversions increased. Even at the lower"
                    f" bound, the lift is {conv_lower_bound:.2f}. Promoting"
                    " changes."
                )
                promote_experiment(
                    client, customer_id, experiment_resource_name
                )
                return
            elif (conv_lift + conv_error) < 0:
                print(
                    "Significant Decline: Even the upper bound"
                    f" ({conv_lift + conv_error:.2f}) is below zero. Ending"
                    " experiment."
                )
                end_experiment(client, customer_id, experiment_resource_name)
                return

        # 2. Evaluate click volume as a secondary signal.
        # This is helpful as an early indicator or for lower-volume accounts.
        click_p_value = metrics.clicks_p_value
        click_lift = metrics.clicks_point_estimate
        click_error = metrics.clicks_margin_of_error
        click_lower_bound = click_lift - click_error

        if click_p_value <= P_VALUE_THRESHOLD and click_lower_bound > 0:
            # We have a directional winner: high confidence in more traffic,
            # but not enough data to confirm conversion impact yet.
            print(f"Click volume is significantly up (+{click_lift*100:.1f}%).")

            # Graduation is only supported for separate campaign experiments, not
            # intra-campaign experiments where there is no separate treatment campaign.
            experiment_type_name = row.experiment.type_.name
            if (
                experiment_type_name != "ADOPT_BROAD_MATCH_KEYWORDS"
                and experiment_type_name != "ADOPT_AI_MAX"
            ):
                print(
                    "Graduating treatment campaign for further manual analysis."
                )
                graduate_experiment(
                    client, customer_id, experiment_resource_name
                )
            else:
                print(
                    "Intra-campaign trial detected: graduation is not supported. "
                    "Continuing to run the experiment to gather more conversion data."
                )
            return

    # 3. Print status if no action was taken.
    if has_conv_metrics or has_click_metrics:
        conv_status = (
            f"Conversions (p={metrics.conversions_absolute_change_p_value:.2f}, "
            f"lift={metrics.conversions_absolute_change_point_estimate:.2f} +/- "
            f"{metrics.conversions_absolute_change_margin_of_error:.2f})"
            if has_conv_metrics
            else "Conversions (not populated)"
        )
        click_status = (
            f"Clicks (p={metrics.clicks_p_value:.2f}, "
            f"lift={metrics.clicks_point_estimate:.2f} +/- "
            f"{metrics.clicks_margin_of_error:.2f})"
            if has_click_metrics
            else "Clicks (not populated)"
        )
        print(
            f"Inconclusive: No significant action taken. {conv_status}, {click_status}."
            " Allowing the experiment to continue running."
        )
    else:
        print(
            "Conversion and click performance metrics are not yet populated. "
            "Allowing the experiment to continue running."
        )
evaluate_and_update_experiment.py
      

This example is not yet available in Ruby; you can take a look at the other languages.
    

This example is not yet available in Perl; you can take a look at the other languages.
    

Avantages par rapport aux rapports sur les campagnes

Les rapports de test directs offrent plusieurs avantages par rapport à l'interrogation des rapports sur les campagnes séparément :

1. Métriques centralisées : récupérez les métriques pour le contrôle et le traitement sur une seule ligne.
2. Données de confiance statistiques : fournit des valeurs p, des estimations ponctuelles et des marges d'erreur calculées.
3. Efficacité : élimine la nécessité de joindre ou de comparer manuellement les résultats de plusieurs rapports.
4. Compatibilité intracampagne : il s'agit de la seule façon de comparer le contrôle et le traitement pour les tests intracampagnes, où le trafic est réparti au sein d'une seule campagne.

Rapports sur les campagnes

Pour les tests qui créent des campagnes de traitement distinctes (par exemple, SEARCH_CUSTOM), vous pouvez interroger la ressource campaign et utiliser campaign.experiment_type pour identifier les campagnes BASE (contrôle) et EXPERIMENT (traitement). Cette approche est utile si vous devez segmenter les métriques à un niveau plus précis (par exemple, par groupe d'annonces ou par mot clé) ou afficher des métadonnées de campagne non disponibles sur la ressource experiment. Toutefois, vous devez effectuer manuellement des comparaisons de performances et des calculs statistiques.

Vous ne pouvez pas utiliser les rapports au niveau de la campagne pour comparer les groupes pour les tests intracampagnes, car la répartition du trafic s'effectue en interne au sein d'une seule campagne. L'interrogation de campaign pour un test intracampagne ne renvoie que des totaux agrégés.

Rapports sur le brand lift

Vous pouvez générer des rapports sur les études de brand lift dans l'API Google Ads à l'aide de ressources de mesure du brand lift dédiées.

Ressources de brand lift et vues de répartition

Interrogez la ressource LiftMeasurementFlight pour récupérer les résultats de l'étude de brand lift au niveau du vol, y compris les plages de dates du vol (start_date et end_date) dans le fuseau horaire du client.

Pour analyser les métriques de brand lift sur différentes dimensions de segment, interrogez les ressources de répartition correspondantes :

• LiftMeasurementCampaign: répartition par campagne.
• LiftMeasurementAgeRange: répartition par tranche d'âge.
• LiftMeasurementDevice: répartition par appareil.
• LiftMeasurementGender: répartition par genre.
• LiftMeasurementVideo: répartition par composant vidéo.

L'enum BrandLiftMeasurementType spécifie le type de mesure de l'étude, tel que la notoriété de la marque ou le souvenir publicitaire.

Exemples de requêtes de brand lift

Étant donné que les métadonnées de vol et les statistiques d'impact résident sur des ressources distinctes, l'interrogation des détails du vol et des statistiques de performances nécessite des requêtes GAQL distinctes.

Requête de détails du vol

Pour récupérer les métadonnées d'un vol de brand lift, telles que son état, son type de mesure et ses dates planifiées, interrogez la LiftMeasurementFlightressource :

SELECT
  lift_measurement_flight.lift_measurement_config_id,
  lift_measurement_flight.lift_measurement_flight_id,
  lift_measurement_flight.name,
  lift_measurement_flight.status,
  lift_measurement_flight.lift_type,
  lift_measurement_flight.start_date,
  lift_measurement_flight.end_date
FROM lift_measurement_flight
WHERE lift_measurement_flight.lift_measurement_config_id = CONFIG_ID

Requête de statistiques

Pour récupérer les métriques de brand lift, interrogez la ressource de répartition appropriée (ou la configuration d'étude globale sur LiftMeasurementConfig). Par exemple, la requête suivante récupère les métriques de brand lift réparties par campagne à partir de LiftMeasurementCampaign :

SELECT
  lift_measurement_campaign.lift_measurement_config_id,
  lift_measurement_campaign.campaign,
  metrics.absolute_brand_lift,
  metrics.relative_brand_lift
FROM lift_measurement_campaign
WHERE lift_measurement_campaign.lift_measurement_config_id = CONFIG_ID

Rapports sur le conversion lift

Vous pouvez mesurer l'impact incrémental de vos annonces sur les conversions à l'aide des rapports sur le conversion lift dans l'API Google Ads.

Configuration et métriques du conversion lift

Interrogez la ressource LiftMeasurementConfig pour récupérer les configurations d'étude sur le conversion lift et les données sur les performances.

La ressource fournit des métriques de conversion lift pour évaluer les performances incrémentales :

• metrics.conversion_lift_baseline_conversions: conversions de référence pour l'étude.
• metrics.conversion_lift_exposed_conversions: conversions observées dans le groupe exposé.
• metrics.incremental_conversions: conversions incrémentales attribuées aux annonces.
• metrics.cost_per_incremental_conversion: coût par conversion incrémentale.
• metrics.relative_conversion_lift: impact relatif sur les conversions.
• metrics.conversion_lift_baseline_conversion_value: valeur de conversion de référence.
• metrics.conversion_lift_exposed_conversion_value: valeur de conversion dans le groupe exposé.
• metrics.incremental_conversion_value: valeur de conversion incrémentale attribuée aux annonces.
• metrics.relative_conversion_value_lift: impact relatif sur la valeur de conversion.

Les rapports sur le conversion lift permettent également de segmenter par actions de conversion et de récupérer les détails des campagnes associées, les détails des tests et les objectifs de conversion.

Exemple de requête de conversion lift

La requête GAQL suivante récupère les configurations de conversion lift et les métriques de performances clés. Notez que segments.conversion_lift_start_date et segments.conversion_lift_end_date sont des champs INT64 au format d'entiers à huit chiffres sans guillemets au format YYYYMMDD (par exemple, 20260501) :

SELECT
  lift_measurement_config.lift_measurement_config_id,
  segments.conversion_lift_start_date,
  segments.conversion_lift_end_date,
  segments.conversion_lift_included_conversion_action_types,
  metrics.conversion_lift_baseline_conversions,
  metrics.conversion_lift_exposed_conversions,
  metrics.incremental_conversions,
  metrics.cost_per_incremental_conversion,
  metrics.relative_conversion_lift,
  metrics.incremental_conversion_value,
  metrics.relative_conversion_value_lift
FROM lift_measurement_config
WHERE segments.conversion_lift_start_date = YYYYMMDD
  AND segments.conversion_lift_end_date = YYYYMMDD
  AND lift_measurement_config.lift_measurement_config_id = CONFIG_ID

Rapports sur le search lift

Vous pouvez mesurer l'augmentation du volume de requêtes de recherche naturelles généré par vos campagnes publicitaires à l'aide des rapports sur le search lift dans l'API Google Ads. Le search lift quantifie la différence de comportement de recherche pour votre marque ou vos produits entre les utilisateurs exposés à vos annonces et un groupe de contrôle non exposé.

Ressources de search lift et segmentation

Interrogez la ressource SearchLiftKeywordBundle pour récupérer des informations sur les groupes de mots clés configurés pour les études de search lift. SearchLiftKeywordBundle est en lecture seule dans l'API (tous les champs sont OUTPUT_ONLY), et les groupes de mots clés sont configurés dans l'interface utilisateur Google Ads ou par des représentants Google / Global Product Solutions (GPS). Les champs interrogeables dans GAQL sont resource_name, search_lift_keyword_bundle_id, source (SearchLiftMatchingInfoSource) et status (SearchLiftKeywordBundleStatus) (le champ keywords répété n'est pas sélectionnable dans les requêtes GAQL).

Interrogez la ressource LiftMeasurementConfig pour récupérer les métriques de search lift et les configurations d'étude globales.

Vous pouvez segmenter les performances du search lift à l'aide des dimensions suivantes :

• segments.search_lift_keyword_bundle: segmenter par nom de ressource du groupe de mots clés. Compatible avec segments.search_property, segments.date et les segments démographiques (segments.device, segments.age_range et segments.gender).
• segments.search_property : segmenter par propriété de recherche où la recherche a eu lieu, définie par SearchLiftSearchProperty (par exemple, la recherche Google ou YouTube). Notez que segments.search_property n'est compatible qu'avec segments.search_lift_keyword_bundle et segments.date. La combinaison de segments.search_property avec des segments démographiques (segments.device, segments.age_range ou segments.gender) n'est pas prise en charge et échoue à la validation des requêtes API.
• Segments démographiques et de date : segments.device, segments.age_range, segments.gender, et segments.date.

Métriques search lift

La ressource LiftMeasurementConfig fournit des métriques de search lift pour évaluer les changements de comportement de recherche :

• metrics.relative_search_lift: différence de volume de requêtes de recherche entre les groupes exposé et de contrôle, exprimée en fraction des requêtes de recherche du groupe de contrôle.
• metrics.relative_search_lift_p90_lower_bound et metrics.relative_search_lift_p90_upper_bound: limites inférieure et supérieure de l'intervalle de confiance à 90% pour le search lift relatif.
• metrics.incremental_searches_p_value: valeur p pour les recherches incrémentales, représentant la probabilité statistique que l'augmentation observée des requêtes de recherche se soit produite par hasard.
• metrics.search_lift_cost_micros: coût total (en micros) des impressions d'annonces diffusées pour cette tranche de mesure du search lift.
• metrics.search_lift_impressions: nombre total d'impressions d'annonces diffusées pour cette tranche de mesure du search lift.

Les métriques incrémentales normalisées suivantes, ainsi que les limites inférieure et supérieure de leur intervalle de confiance à 90 % (*_p90_lower_bound et *_p90_upper_bound), sont signalées lorsque l'impact est statistiquement positif :

• metrics.normalized_incremental_searches (avec metrics.normalized_incremental_searches_p90_lower_bound et metrics.normalized_incremental_searches_p90_upper_bound) : nombre estimé de requêtes de recherche incrémentales générées par l'exposition aux annonces, normalisé entre les groupes exposé et de contrôle.
• metrics.normalized_incremental_searches_per_cost (avec metrics.normalized_incremental_searches_per_cost_p90_lower_bound et metrics.normalized_incremental_searches_per_cost_p90_upper_bound) : nombre estimé de requêtes de recherche incrémentales générées par unité de dépenses publicitaires.
• metrics.normalized_incremental_searches_per_impression (avec metrics.normalized_incremental_searches_per_impression_p90_lower_bound et metrics.normalized_incremental_searches_per_impression_p90_upper_bound): nombre estimé de requêtes de recherche incrémentales générées par impression d'annonce.

Exemples de requêtes de search lift

Les requêtes GAQL suivantes montrent comment récupérer les groupes de mots clés et les métriques de performances du search lift.

Requête de groupe de mots clés

Pour récupérer les groupes de mots clés configurés pour les mesures de search lift :

SELECT
  search_lift_keyword_bundle.resource_name,
  search_lift_keyword_bundle.search_lift_keyword_bundle_id,
  search_lift_keyword_bundle.source,
  search_lift_keyword_bundle.status
FROM search_lift_keyword_bundle

Requête de métriques

Les valeurs search_lift_keyword_bundle.resource_name récupérées dans la requête de groupe de mots clés correspondent aux valeurs renvoyées dans segments.search_lift_keyword_bundle dans la requête suivante. Pour découvrir le CONFIG_ID de votre étude, interrogez lift_measurement_config (par exemple, SELECT lift_measurement_config.lift_measurement_config_id, lift_measurement_config.name FROM lift_measurement_config).

Pour récupérer les métriques de search lift segmentées par groupe de mots clés et par propriété de recherche :

SELECT
  lift_measurement_config.lift_measurement_config_id,
  segments.search_lift_keyword_bundle,
  segments.search_property,
  metrics.relative_search_lift,
  metrics.relative_search_lift_p90_lower_bound,
  metrics.relative_search_lift_p90_upper_bound,
  metrics.incremental_searches_p_value,
  metrics.search_lift_cost_micros,
  metrics.search_lift_impressions,
  metrics.normalized_incremental_searches,
  metrics.normalized_incremental_searches_p90_lower_bound,
  metrics.normalized_incremental_searches_p90_upper_bound
FROM lift_measurement_config
WHERE lift_measurement_config.lift_measurement_config_id = CONFIG_ID

Bonnes pratiques

Les bonnes pratiques suivantes s'appliquent aux tests A/B standards (tels que les tests sur les campagnes et les tests intracampagnes). Les études de mesure de l'impact (brand lift, conversion lift et search lift) utilisent des configurations spécifiques à l'étude et signalent des intervalles de confiance à 90 % (*_p90_lower_bound et *_p90_upper_bound) plutôt qu'un seuil de confiance à 95 %.

• Sélectionnez un niveau de confiance approprié : la définition d'un seuil de valeur p plus faible peut fournir plus rapidement des conseils directionnels, en particulier avec des budgets ou des volumes de conversion plus faibles. Une confiance de 95 % (valeur p <= 0,05) est considérée comme la norme académique et peut être préférable pour obtenir des résultats plus précis sur une période plus longue.
• Exécutez les tests suffisamment longtemps : exécutez les tests pendant au moins quatre semaines pour tenir compte des cycles de performances hebdomadaires, des délais de conversion et des périodes d'apprentissage.
• Laissez le temps de la montée en puissance : pour les campagnes qui utilisent des enchères automatiques ou qui testent de nouvelles fonctionnalités, ignorez les données des une à deux premières semaines pour laisser le temps aux modèles d'enchères et aux niveaux de trafic de se recalibrer sur la répartition.
• Utilisez des répartitions à 50/50 : une répartition du trafic à 50/50 est généralement le moyen le plus rapide d' obtenir des résultats statistiquement significatifs.
• Planifiez à l'avance : définissez la date de début de votre test trois à sept jours à l' avance pour laisser le temps aux processus d'examen et d'approbation des annonces.