Report sugli esperimenti

Esistono due modi principali per generare report sugli esperimenti A/B standard:

• Report sugli esperimenti diretti: esegui una query sulla risorsa experiment per ottenere le metriche. Questa opzione fornisce le metriche per i gruppi di controllo e sperimentali in un'unica risposta, insieme ai dati di confronto statistico, come l'incremento e i valori p. Questo è l'unico modo per generare report sugli esperimenti all'interno della campagna.
• Report sulle campagne: esegui una query sulla risorsa campaign per ottenere le metriche, utilizzando campaign.experiment_type per distinguere tra campagne di base e campagne sperimentali. Questa opzione è disponibile solo per gli esperimenti che utilizzano campagne di controllo e sperimentali separate, ad esempio gli esperimenti gestiti dal sistema.

Per gli esperimenti standard, questa guida si concentra principalmente sui report sugli esperimenti diretti, che sono compatibili con tutti i tipi di esperimenti che supportano i report. Per gli studi di misurazione del lift, puoi anche generare report sul brand lift, sul conversion lift e sul search lift utilizzando risorse di misurazione del lift dedicate.

Report sugli esperimenti diretti

Puoi eseguire query direttamente sulla risorsa experiment per recuperare le metriche sul rendimento e i confronti statistici tra i gruppi di controllo e sperimentale.

Metriche e significatività statistica

Per le metriche principali, come clic, impressioni, costo, conversioni e valore di conversione, la risorsa experiment fornisce sia le metriche del gruppo sperimentale (ad es. metrics.clicks) sia quelle del gruppo di controllo (ad es. metrics.control_clicks) nella stessa riga.

Inoltre, fornisce campi che ti aiutano a valutare la significatività statistica di qualsiasi differenza tra i gruppi:

• metrics.*_p_value: la probabilità che i risultati osservati si verifichino se l'esperimento non ha avuto alcun effetto effettivo sulla metrica. Un valore p più basso indica una significatività statistica più elevata.
• metrics.*_point_estimate: l'incremento percentuale stimato (positivo o negativo) nella metrica specificata per il gruppo sperimentale rispetto al gruppo di controllo. Insieme a margin_of_error, descrivono un intervallo di affidabilità con un livello di confidenza prescritto per la differenza stimata. La quantità stimata è (gruppo sperimentale / gruppo di controllo - 1). La stima puntuale è il centro dell'intervallo di affidabilità.
• metrics.*_margin_of_error: il raggio dell'intervallo di affidabilità, centrato su point_estimate. Viene calcolato per un livello di confidenza prescritto, che dipende dal tipo di esperimento.

I seguenti campi delle metriche principali sono supportati nella risorsa experiment, tra cui un valore del gruppo sperimentale, un valore del gruppo di controllo e i campi delle statistiche elencati in precedenza:

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

Per le conversioni, in particolare, i campi statistici sono disponibili tramite i seguenti campi absolute_change, anziché come valori relativi:

• metrics.conversions_absolute_change_p_value: il valore p per l'ipotesi nulla che l'esperimento non abbia alcun effetto sulla variazione assoluta delle conversioni. Intervalli da 0 a 1.
• metrics.conversions_absolute_change_point_estimate: la stima puntuale quando si stima l'effetto dell'esperimento sulla variazione assoluta delle conversioni.
• metrics.conversions_absolute_change_margin_of_error: il margine di errore durante la stima dell'effetto dell'esperimento sulla variazione assoluta delle conversioni.

Per assistenza nella creazione di query valide per la risorsa experiment, utilizza lo strumento Google Ads Query Builder.

Query di esempio

La seguente query GAQL recupera le metriche chiave per un esperimento:

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

Interpreta i risultati

Puoi utilizzare i campi Valore p, Stima puntuale e Margine di errore per determinare se l'esperimento ha prodotto risultati statisticamente significativi. Ad esempio, se conversions_absolute_change_p_value è inferiore alla soglia scelta (ad esempio 0.05 per una confidenza del 95%) e conversions_absolute_change_point_estimate - conversions_absolute_change_margin_of_error è maggiore di zero, il gruppo sperimentale ha un rendimento significativamente migliore rispetto al gruppo di controllo in termini di conversioni.

