Rapports sur les tests

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

• Rapports directs sur les tests : interrogez la ressource experiment pour obtenir des métriques. Cette option fournit des métriques pour les bras de contrôle et de traitement dans une même réponse, ainsi que des données de comparaison statistique telles que l'amélioration et les valeurs p. Il s'agit du seul moyen 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 faire la distinction entre les campagnes de base et les campagnes tests. 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.

Ce guide se concentre principalement sur les rapports de tests directs, qui sont compatibles avec tous les types de tests qui prennent en charge les rapports.

Rapports directs sur les tests

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

Métriques et pertinence statistique

Pour les métriques principales 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.

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

• metrics.*_p_value : probabilité que les résultats observés se produisent si le test n'a eu aucun effet réel sur la métrique. Plus la valeur p est faible, plus la pertinence statistique est élevée.
• metrics.*_point_estimate : estimation du pourcentage de lift (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. Elle est calculée pour un niveau de confiance prédéfini, qui dépend du type de test.

Les champs de métriques clés suivants sont acceptés dans 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, les champs statistiques sont disponibles dans les champs absolute_change suivants, et non sous forme de valeurs relatives :

• metrics.conversions_absolute_change_p_value : valeur p pour l'hypothèse nulle selon laquelle le test n'a aucun effet sur la variation absolue des conversions. Les valeurs vont 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 afin de créer des requêtes valides pour la ressource experiment, utilisez l'outil Générateur 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 "Valeur p", "Estimation ponctuelle" et "Marge d'erreur" pour déterminer si votre test a généré des résultats statistiquement pertinents. Par exemple, si conversions_absolute_change_p_value est inférieur au seuil 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, cela indique que le groupe de traitement est nettement plus performant que le groupe de contrôle en termes de conversions.

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

Java

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
      

C#

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
      

PHP

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

Python

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
      

Ruby

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

Perl

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

curl

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni pour cette étape, vous pouvez y parvenir à l'aide d'une requête REST manuelle.

Consultez la documentation de l'interface REST de l'API Google Ads et les pages de référence spécifiques aux méthodes. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Ressources clés :

• Utiliser REST
• Structure de l'interface REST
• Mappages des champs JSON
• Consultez la documentation de référence de l'API REST pour le service et la méthode spécifiques.

Avantages par rapport aux rapports sur les campagnes

La création de rapports de tests directs offre plusieurs avantages par rapport à l'interrogation séparée des rapports de campagne :

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 fiabilité statistique : fournit les valeurs p, les estimations ponctuelles et les marges d'erreur calculées.
3. Efficacité : vous n'avez plus besoin de joindre ni de comparer manuellement les résultats de plusieurs rapports.
4. Compatibilité avec les tests intracampagne : c'est le seul moyen de comparer le groupe de contrôle au groupe de traitement pour les tests intracampagne, où le trafic est réparti au sein d'une même campagne.

Création de 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 les métadonnées de campagne qui ne sont pas disponibles dans la ressource experiment. Toutefois, vous devez effectuer manuellement les comparaisons de performances et les calculs statistiques.

Vous ne pouvez pas utiliser les rapports au niveau de la campagne pour comparer les bras des tests intracampagne, car la répartition du trafic se fait en interne au sein d'une même campagne. Si vous interrogez campaign pour un test intracampagne, seuls les totaux agrégés seront renvoyés.

Bonnes pratiques

• Sélectionnez un niveau de confiance approprié : définir un seuil de valeur p plus faible peut fournir des indications directionnelles plus rapidement, en particulier avec des budgets ou des volumes de conversions plus faibles. Un niveau de confiance de 95 % (valeur p <= 0,05) est considéré comme la norme académique et peut être plus adapté 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 à la campagne de s'adapter : pour les campagnes utilisant les enchères automatiques ou testant de nouvelles fonctionnalités, ignorez les données des une à deux premières semaines. Cela permettra aux modèles d'enchères et aux niveaux de trafic de se réadapter à la répartition.
• Utilisez une répartition à 50/50 : une répartition du trafic à 50/50 est généralement le moyen le plus rapide d'obtenir des résultats statistiquement pertinents.
• 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.
• Vous ne pouvez effectuer qu'un seul test par campagne à la fois.