एक्सपेरिमेंट की रिपोर्ट

स्टैंडर्ड A/B एक्सपेरिमेंट की रिपोर्टिंग के दो मुख्य तरीके हैं:

• एक्सपेरिमेंट की डायरेक्ट रिपोर्टिंग: मेट्रिक के लिए, experiment रिसॉर्स को क्वेरी करें. यह विकल्प, एक ही रिस्पॉन्स में कंट्रोल और ट्रीटमेंट ग्रुप की मेट्रिक उपलब्ध कराता है. साथ ही, अपलिफ़्ट और p-वैल्यू जैसे आंकड़ों की तुलना करने वाला डेटा भी उपलब्ध कराता है. इंट्रा-कैंपेन एक्सपेरिमेंट की रिपोर्ट करने का यह एकमात्र तरीका है.
• कैंपेन रिपोर्टिंग: मेट्रिक के लिए, campaign रिसॉर्स को क्वेरी करें. इसके लिए, campaign.experiment_type का इस्तेमाल करके, बेस और एक्सपेरिमेंट कैंपेन के बीच अंतर करें. यह विकल्प सिर्फ़ उन एक्सपेरिमेंट के लिए उपलब्ध है जो अलग-अलग कंट्रोल और ट्रीटमेंट कैंपेन का इस्तेमाल करते हैं. जैसे, सिस्टम से मैनेज किए जाने वाले एक्सपेरिमेंट.

स्टैंडर्ड एक्सपेरिमेंट के लिए, यह गाइड मुख्य रूप से डायरेक्ट एक्सपेरिमेंट रिपोर्टिंग पर फ़ोकस करती है. यह रिपोर्टिंग, एक्सपेरिमेंट के उन सभी टाइप के साथ काम करती है जो रिपोर्टिंग के साथ काम करते हैं. लिफ़्ट मेज़रमेंट स्टडी के लिए, ब्रैंड पर असर, कन्वर्ज़न लिफ़्ट, और खोज में बढ़त की रिपोर्ट भी की जा सकती है. इसके लिए, लिफ़्ट मेज़रमेंट के लिए खास तौर पर उपलब्ध संसाधनों का इस्तेमाल करें.

रणनीति बनाने के लिए एक्सपेरिमेंट की रिपोर्टिंग

परफ़ॉर्मेंस मेट्रिक और कंट्रोल और ट्रीटमेंट ग्रुप के बीच आंकड़ों की तुलना करने के लिए, सीधे experiment रिसॉर्स से क्वेरी की जा सकती है.

मेट्रिक और सांख्यिकीय महत्व

क्लिक, इंप्रेशन, लागत, कन्वर्ज़न, और कन्वर्ज़न वैल्यू जैसी मुख्य मेट्रिक के लिए, experiment रिसॉर्स, ट्रीटमेंट मेट्रिक (उदाहरण के लिए, metrics.clicks) और कंट्रोल मेट्रिक (उदाहरण के लिए, metrics.control_clicks), दोनों को एक ही लाइन में दिखाता है.

इसमें ऐसे फ़ील्ड भी होते हैं जिनकी मदद से, ग्रुप के बीच के किसी भी अंतर के सांख्यिकीय महत्व का आकलन किया जा सकता है:

• metrics.*_p_value: अगर एक्सपेरिमेंट का मेट्रिक पर कोई असर नहीं पड़ता, तो देखे गए नतीजे मिलने की संभावना. p-वैल्यू जितनी कम होगी, सांख्यिकीय महत्व उतना ही ज़्यादा होगा.
• metrics.*_point_estimate: कंट्रोल ग्रुप की तुलना में ट्रीटमेंट ग्रुप के लिए, दी गई मेट्रिक में अनुमानित प्रतिशत लिफ़्ट (पॉज़िटिव या नेगेटिव). margin_of_error के साथ मिलकर, ये कॉन्फ़िडेंस इंटरवल के बारे में बताते हैं. साथ ही, अनुमानित अंतर के लिए तय किए गए कॉन्फ़िडेंस लेवल के बारे में बताते हैं. अनुमानित संख्या (ट्रीटमेंट / कंट्रोल - 1) है. पॉइंट एस्टिमेट, कॉन्फ़िडेंस इंटरवल का सेंटर होता है.
• metrics.*_margin_of_error: कॉन्फ़िडेंस इंटरवल की त्रिज्या, जो point_estimate पर केंद्रित है. इसे कॉन्फ़िडेंस लेवल के हिसाब से कैलकुलेट किया जाता है. यह लेवल, एक्सपेरिमेंट के टाइप पर निर्भर करता है.