Ecco uno snippet Python che mostra come valutare i risultati in base al p-value e alle stime del lift:

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

def evaluate_experiment(client, customer_id, 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.
  metrics = row.metrics
  experiment_resource_name = row.experiment.resource_name

  has_conv_metrics = !metrics.nil? &&
                     metrics.has_conversions_absolute_change_p_value? &&
                     metrics.has_conversions_absolute_change_point_estimate? &&
                     metrics.has_conversions_absolute_change_margin_of_error?
  has_click_metrics = !metrics.nil? &&
                      metrics.has_clicks_p_value? &&
                      metrics.has_clicks_point_estimate? &&
                      metrics.has_clicks_margin_of_error?

  # 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
        puts sprintf(
          "Significant Success: Conversions increased. Even at the lower " \
          "bound, the lift is %.2f. Promoting changes.",
          conv_lower_bound,
        )
        promote_experiment(client, customer_id, experiment_resource_name)
        return
      elsif (conv_lift + conv_error) < 0
        puts sprintf(
          "Significant Decline: Even the upper bound (%.2f) is below zero. " \
          "Ending experiment.",
          conv_lift + conv_error,
        )
        end_experiment(client, customer_id, experiment_resource_name)
        return
      end
    end
  end

  # 2. Evaluate click volume as a secondary signal.
  # This is helpful as an early indicator or for lower-volume accounts.
  if has_click_metrics
    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 && click_lower_bound > 0
      # We have a directional winner: high confidence in more traffic,
      # but not enough data to confirm conversion impact yet.
      puts sprintf("Click volume is significantly up (+%.1f%%).", click_lift * 100)

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

  # 3. Print status if no action was taken.
  if has_conv_metrics || has_click_metrics
    conv_status = if has_conv_metrics
      sprintf(
        "Conversions (p=%.2f, lift=%.2f +/- %.2f)",
        metrics.conversions_absolute_change_p_value,
        metrics.conversions_absolute_change_point_estimate,
        metrics.conversions_absolute_change_margin_of_error,
      )
    else
      "Conversions (not populated)"
    end

    click_status = if has_click_metrics
      sprintf(
        "Clicks (p=%.2f, lift=%.2f +/- %.2f)",
        metrics.clicks_p_value,
        metrics.clicks_point_estimate,
        metrics.clicks_margin_of_error,
      )
    else
      "Clicks (not populated)"
    end

    puts "Inconclusive: No significant action taken. #{conv_status}, #{click_status}. " \
         "Allowing the experiment to continue running."
  else
    puts "Conversion and click performance metrics are not yet populated. " \
         "Allowing the experiment to continue running."
  end
end
evaluate_and_update_experiment.rb
      

Perl

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

curl

Nota: anche se qui non viene fornito un esempio di codice REST diretto per questo passaggio, puoi ottenere questo risultato utilizzando una richiesta REST manuale.

Consulta la documentazione dell'interfaccia REST dell'API Google Ads e le pagine di riferimento specifiche per i metodi. Dovrai creare il payload JSON in base alle definizioni proto.

Risorse principali:

• Utilizzo di REST
• Struttura dell'interfaccia REST
• Mappature dei campi JSON
• Consulta il Riferimento API REST per il servizio e il metodo specifici.

Vantaggi rispetto ai report sulle campagne

I report sugli esperimenti diretti offrono diversi vantaggi rispetto alle query separate sui report sulle campagne:

1. Metriche centralizzate: recupera le metriche per il controllo e il trattamento in una singola riga.
2. Dati di confidenza statistica: fornisce valori p, stime puntuali e margini di errore calcolati.
3. Efficienza: elimina la necessità di unire o confrontare manualmente i risultati di più report.
4. Supporto per gli esperimenti all'interno della campagna: è l'unico modo per confrontare il gruppo di controllo con quello sperimentale per gli esperimenti all'interno della campagna, in cui il traffico viene suddiviso all'interno di una singola campagna.

Generazione di report sulla campagna

Per gli esperimenti che creano campagne sperimentali separate (ad esempio, SEARCH_CUSTOM), puoi eseguire query sulla risorsa campaign e utilizzare campaign.experiment_type per identificare le campagne BASE (di controllo) e EXPERIMENT (sperimentali). Questo approccio è utile se devi segmentare le metriche a un livello più granulare (ad esempio per gruppo di annunci o parola chiave) o visualizzare i metadati della campagna non disponibili nella risorsa experiment. Tuttavia, richiede di eseguire manualmente i confronti del rendimento e i calcoli statistici.

Non puoi utilizzare i report a livello di campagna per confrontare i gruppi per gli esperimenti all'interno della campagna, poiché la suddivisione del traffico avviene internamente all'interno di una singola campagna. Se esegui una query su campaign per un esperimento all'interno della campagna, vengono restituiti solo i totali aggregati.

Report sul brand lift

Puoi generare report sugli studi sul brand lift nell'API Google Ads utilizzando risorse di misurazione del brand lift dedicate.

Nota: l'ID cliente (CID) per cui vuoi eseguire la query deve essere incluso nella lista consentita gestita da Global Product Solutions (GPS). Contatta il tuo rappresentante di Google o il contatto GPS prima di iniziare l'integrazione.

Risorse e visualizzazioni di analisi dettagliata del brand lift

Esegui una query sulla risorsa LiftMeasurementFlight per recuperare i risultati dello studio sul brand lift a livello di periodo di pubblicazione, inclusi gli intervalli di date del periodo di pubblicazione (start_date e end_date) nel fuso orario del cliente.

Per analizzare le metriche del brand lift in base a diverse dimensioni di segmentazione, esegui una query sulle risorse di suddivisione corrispondenti:

• LiftMeasurementCampaign: suddivisione per campagna.
• LiftMeasurementAgeRange: suddivisione per fascia d'età.
• LiftMeasurementDevice: suddivisione per dispositivo.
• LiftMeasurementGender: suddivisione per genere.
• LiftMeasurementVideo: suddivisione per asset video.

L'enum BrandLiftMeasurementType specifica il tipo di misurazione per lo studio, ad esempio la brand awareness o il ricordo dell'annuncio.

Esempi di query sul brand lift

Poiché i metadati dei voli e le statistiche sull'impatto risiedono su risorse separate, per eseguire query sui dettagli dei voli e sulle statistiche sul rendimento sono necessarie query GAQL separate.

Query sui dettagli del volo

Per recuperare i metadati di un periodo di pubblicazione del brand lift, ad esempio lo stato, il tipo di misurazione e le date pianificate, esegui una query sulla risorsa LiftMeasurementFlight:

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

Query sulle statistiche

Per recuperare le metriche di brand lift, esegui una query sulla risorsa di suddivisione appropriata (o sulla configurazione di studio complessiva su LiftMeasurementConfig). Ad esempio, la seguente query recupera le metriche di brand lift suddivise per campagna da 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

Report sul conversion lift

Puoi misurare l'impatto incrementale dei tuoi annunci sulle conversioni utilizzando i report sul conversion lift nell'API Google Ads.

Nota: l'ID cliente (CID) per cui vuoi eseguire la query deve essere incluso nella lista consentita gestita da Global Product Solutions (GPS). Contatta il tuo rappresentante di Google o il contatto GPS prima di iniziare l'integrazione. Inoltre, l'accesso a livello di account amministratore per il conversion lift è in fase di sviluppo.

Configurazione e metriche del conversion lift

Esegui una query sulla risorsa LiftMeasurementConfig per recuperare le configurazioni di studio sul conversion lift e i dati sul rendimento.

La risorsa fornisce metriche sul conversion lift per valutare il rendimento incrementale:

• metrics.conversion_lift_baseline_conversions: conversioni di riferimento per lo studio.
• metrics.conversion_lift_exposed_conversions: conversioni osservate nel gruppo esposto.
• metrics.incremental_conversions: conversioni incrementali attribuite agli annunci.
• metrics.cost_per_incremental_conversion: costo per conversione incrementale.
• metrics.relative_conversion_lift: lift relativo delle conversioni.
• metrics.conversion_lift_baseline_conversion_value: valore di conversione di riferimento.
• metrics.conversion_lift_exposed_conversion_value: valore di conversione nel gruppo esposto.
• metrics.incremental_conversion_value: valore di conversione incrementale attribuito agli annunci.
• metrics.relative_conversion_value_lift: lift relativo del valore di conversione.

I report sul conversion lift consentono anche di segmentare in base alle azioni di conversione e di recuperare i dettagli delle campagne collegate, i dettagli degli esperimenti e gli obiettivi di conversione.

A partire dalla versione v26, puoi scoprire la configurazione della misurazione del lift collegata a una campagna direttamente dalla risorsa campaign utilizzando Campaign.lift_measurement_config. In questo modo, non è necessario fare un controllo incrociato della risorsa LiftMeasurementConfig separatamente:

SELECT
  campaign.id,
  campaign.lift_measurement_config
FROM campaign
WHERE campaign.id = CAMPAIGN_ID

Il campo lift_measurement_config restituito contiene il nome della risorsa nel formato customers/{customer_id}/liftMeasurementConfigs/{lift_measurement_config_id}.

Nota:lift_measurement_config contiene il nome della risorsa della configurazione collegata più di recente (attiva o non attiva) se la campagna ha eseguito più esperimenti sull'impatto.

Esempio di query sul conversion lift

La seguente query GAQL recupera le configurazioni del conversion lift e le metriche sul rendimento principali. Tieni presente che segments.conversion_lift_start_date e segments.conversion_lift_end_date sono campi INT64 formattati come numeri interi di 8 cifre senza virgolette nel formato YYYYMMDD (ad esempio, 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

Report sul search lift

Puoi misurare l'aumento del volume delle query di ricerca organica generato dalle tue campagne pubblicitarie utilizzando i report sul search lift nell'API Google Ads. Il search lift quantifica la differenza nel comportamento di ricerca per il tuo brand o i tuoi prodotti tra gli utenti esposti ai tuoi annunci e un gruppo di controllo non esposto.

Nota: l'ID cliente (CID) per cui vuoi eseguire la query deve essere incluso nella lista consentita gestita da Global Product Solutions (GPS). Contatta il tuo rappresentante di Google o il contatto GPS prima di iniziare l'integrazione.

Risorse e segmentazione del search lift

Esegui una query sulla risorsa SearchLiftKeywordBundle per recuperare i dettagli sui gruppi di parole chiave configurati per gli studi del search lift. SearchLiftKeywordBundle è di sola lettura nell'API (tutti i campi sono OUTPUT_ONLY) e i gruppi di parole chiave vengono configurati nell'interfaccia utente di Google Ads o dai rappresentanti di Google / Global Product Solutions (GPS). I campi disponibili per le query in GAQL sono resource_name, search_lift_keyword_bundle_id, source (SearchLiftMatchingInfoSource) e status (SearchLiftKeywordBundleStatus) (il campo ripetuto keywords non è selezionabile nelle query GAQL).

Esegui una query sulla risorsa LiftMeasurementConfig per recuperare le metriche di search lift e le configurazioni di studio complessive.

Puoi segmentare il rendimento del search lift utilizzando le seguenti dimensioni:

• segments.search_lift_keyword_bundle: segmenta in base al nome della risorsa del gruppo di parole chiave. Compatibile con segments.search_property, segments.date e segmenti demografici (segments.device, segments.age_range e segments.gender).
• segments.search_property: segmenta in base alla proprietà di ricerca in cui è avvenuta la ricerca, definita da SearchLiftSearchProperty (ad esempio Ricerca Google o YouTube). Tieni presente che segments.search_property è compatibile solo con segments.search_lift_keyword_bundle e segments.date; la combinazione di segments.search_property con segmenti demografici (segments.device, segments.age_range o segments.gender) non è supportata e non supera la convalida delle query API.
• Segmenti demografici e di date: segments.device, segments.age_range, segments.gender e segments.date.

Metriche dell'impatto sulle ricerche

La risorsa LiftMeasurementConfig fornisce metriche sul search lift per valutare le variazioni del comportamento di ricerca:

• metrics.relative_search_lift: la differenza nel volume delle query di ricerca tra i gruppi esposti e di controllo, espressa come frazione delle query di ricerca nel gruppo di controllo.
• metrics.relative_search_lift_p90_lower_bound e metrics.relative_search_lift_p90_upper_bound: i limiti inferiore e superiore dell'intervallo di affidabilità del 90% per il search lift relativo.
• metrics.incremental_searches_p_value: il valore p per le ricerche incrementali, che rappresenta la probabilità statistica che l'aumento osservato delle query di ricerca si sia verificato per caso.
• metrics.search_lift_cost_micros: il costo totale (in micro) delle impressioni degli annunci pubblicati per questa sezione di misurazione del search lift.
• metrics.search_lift_impressions: il numero totale di impressioni dell'annuncio pubblicate per questa sezione di misurazione del search lift.

Quando il lift è statisticamente positivo, vengono riportate le seguenti metriche incrementali normalizzate, insieme ai corrispondenti limiti inferiore e superiore dell'intervallo di affidabilità del 90% (*_p90_lower_bound e *_p90_upper_bound):

• metrics.normalized_incremental_searches (con metrics.normalized_incremental_searches_p90_lower_bound e metrics.normalized_incremental_searches_p90_upper_bound): numero stimato di query di ricerca incrementali generate dall'esposizione all'annuncio, normalizzato tra i gruppi esposti e di controllo.
• metrics.normalized_incremental_searches_per_cost (con metrics.normalized_incremental_searches_per_cost_p90_lower_bound e metrics.normalized_incremental_searches_per_cost_p90_upper_bound): query di ricerca incrementali stimate generate per unità di spesa pubblicitaria.
• metrics.normalized_incremental_searches_per_impression (con metrics.normalized_incremental_searches_per_impression_p90_lower_bound e metrics.normalized_incremental_searches_per_impression_p90_upper_bound): query di ricerca incrementali stimate generate per impressione dell'annuncio.

Esempi di query per il search lift

Le seguenti query GAQL mostrano come recuperare i gruppi di parole chiave e le metriche sul rendimento di Search Lift.

Query del gruppo di parole chiave

Per recuperare i gruppi di parole chiave configurati per le misurazioni del 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

Query sulle metriche

I valori search_lift_keyword_bundle.resource_name recuperati nella query del bundle di parole chiave corrispondono ai valori restituiti in segments.search_lift_keyword_bundle nella query seguente. Per scoprire il CONFIG_ID per il tuo studio, esegui una query su lift_measurement_config (ad esempio, SELECT lift_measurement_config.lift_measurement_config_id, lift_measurement_config.name FROM lift_measurement_config).

Per recuperare le metriche relative all'impatto sulle ricerche segmentate per gruppo di parole chiave e proprietà di ricerca:

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

Best practice

Le seguenti best practice si applicano agli esperimenti A/B standard (ad esempio gli esperimenti sulle campagne e all'interno delle campagne). Gli studi di misurazione del lift (brand lift, conversion lift e search lift) utilizzano configurazioni specifiche per lo studio e generano report con intervalli di affidabilità del 90% (*_p90_lower_bound e *_p90_upper_bound) anziché con una soglia di confidenza del 95%.

• Seleziona un livello di confidenza appropriato: l'impostazione di una soglia del valore p più bassa può fornire indicazioni direzionali più rapidamente, soprattutto con budget o volumi di conversioni inferiori. Una confidenza del 95% (p-value <= 0,05) è considerata lo standard accademico e potrebbe essere migliore per ottenere risultati più accurati in un periodo di tempo più lungo.
• Esegui gli esperimenti per un periodo di tempo sufficiente: esegui gli esperimenti per almeno 4 settimane per tenere conto dei cicli di rendimento settimanali, dei ritardi nella conversione e dei periodi di apprendimento.
• Concedi il tempo necessario per l'avvio: per le campagne che utilizzano le offerte automatiche o testano nuove funzionalità, ignora i dati delle prime 1-2 settimane per dare ai modelli di offerta e ai livelli di traffico il tempo di ricalibrarsi in base alla suddivisione.
• Utilizza suddivisioni 50/50: una suddivisione del traffico 50/50 è in genere il modo più rapido per ottenere risultati statisticamente significativi.
• Pianifica in anticipo: imposta la data di inizio dell'esperimento 3-7 giorni nel futuro per concedere tempo ai processi di revisione e approvazione degli annunci.

Importante: puoi eseguire un solo esperimento per campagna alla volta.