experiment संसाधन में, ये मुख्य मेट्रिक फ़ील्ड इस्तेमाल किए जा सकते हैं. इनमें ट्रीटमेंट ग्रुप की वैल्यू, कंट्रोल ग्रुप की वैल्यू, और पहले से मौजूद स्टैटिस्टिक्स फ़ील्ड शामिल हैं:

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

खास तौर पर कन्वर्ज़न के लिए, आंकड़ों वाले फ़ील्ड, रिलेटिव वैल्यू के बजाय इन absolute_change फ़ील्ड के ज़रिए उपलब्ध होते हैं:

• metrics.conversions_absolute_change_p_value: नल हाइपोथीसिस के लिए p-वैल्यू. इससे पता चलता है कि एक्सपेरिमेंट का, कन्वर्ज़न में हुए कुल बदलाव पर कोई असर नहीं पड़ा. इसकी वैल्यू 0 से 1 के बीच होती है.
• metrics.conversions_absolute_change_point_estimate: कन्वर्ज़न पर एक्सपेरिमेंट के असर का अनुमान लगाते समय, पॉइंट एस्टिमेट कुल बदलाव.
• metrics.conversions_absolute_change_margin_of_error: कन्वर्ज़न में हुए बदलाव पर, एक्सपेरिमेंट के असर का अनुमान लगाते समय मार्जिन ऑफ़ एरर.

experiment रिसॉर्स के लिए मान्य क्वेरी बनाने में मदद पाने के लिए, Google Ads क्वेरी बिल्डर टूल का इस्तेमाल करें.

उदाहरण के तौर पर दी गई क्वेरी

यहां दी गई GAQL क्वेरी, किसी एक्सपेरिमेंट की मुख्य मेट्रिक को वापस लाती है:

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

नतीजे समझना

p-वैल्यू, पॉइंट एस्टिमेट, और मार्जिन ऑफ़ एरर फ़ील्ड का इस्तेमाल करके, यह पता लगाया जा सकता है कि आपके एक्सपेरिमेंट से सांख्यिकीय तौर पर अहम नतीजे मिले हैं या नहीं. उदाहरण के लिए, अगर conversions_absolute_change_p_value आपकी चुनी गई थ्रेशोल्ड से कम है (जैसे कि 95% कॉन्फ़िडेंस के लिए 0.05) और conversions_absolute_change_point_estimate - conversions_absolute_change_margin_of_error शून्य से ज़्यादा है, तो कन्वर्ज़न के मामले में ट्रीटमेंट ग्रुप, कंट्रोल ग्रुप की तुलना में काफ़ी बेहतर परफ़ॉर्म कर रहा है.

यहां एक Python स्निपेट दिया गया है. इसमें p-वैल्यू और लिफ़्ट के अनुमानों के आधार पर, नतीजों का आकलन करने का तरीका बताया गया है:

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

ध्यान दें: इस चरण के लिए, REST कोड का कोई सैंपल यहां नहीं दिया गया है. हालांकि, मैन्युअल तरीके से REST अनुरोध का इस्तेमाल करके, यह काम किया जा सकता है.

Google Ads API के REST इंटरफ़ेस के दस्तावेज़ और तरीके के हिसाब से रेफ़रंस पेज देखें. आपको प्रोटो डेफ़िनिशन के आधार पर, JSON पेलोड बनाना होगा.

मुख्य संसाधन:

• REST का इस्तेमाल करना
• REST इंटरफ़ेस का स्ट्रक्चर
• JSON फ़ील्ड मैपिंग
• किसी खास सेवा और तरीके के बारे में जानने के लिए, REST API का रेफ़रंस देखें.

कैंपेन रिपोर्टिंग की तुलना में मिलने वाले फ़ायदे

कैंपेन की रिपोर्ट को अलग से क्वेरी करने के मुकाबले, डायरेक्ट एक्सपेरिमेंट रिपोर्टिंग के कई फ़ायदे हैं:

1. एक ही जगह पर मौजूद मेट्रिक: कंट्रोल और ट्रीटमेंट ग्रुप की मेट्रिक को एक ही लाइन में देखें.
2. आंकड़ों के आधार पर कॉन्फ़िडेंस डेटा: इससे कैलकुलेट की गई p-वैल्यू, पॉइंट अनुमान, और मार्जिन ऑफ़ एरर (गड़बड़ी की गुंजाइश) की जानकारी मिलती है.
3. बेहतर तरीके से काम करना: इससे आपको कई रिपोर्ट के नतीजों को मैन्युअल तरीके से जोड़ने या उनकी तुलना करने की ज़रूरत नहीं पड़ती.
4. इंट्रा-कैंपेन के लिए सहायता: इंट्रा-कैंपेन एक्सपेरिमेंट के लिए, कंट्रोल और ट्रीटमेंट की तुलना करने का यह एकमात्र तरीका है. इसमें ट्रैफ़िक को एक ही कैंपेन में बांटा जाता है.

कैंपेन रिपोर्टिंग

अलग-अलग ट्रीटमेंट कैंपेन बनाने वाले एक्सपेरिमेंट (उदाहरण के लिए, SEARCH_CUSTOM) के लिए, campaign रिसॉर्स को क्वेरी किया जा सकता है. साथ ही, BASE (कंट्रोल) और EXPERIMENT (ट्रीटमेंट) कैंपेन की पहचान करने के लिए, campaign.experiment_type का इस्तेमाल किया जा सकता है. यह तरीका तब काम आता है, जब आपको मेट्रिक को ज़्यादा बारीकी से सेगमेंट करना हो (जैसे कि विज्ञापन ग्रुप या कीवर्ड के हिसाब से) या कैंपेन का ऐसा मेटाडेटा देखना हो जो experiment रिसॉर्स पर उपलब्ध नहीं है. हालांकि, इसके लिए आपको परफ़ॉर्मेंस की तुलना और आंकड़ों का हिसाब-किताब मैन्युअल तरीके से करना होगा.

कैंपेन के अंदर किए जाने वाले एक्सपेरिमेंट के ग्रुप की तुलना करने के लिए, कैंपेन-लेवल की रिपोर्टिंग का इस्तेमाल नहीं किया जा सकता. इसकी वजह यह है कि ट्रैफ़िक का बंटवारा, एक ही कैंपेन के अंदर होता है. इंट्रा-कैंपेन एक्सपेरिमेंट के लिए campaign से क्वेरी करने पर, सिर्फ़ एग्रीगेट किया गया कुल डेटा मिलता है.

ब्रैंड पर असर की रिपोर्टिंग

Google Ads API में, ब्रैंड पर असर की स्टडी की रिपोर्ट तैयार की जा सकती है. इसके लिए, ब्रैंड पर विज्ञापन के असर को मेज़र करने के लिए खास तौर पर बनाए गए संसाधनों का इस्तेमाल करें.

ध्यान दें: जिस ग्राहक आईडी (सीआईडी) के लिए क्वेरी करनी है वह ग्लोबल प्रॉडक्ट सॉल्यूशंस (जीपीएस) की मैनेज की जाने वाली अनुमति वाली सूची में शामिल होना चाहिए. इंटिग्रेशन शुरू करने से पहले, अपने Google प्रतिनिधि या जीपीएस संपर्क से संपर्क करें.

ब्रैंड पर असर के संसाधन और ब्रेकडाउन व्यू

ग्राहक के टाइम ज़ोन में, फ़्लाइट की तारीख की सीमाओं (start_date और end_date) के साथ-साथ फ़्लाइट-लेवल पर ब्रैंड पर असर की स्टडी के नतीजे पाने के लिए, LiftMeasurementFlight रिसॉर्स को क्वेरी करें.

अलग-अलग सेगमेंट डाइमेंशन में ब्रैंड पर असर की मेट्रिक का विश्लेषण करने के लिए, ब्रेकडाउन के हिसाब से संसाधनों के लिए क्वेरी करें:

• LiftMeasurementCampaign: कैंपेन के हिसाब से ब्रेकडाउन.
• LiftMeasurementAgeRange: उम्र की सीमा के हिसाब से ब्रेकडाउन.
• LiftMeasurementDevice: डिवाइस के हिसाब से ब्रेकडाउन.
• LiftMeasurementGender: लैंगिक जानकारी के हिसाब से ब्रेकडाउन.
• LiftMeasurementVideo: वीडियो ऐसेट के हिसाब से ब्रेकडाउन.

BrandLiftMeasurementType enum से, स्टडी के लिए मेज़रमेंट टाइप तय होता है. जैसे, ब्रैंड जागरूकता या विज्ञापन याद रखना.

ब्रैंड पर असर की क्वेरी के उदाहरण

फ़्लाइट का मेटाडेटा और लिफ़्ट के आंकड़े अलग-अलग संसाधनों में मौजूद होते हैं. इसलिए, फ़्लाइट की जानकारी और परफ़ॉर्मेंस के आंकड़ों के लिए, अलग-अलग GAQL क्वेरी की ज़रूरत होती है.

फ़्लाइट की जानकारी वाली क्वेरी

ब्रैंड पर असर की फ़्लाइट का मेटाडेटा पाने के लिए, 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

आंकड़ों से जुड़ी क्वेरी

ब्रैंड पर असर की मेट्रिक पाने के लिए, ब्रेकडाउन के सही संसाधन (या LiftMeasurementConfig पर स्टडी के पूरे कॉन्फ़िगरेशन) के लिए क्वेरी करें. उदाहरण के लिए, यह क्वेरी 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

कन्वर्ज़न लिफ़्ट रिपोर्टिंग

Google Ads API में कन्वर्ज़न लिफ़्ट रिपोर्टिंग का इस्तेमाल करके, कन्वर्ज़न पर विज्ञापनों के बढ़ने वाले असर को मेज़र किया जा सकता है.

ध्यान दें: जिस ग्राहक आईडी (सीआईडी) के लिए क्वेरी करनी है वह ग्लोबल प्रॉडक्ट सॉल्यूशंस (जीपीएस) की मैनेज की जाने वाली अनुमति वाली सूची में शामिल होना चाहिए. इंटिग्रेशन शुरू करने से पहले, अपने Google प्रतिनिधि या जीपीएस संपर्क से संपर्क करें. इसके अलावा, कन्वर्ज़न लिफ़्ट के लिए मैनेजर खाते के लेवल पर ऐक्सेस देने की सुविधा पर काम चल रहा है.

कन्वर्ज़न लिफ़्ट का कॉन्फ़िगरेशन और मेट्रिक

कन्वर्ज़न लिफ़्ट स्टडी के कॉन्फ़िगरेशन और परफ़ॉर्मेंस डेटा को वापस पाने के लिए, LiftMeasurementConfig रिसॉर्स को क्वेरी करें.

यह संसाधन, कन्वर्ज़न लिफ़्ट मेट्रिक उपलब्ध कराता है, ताकि परफ़ॉर्मेंस में हुई बढ़ोतरी का आकलन किया जा सके:

• metrics.conversion_lift_baseline_conversions: स्टडी के लिए बेसलाइन कन्वर्ज़न.
• metrics.conversion_lift_exposed_conversions: एक्सपोज़्ड ग्रुप में मिले कन्वर्ज़न.
• metrics.incremental_conversions: विज्ञापनों को एट्रिब्यूट किए गए इंक्रीमेंटल कन्वर्ज़न.
• metrics.cost_per_incremental_conversion: हर इंक्रीमेंटल कन्वर्ज़न की लागत.
• metrics.relative_conversion_lift: कन्वर्ज़न में रिलेटिव लिफ़्ट.
• metrics.conversion_lift_baseline_conversion_value: बेसलाइन कन्वर्ज़न वैल्यू.
• metrics.conversion_lift_exposed_conversion_value: एक्सपोज़्ड ग्रुप में कन्वर्ज़न वैल्यू.
• metrics.incremental_conversion_value: विज्ञापनों को एट्रिब्यूट की गई इंक्रीमेंटल कन्वर्ज़न वैल्यू.
• metrics.relative_conversion_value_lift: कन्वर्ज़न वैल्यू में रिलेटिव लिफ़्ट.

कन्वर्ज़न लिफ़्ट रिपोर्टिंग की मदद से, कन्वर्ज़न ऐक्शन के हिसाब से सेगमेंट भी किया जा सकता है. साथ ही, लिंक किए गए कैंपेन की जानकारी, एक्सपेरिमेंट की जानकारी, और कन्वर्ज़न लक्ष्यों को वापस पाया जा सकता है.

v26 से, Campaign.lift_measurement_config का इस्तेमाल करके, campaign रिसॉर्स से सीधे तौर पर किसी कैंपेन से जुड़े लिफ़्ट मेज़रमेंट कॉन्फ़िगरेशन को खोजा जा सकता है. इससे LiftMeasurementConfig रिसॉर्स को अलग से क्रॉस-रेफ़रंस करने की ज़रूरत नहीं पड़ती:

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

नतीजे में मिले lift_measurement_config फ़ील्ड में, संसाधन का नाम customers/{customer_id}/liftMeasurementConfigs/{lift_measurement_config_id} फ़ॉर्मैट में होता है.

ध्यान दें: अगर कैंपेन में लिफ़्ट के कई एक्सपेरिमेंट चलाए गए हैं, तो lift_measurement_config में हाल ही में लिंक किए गए कॉन्फ़िगरेशन (चालू या बंद) का रिसॉर्स नेम शामिल होता है.

कन्वर्ज़न लिफ़्ट क्वेरी का उदाहरण

यहां दी गई GAQL क्वेरी, कन्वर्ज़न लिफ़्ट के कॉन्फ़िगरेशन और परफ़ॉर्मेंस की मुख्य मेट्रिक को वापस लाती है. ध्यान दें कि segments.conversion_lift_start_date और segments.conversion_lift_end_date, INT64 फ़ील्ड हैं. इन्हें YYYYMMDD फ़ॉर्मैट में, बिना कोटेशन मार्क वाले आठ अंकों के पूर्णांक के तौर पर फ़ॉर्मैट किया गया है. उदाहरण के लिए, 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

खोज में बढ़त की रिपोर्टिंग

Google Ads API में खोज में बढ़त की रिपोर्टिंग का इस्तेमाल करके, अपने विज्ञापन कैंपेन से ऑर्गैनिक सर्च क्वेरी की संख्या में हुई बढ़ोतरी को मेज़र किया जा सकता है. खोज में बढ़त से, आपके ब्रैंड या प्रॉडक्ट के लिए खोज करने के तरीके में अंतर का पता चलता है. यह अंतर, आपके विज्ञापन देखने वाले उपयोगकर्ताओं और विज्ञापन न देखने वाले कंट्रोल ग्रुप के बीच होता है.

ध्यान दें: जिस ग्राहक आईडी (सीआईडी) के लिए क्वेरी करनी है वह ग्लोबल प्रॉडक्ट सॉल्यूशंस (जीपीएस) की मैनेज की जाने वाली अनुमति वाली सूची में शामिल होना चाहिए. इंटिग्रेशन शुरू करने से पहले, अपने Google प्रतिनिधि या जीपीएस संपर्क से संपर्क करें.

खोज में बढ़त के संसाधन और सेगमेंटेशन

खोज में बढ़त की जांच के लिए कॉन्फ़िगर किए गए कीवर्ड बंडल की जानकारी पाने के लिए, SearchLiftKeywordBundle संसाधन को क्वेरी करें. SearchLiftKeywordBundle, एपीआई में रीड-ओनली है (सभी फ़ील्ड OUTPUT_ONLY हैं). साथ ही, कीवर्ड बंडल को Google Ads के यूज़र इंटरफ़ेस (यूआई) में या Google के प्रतिनिधियों / ग्लोबल प्रॉडक्ट सॉल्यूशंस (जीपीएस) के ज़रिए कॉन्फ़िगर किया जाता है. GAQL में इसके क्वेरी किए जा सकने वाले फ़ील्ड resource_name, search_lift_keyword_bundle_id, source (SearchLiftMatchingInfoSource), और status (SearchLiftKeywordBundleStatus) हैं. GAQL क्वेरी में, दोहराए गए keywords फ़ील्ड को नहीं चुना जा सकता.

खोज में बढ़त की मेट्रिक और स्टडी के सभी कॉन्फ़िगरेशन को वापस पाने के लिए, LiftMeasurementConfig रिसॉर्स को क्वेरी करें.

खोज में बढ़त की परफ़ॉर्मेंस को इन डाइमेंशन का इस्तेमाल करके सेगमेंट किया जा सकता है:

• segments.search_lift_keyword_bundle: कीवर्ड बंडल के संसाधन के नाम के हिसाब से सेगमेंट करें. segments.search_property, segments.date, और डेमोग्राफ़िक सेगमेंट (segments.device, segments.age_range, और segments.gender) के साथ काम करता है.
• segments.search_property: खोज के लिए इस्तेमाल की गई प्रॉपर्टी के हिसाब से सेगमेंट करें. इसे SearchLiftSearchProperty से तय किया जाता है. जैसे, Google Search या YouTube. ध्यान दें कि segments.search_property सिर्फ़ segments.search_lift_keyword_bundle और segments.date के साथ काम करता है. segments.search_property को डेमोग्राफ़िक सेगमेंट (segments.device, segments.age_range या segments.gender) के साथ नहीं जोड़ा जा सकता. ऐसा करने पर, एपीआई क्वेरी की पुष्टि नहीं हो पाती.
• डेमोग्राफ़िक और तारीख के सेगमेंट: segments.device, segments.age_range, segments.gender, और segments.date.

खोज में बढ़त की मेट्रिक

LiftMeasurementConfig रिसॉर्स, खोज में बढ़त की मेट्रिक उपलब्ध कराता है. इससे खोज के व्यवहार में हुए बदलावों का आकलन किया जा सकता है:

• metrics.relative_search_lift: एक्सपोज़्ड और कंट्रोल ग्रुप के बीच सर्च क्वेरी की संख्या में अंतर. इसे कंट्रोल ग्रुप में सर्च क्वेरी के फ़्रैक्शन के तौर पर दिखाया जाता है.
• metrics.relative_search_lift_p90_lower_bound और metrics.relative_search_lift_p90_upper_bound: खोज में बढ़त के लिए, 90% कॉन्फ़िडेंस इंटरवल की निचली और ऊपरी सीमाएं.
• metrics.incremental_searches_p_value: बढ़ी हुई खोजों के लिए p-वैल्यू. इससे यह पता चलता है कि सर्च क्वेरी में हुई बढ़ोतरी, संयोग से हुई है या नहीं.
• metrics.search_lift_cost_micros: खोज में बढ़त के मेज़रमेंट के इस स्लाइस के लिए दिखाए गए विज्ञापन इंप्रेशन की कुल लागत (माइक्रो में).
• metrics.search_lift_impressions: खोज में बढ़त के मेज़रमेंट के इस स्लाइस के लिए दिखाए गए विज्ञापन इंप्रेशन की कुल संख्या.

जब लिफ़्ट, आंकड़ों के हिसाब से पॉज़िटिव होती है, तब यहां दी गई नॉर्मलाइज़ की गई इंक्रीमेंटल मेट्रिक रिपोर्ट की जाती हैं. साथ ही, उनके लिए 90% कॉन्फ़िडेंस इंटरवल की निचली और ऊपरी सीमाएं (*_p90_lower_bound और *_p90_upper_bound) भी रिपोर्ट की जाती हैं:

• metrics.normalized_incremental_searches (metrics.normalized_incremental_searches_p90_lower_bound और metrics.normalized_incremental_searches_p90_upper_bound के साथ): विज्ञापन की पहुंच की वजह से, सर्च क्वेरी में हुई बढ़ोतरी की अनुमानित संख्या. इसे एक्सपोज़्ड और कंट्रोल ग्रुप के हिसाब से सामान्य बनाया जाता है.
• metrics.normalized_incremental_searches_per_cost (with metrics.normalized_incremental_searches_per_cost_p90_lower_bound and metrics.normalized_incremental_searches_per_cost_p90_upper_bound): विज्ञापन पर खर्च की गई हर यूनिट के हिसाब से जनरेट हुई अनुमानित इंक्रीमेंटल सर्च क्वेरी.
• metrics.normalized_incremental_searches_per_impression (with metrics.normalized_incremental_searches_per_impression_p90_lower_bound and metrics.normalized_incremental_searches_per_impression_p90_upper_bound): हर विज्ञापन इंप्रेशन से जनरेट हुई, अनुमानित इंक्रीमेंटल सर्च क्वेरी.

खोज में बढ़त की क्वेरी के उदाहरण

यहां दी गई GAQL क्वेरी से, खोज में बढ़त के कीवर्ड बंडल और परफ़ॉर्मेंस मेट्रिक को वापस पाने का तरीका पता चलता है.

कीवर्ड बंडल क्वेरी

खोज में बढ़त के मेज़रमेंट के लिए कॉन्फ़िगर किए गए कीवर्ड बंडल को वापस पाने के लिए:

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

मेट्रिक क्वेरी

कीवर्ड बंडल क्वेरी में मिली search_lift_keyword_bundle.resource_name वैल्यू, नीचे दी गई क्वेरी में segments.search_lift_keyword_bundle में मिली वैल्यू से मेल खाती हैं. अपनी स्टडी के लिए CONFIG_ID का पता लगाने के लिए, lift_measurement_config क्वेरी करें. उदाहरण के लिए, SELECT lift_measurement_config.lift_measurement_config_id, lift_measurement_config.name FROM lift_measurement_config.

कीवर्ड बंडल और सर्च प्रॉपर्टी के हिसाब से सेगमेंट की गई, खोज में बढ़त की मेट्रिक पाने के लिए:

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

सबसे सही तरीके

यहां दिए गए सबसे सही तरीके, स्टैंडर्ड A/B एक्सपेरिमेंट पर लागू होते हैं. जैसे, कैंपेन और इंट्रा-कैंपेन एक्सपेरिमेंट. लिफ़्ट मेज़रमेंट स्टडी (ब्रैंड पर असर, कन्वर्ज़न लिफ़्ट, और खोज में बढ़त) में, स्टडी के हिसाब से कॉन्फ़िगरेशन का इस्तेमाल किया जाता है. साथ ही, 95% कॉन्फ़िडेंस थ्रेशोल्ड के बजाय 90% कॉन्फ़िडेंस इंटरवल (*_p90_lower_bound और *_p90_upper_bound) की रिपोर्ट दी जाती है.

• कॉन्फ़िडेंस लेवल सही तरीके से चुनें: पी-वैल्यू थ्रेशोल्ड को कम पर सेट करने से, आपको तेज़ी से दिशा-निर्देश मिल सकते हैं. खास तौर पर, कम बजट या कन्वर्ज़न वॉल्यूम के साथ. 95% कॉन्फ़िडेंस लेवल (p-वैल्यू <= 0.05) को अकैडमिक स्टैंडर्ड माना जाता है. यह लंबी समयावधि में ज़्यादा सटीक नतीजे पाने के लिए बेहतर हो सकता है.
• एक्सपेरिमेंट को लंबे समय तक चलाएं: एक्सपेरिमेंट को कम से कम चार हफ़्तों तक चलाएं, ताकि हर हफ़्ते की परफ़ॉर्मेंस साइकल, कन्वर्ज़न में लगने वाले समय, और लर्निंग पीरियड (परफ़ॉर्मेंस डेटा इकट्ठा करने में लगने वाला समय) को ध्यान में रखा जा सके.
• रैंप-अप के लिए समय दें: ऑटोमेटेड बिडिंग का इस्तेमाल करने वाले या नई सुविधाओं की टेस्टिंग करने वाले कैंपेन के लिए, पहले एक से दो हफ़्तों के डेटा को अनदेखा करें. इससे बिडिंग मॉडल और ट्रैफ़िक लेवल को स्प्लिट के हिसाब से फिर से कैलिब्रेट करने का समय मिलता है.
• ट्रैफ़िक को 50/50 के अनुपात में बांटें: आम तौर पर, ट्रैफ़िक को 50/50 के अनुपात में बांटने से, सांख्यिकीय तौर पर अहम नतीजे सबसे तेज़ी से मिलते हैं.
• पहले से शेड्यूल करें: एक्सपेरिमेंट शुरू होने की तारीख, तीन से सात दिन बाद की सेट करें. इससे विज्ञापन की समीक्षा और उसे मंज़ूरी मिलने की प्रोसेस के लिए समय मिल जाएगा.

अहम जानकारी: किसी भी समय, हर कैंपेन के लिए सिर्फ़ एक एक्सपेरिमेंट चलाया जा सकता है.