אתם מוזמנים להצטרף אלינו לשידור חי ב-Discord בשרת של קהילת הפרסום והמדידה של Google וב-YouTube ב-14 במאי בשעה 10:00 (שעון החוף המזרחי)! במאמר הזה נדון בתכונות החדשות שנוספו לגרסה 24.1 של Google Ads API.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

ניסויים שמנוהלים על ידי המערכת

ניסויים שמנוהלים על ידי המערכת משמשים להרצת בדיקות A/B של שינויים. לשם כך, המערכת יוצרת קמפיין בקרה מקורי וקמפיין ניסיוני אחד או יותר שאפשר לשנות, והם פועלים במקביל. התהליך הזה נתמך בערכים הבאים של ExperimentType:

‫SEARCH_CUSTOM: ניסוי בהתאמה אישית שכולל קמפיינים לרשת החיפוש.
‫DISPLAY_CUSTOM: ניסוי בהתאמה אישית שכולל קמפיינים לרשת המדיה.
‫HOTEL_CUSTOM: ניסוי מותאם אישית שכולל קמפיינים לקידום מלונות.
‫YOUTUBE_CUSTOM: ניסוי בהתאמה אישית שכולל קמפיינים של מודעות וידאו.
‫PMAX_REPLACEMENT_SHOPPING: ניסוי שמאפשר לבדוק את הביצועים של קמפיינים של שופינג בהשוואה לקמפיינים למיקסום הביצועים.

הגדרה

כדי להגדיר ניסויים שמנוהלים על ידי המערכת, פועלים לפי השלבים הבאים:

יצירת Experiment.
יוצרים משאבי ExperimentArm בקרה וניסוי.
משנים את in_design_campaigns בקבוצות הניסוי.

1. יצירת ניסוי

השלב הראשון בהרצת ניסוי באמצעות Google Ads API הוא ליצור Experiment. במקור הזה מוגדר מידע חשוב על הניסוי שרוצים להפעיל. בשלב הזה לא מציינים אף אחד מהקמפיינים שמשתתפים בניסוי.

הנה סקירה כללית של כמה שדות חשובים ב-Experiment:

‫name: לכל ניסוי צריך להיות שם ייחודי.
‫description: שדה אופציונלי שאפשר להשתמש בו כדי ליצור הפניה בהמשך. הסטטוס לא משפיע על אופן הפעלת הניסוי.
‫suffix: הסיומת תצורף לסוף השמות של קמפיינים שמוגדרים כקבוצת ניסוי, כדי שתוכלו להבחין בינם לבין קמפיין הבקרה. הסברים נוספים על המושגים האלה מופיעים בשלב 2.
‫type: סוג הניסוי שרוצים להריץ. בניסויים שמנוהלים על ידי המערכת, משתמשים בערכים SEARCH_CUSTOM, DISPLAY_CUSTOM, HOTEL_CUSTOM, YOUTUBE_CUSTOM או PMAX_REPLACEMENT_SHOPPING.
‫status: כשיוצרים ניסוי, מגדירים את השדה הזה לערך SETUP. בהמשך, אחרי שתתחילו את הניסוי, תוכלו לבדוק את הסטטוס הנוכחי בשדה הזה.
‫start_date ו-end_date: מציינים מתי הניסוי צריך להתחיל ומתי הוא צריך להסתיים.
‫sync_enabled: מושבת כברירת מחדל. אם ההגדרה היא true, שינויים שמתבצעים בקמפיין המקורי בזמן שהניסוי פועל מועתקים באופן אוטומטי לקמפיין הניסוי. מידע נוסף

Java

private String createExperimentResource(GoogleAdsClient googleAdsClient, long customerId) {
  ExperimentOperation operation =
      ExperimentOperation.newBuilder()
          .setCreate(
              Experiment.newBuilder()
                  // Name must be unique.
                  .setName("Example Experiment #" + getPrintableDateTime())
                  .setType(ExperimentType.SEARCH_CUSTOM)
                  .setSuffix("[experiment]")
                  .setStatus(ExperimentStatus.SETUP)
                  .build())
          .build();

  try (ExperimentServiceClient experimentServiceClient =
      googleAdsClient.getLatestVersion().createExperimentServiceClient()) {
    MutateExperimentsResponse response =
        experimentServiceClient.mutateExperiments(
            Long.toString(customerId), ImmutableList.of(operation));
    String experiment = response.getResults(0).getResourceName();
    System.out.printf("Created experiment with resource name '%s'%n", experiment);
    return experiment;
  }
}CreateExperiment.java

C#‎

/// <summary>
/// Creates the experiment.
/// </summary>
/// <param name="client">The Google Ads client.</param>
/// <param name="customerId">The customer ID for which the call is made.</param>
/// <returns>The resource name of the newly created experiment.</returns>
private static string CreateAnExperiment(GoogleAdsClient client, long customerId)
{
    // Get the ExperimentService.
    ExperimentServiceClient experimentService = client.GetService(
        Services.V24.ExperimentService);

    // Creates the experiment.
    Experiment experiment = new Experiment()
    {
        // Name must be unique.
        Name = $"Example Experiment #{ExampleUtilities.GetRandomString()}",
        Type = ExperimentType.SearchCustom,
        Suffix = "[experiment]",
        Status = ExperimentStatus.Setup
    };

    // Creates the operation.
    ExperimentOperation operation = new ExperimentOperation()
    {
        Create = experiment
    };

    // Makes the API call.
    MutateExperimentsResponse response = experimentService.MutateExperiments(
        customerId.ToString(), new[] { operation });

    // Displays the result.
    string experimentResourceName = response.Results.First().ResourceName;

    Console.WriteLine($"Created experiment with resource name " +
        $"'{experimentResourceName}'.");
    return experimentResourceName;
}
CreateExperiment.cs

PHP

private static function createExperimentResource(
    ExperimentServiceClient $experimentServiceClient,
    int $customerId
): string {
    // Creates an experiment and its operation.
    $experiment = new Experiment([
        // Name must be unique.
        'name' => 'Example Experiment #' . Helper::getPrintableDatetime(),
        'type' => ExperimentType::SEARCH_CUSTOM,
        'suffix' => '[experiment]',
        'status' => ExperimentStatus::SETUP
    ]);
    $experimentOperation = new ExperimentOperation(['create' => $experiment]);

    // Issues a request to create the experiment.
    $response = $experimentServiceClient->mutateExperiments(
        MutateExperimentsRequest::build($customerId, [$experimentOperation])
    );
    $experimentResourceName = $response->getResults()[0]->getResourceName();
    print "Created experiment with resource name '$experimentResourceName'" . PHP_EOL;

    return $experimentResourceName;
}CreateExperiment.php

Python

def create_experiment_resource(
    client: GoogleAdsClient, customer_id: str
) -> str:
    """Creates a new experiment resource.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.

    Returns:
        the resource name for the new experiment.
    """
    experiment_operation: ExperimentOperation = client.get_type(
        "ExperimentOperation"
    )
    experiment: Experiment = experiment_operation.create

    experiment.name = f"Example Experiment #{uuid.uuid4()}"
    # We specify SEARCH_CUSTOM to create a standard search campaign experiment.
    # This type uses a standard draft-based workflow where the system automatically
    # creates a draft/in-design campaign for the treatment arm.
    experiment.type_ = client.enums.ExperimentTypeEnum.SEARCH_CUSTOM
    experiment.suffix = "[experiment]"
    experiment.status = client.enums.ExperimentStatusEnum.SETUP

    experiment_service: ExperimentServiceClient = client.get_service(
        "ExperimentService"
    )
    response: MutateExperimentsResponse = experiment_service.mutate_experiments(
        customer_id=customer_id, operations=[experiment_operation]
    )

    experiment_resource_name: str = response.results[0].resource_name
    print(f"Created experiment with resource name {experiment_resource_name}")

    return experiment_resource_namecreate_search_custom_experiment.py

Ruby

def create_experiment_resource(client, customer_id)
  operation = client.operation.create_resource.experiment do |e|
    # Name must be unique.
    e.name = "Example Experiment #{(Time.new.to_f * 1000).to_i}"
    e.type = :SEARCH_CUSTOM
    e.suffix = '[experiment]'
    e.status = :SETUP
  end

  response = client.service.experiment.mutate_experiments(
    customer_id: customer_id,
    operations: [operation],
  )

  experiment = response.results.first.resource_name
  puts "Created experiment with resource name #{experiment}."

  experiment
endcreate_experiment.rb

Perl

sub create_experiment_resource {
  my ($api_client, $customer_id) = @_;

  my $experiment = Google::Ads::GoogleAds::V24::Resources::Experiment->new({
    # Name must be unique.
    name   => "Example Experiment #" . uniqid(),
    type   => SEARCH_CUSTOM,
    suffix => "[experiment]",
    status => SETUP
  });

  my $operation =
    Google::Ads::GoogleAds::V24::Services::ExperimentService::ExperimentOperation
    ->new({
      create => $experiment
    });

  my $response = $api_client->ExperimentService()->mutate({
      customerId => $customer_id,
      operations => [$operation]});

  my $resource_name = $response->{results}[0]{resourceName};
  printf "Created experiment with resource name '%s'.\n", $resource_name;
  return $resource_name;
}create_experiment.pl

curl

2. יצירת קבוצות ניסוי

לאחר מכן, יוצרים משאבי ExperimentArm כדי להגדיר את קבוצות הבקרה והניסוי. כל הקבוצות צריכות להיווצר בבקשה אחת.

לכל ניסוי צריכה להיות בדיוק קבוצת בקרה אחת וקבוצת ניסוי אחת או יותר. קבוצת הבקרה מזהה את קמפיין הבסיס לצורך השוואה, וכל קבוצת ניסוי יוצרת קמפיין חדש שבו אפשר לבצע שינויים לבדיקה.

צריך גם לציין את המאפיין traffic_split, שהוא אחוז התנועה שמופנה לכל קבוצה. סכום חלוקת התנועה בכל הקבוצות חייב להיות 100.

Java

private String createExperimentArms(
    GoogleAdsClient googleAdsClient, long customerId, long campaignId, String experiment) {
  List<ExperimentArmOperation> operations = new ArrayList<>();
  operations.add(
      ExperimentArmOperation.newBuilder()
          .setCreate(
              // The "control" arm references an already-existing campaign.
              ExperimentArm.newBuilder()
                  .setControl(true)
                  .addCampaigns(ResourceNames.campaign(customerId, campaignId))
                  .setExperiment(experiment)
                  .setName("control arm")
                  .setTrafficSplit(40)
                  .build())
          .build());
  operations.add(
      ExperimentArmOperation.newBuilder()
          .setCreate(
              // The non-"control" arm, also called a "treatment" arm, will automatically
              // generate draft campaigns that you can modify before starting the experiment.
              ExperimentArm.newBuilder()
                  .setControl(false)
                  .setExperiment(experiment)
                  .setName("experiment arm")
                  .setTrafficSplit(60)
                  .build())
          .build());

  try (ExperimentArmServiceClient experimentArmServiceClient =
      googleAdsClient.getLatestVersion().createExperimentArmServiceClient()) {
    // Constructs the mutate request.
    MutateExperimentArmsRequest mutateRequest = MutateExperimentArmsRequest.newBuilder()
        .setCustomerId(Long.toString(customerId))
        .addAllOperations(operations)
        // We want to fetch the draft campaign IDs from the treatment arm, so the easiest way to do
        // that is to have the response return the newly created entities.
        .setResponseContentType(ResponseContentType.MUTABLE_RESOURCE)
        .build();

    // Sends the mutate request.
    MutateExperimentArmsResponse response =
        experimentArmServiceClient.mutateExperimentArms(mutateRequest);

    // Results always return in the order that you specify them in the request. Since we created
    // the treatment arm last, it will be the last result.  If you don't remember which arm is the
    // treatment arm, you can always filter the query in the next section with
    // `experiment_arm.control = false`.
    MutateExperimentArmResult controlArmResult = response.getResults(0);
    MutateExperimentArmResult treatmentArmResult = response.getResults(
        response.getResultsCount() - 1);

    System.out.printf("Created control arm with resource name '%s'%n",
        controlArmResult.getResourceName());
    System.out.printf("Created treatment arm with resource name '%s'%n",
        treatmentArmResult.getResourceName());

    return treatmentArmResult.getExperimentArm().getInDesignCampaigns(0);
  }
}CreateExperiment.java

C#‎

/// <summary>
/// Creates the experiment arms.
/// </summary>
/// <param name="client">The Google Ads client.</param>
/// <param name="customerId">The customer ID for which the call is made.</param>
/// <param name="baseCampaignId">ID of the campaign for which the control arm is
/// created.</param>
/// <param name="experimentResourceName">Resource name of the experiment.</param>
/// <returns>The control and treatment arms.</returns>
private static (MutateExperimentArmResult, MutateExperimentArmResult)
    CreateExperimentArms(GoogleAdsClient client, long customerId, long baseCampaignId,
        string experimentResourceName)
{
    // Get the ExperimentArmService.
    ExperimentArmServiceClient experimentService = client.GetService(
        Services.V24.ExperimentArmService);

    // Create the control arm. The control arm references an already-existing campaign.
    ExperimentArmOperation controlArmOperation = new ExperimentArmOperation()
    {
        Create = new ExperimentArm()
        {
            Control = true,
            Campaigns = {
                ResourceNames.Campaign(customerId, baseCampaignId)
            },
            Experiment = experimentResourceName,
            Name = "Control Arm",
            TrafficSplit = 40
        }
    };

    // Create the non-control arm. The non-"control" arm, also called a "treatment" arm,
    // will automatically generate draft campaigns that you can modify before starting the
    // experiment.
    ExperimentArmOperation treatmentArmOperation = new ExperimentArmOperation()
    {
        Create = new ExperimentArm()
        {
            Control = false,
            Experiment = experimentResourceName,
            Name = "Experiment Arm",
            TrafficSplit = 60
        }
    };

    // We want to fetch the draft campaign IDs from the treatment arm, so the
    // easiest way to do that is to have the response return the newly created
    // entities.
    MutateExperimentArmsRequest request = new MutateExperimentArmsRequest
    {
        CustomerId = customerId.ToString(),
        Operations = { controlArmOperation, treatmentArmOperation },
        ResponseContentType = ResponseContentType.MutableResource
    };


    MutateExperimentArmsResponse response = experimentService.MutateExperimentArms(
        request
    );

    // Results always return in the order that you specify them in the request.
    // Since we created the treatment arm last, it will be the last result.
    MutateExperimentArmResult controlArm = response.Results.First();
    MutateExperimentArmResult treatmentArm = response.Results.Last();

    Console.WriteLine($"Created control arm with resource name " +
        $"'{controlArm.ResourceName}.");
    Console.WriteLine($"Created treatment arm with resource name" +
      $" '{treatmentArm.ResourceName}'.");
    return (controlArm, treatmentArm);
}
CreateExperiment.cs

PHP

private static function createExperimentArms(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    int $campaignId,
    string $experimentResourceName
): string {
    $operations = [];
    $experimentArm1 = new ExperimentArm([
        // The "control" arm references an already-existing campaign.
        'control' => true,
        'campaigns' => [ResourceNames::forCampaign($customerId, $campaignId)],
        'experiment' => $experimentResourceName,
        'name' => 'control arm',
        'traffic_split' => 40
    ]);
    $operations[] = new ExperimentArmOperation(['create' => $experimentArm1]);
    $experimentArm2 = new ExperimentArm([
        // The non-"control" arm, also called a "treatment" arm, will automatically
        // generate draft campaigns that you can modify before starting the
        // experiment.
        'control' => false,
        'experiment' => $experimentResourceName,
        'name' => 'experiment arm',
        'traffic_split' => 60
    ]);
    $operations[] = new ExperimentArmOperation(['create' => $experimentArm2]);

    // Issues a request to create the experiment arms.
    $experimentArmServiceClient = $googleAdsClient->getExperimentArmServiceClient();
    $response = $experimentArmServiceClient->mutateExperimentArms(
        MutateExperimentArmsRequest::build($customerId, $operations)
            // We want to fetch the draft campaign IDs from the treatment arm, so the easiest
            // way to do that is to have the response return the newly created entities.
            ->setResponseContentType(ResponseContentType::MUTABLE_RESOURCE)
    );
    // Results always return in the order that you specify them in the request.
    // Since we created the treatment arm last, it will be the last result.
    $controlArmResourceName = $response->getResults()[0]->getResourceName();
    $treatmentArm = $response->getResults()[count($operations) - 1];
    print "Created control arm with resource name '$controlArmResourceName'" . PHP_EOL;
    print "Created treatment arm with resource name '{$treatmentArm->getResourceName()}'"
        . PHP_EOL;

    return $treatmentArm->getExperimentArm()->getInDesignCampaigns()[0];
}CreateExperiment.php

Python

def create_experiment_arms(
    client: GoogleAdsClient,
    customer_id: str,
    base_campaign_id: str,
    experiment: str,
) -> str:
    """Creates a control and treatment experiment arms.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        base_campaign_id: the campaign ID to associate with the control arm of
          the experiment.
        experiment: the resource name for an experiment.

    Returns:
        the resource name for the new treatment experiment arm.
    """
    operations: List[ExperimentArmOperation] = []

    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )

    # The "control" arm references an already-existing campaign.
    operation_1: ExperimentArmOperation = client.get_type(
        "ExperimentArmOperation"
    )
    exa_1: ExperimentArm = operation_1.create
    exa_1.control = True
    exa_1.campaigns.append(
        campaign_service.campaign_path(customer_id, base_campaign_id)
    )
    exa_1.experiment = experiment
    exa_1.name = "control arm"
    exa_1.traffic_split = 40
    operations.append(operation_1)

    # In standard campaign experiments, creating the treatment arm automatically
    # generates a draft campaign that you can modify before starting the experiment.
    operation_2: ExperimentArmOperation = client.get_type(
        "ExperimentArmOperation"
    )
    exa_2: ExperimentArm = operation_2.create
    exa_2.control = False
    exa_2.experiment = experiment
    exa_2.name = "experiment arm"
    exa_2.traffic_split = 60
    operations.append(operation_2)

    experiment_arm_service: ExperimentArmServiceClient = client.get_service(
        "ExperimentArmService"
    )
    request: MutateExperimentArmsRequest = client.get_type(
        "MutateExperimentArmsRequest"
    )
    request.customer_id = customer_id
    request.operations = operations
    # We want to fetch the draft campaign IDs from the treatment arm, so the
    # easiest way to do that is to have the response return the newly created
    # entities.
    request.response_content_type = (
        client.enums.ResponseContentTypeEnum.MUTABLE_RESOURCE
    )
    response: MutateExperimentArmsResponse = (
        experiment_arm_service.mutate_experiment_arms(request=request)
    )

    # Results always return in the order that you specify them in the request.
    # Since we created the treatment arm second, it will be the second result.
    control_arm_result: Any = response.results[0]
    treatment_arm_result: Any = response.results[1]

    print(
        f"Created control arm with resource name {control_arm_result.resource_name}"
    )
    print(
        f"Created treatment arm with resource name {treatment_arm_result.resource_name}"
    )

    return treatment_arm_result.experiment_arm.in_design_campaigns[0]create_search_custom_experiment.py

Ruby

def create_experiment_arms(client, customer_id, base_campaign_id, experiment)
  operations = []
  operations << client.operation.create_resource.experiment_arm do |ea|
    # The "control" arm references an already-existing campaign.
    ea.control = true
    ea.campaigns << client.path.campaign(customer_id, base_campaign_id)
    ea.experiment = experiment
    ea.name = 'control arm'
    ea.traffic_split = 40
  end
  operations << client.operation.create_resource.experiment_arm do |ea|
    # The non-"control" arm, also called a "treatment" arm, will automatically
    # generate draft campaigns that you can modify before starting the
    # experiment.
    ea.control = false
    ea.experiment = experiment
    ea.name = 'experiment arm'
    ea.traffic_split = 60
  end

  response = client.service.experiment_arm.mutate_experiment_arms(
    customer_id: customer_id,
    operations: operations,
    # We want to fetch the draft campaign IDs from the treatment arm, so the
    # easiest way to do that is to have the response return the newly created
    # entities.
    response_content_type: :MUTABLE_RESOURCE,
  )

  # Results always return in the order that you specify them in the request.
  # Since we created the treatment arm last, it will be the last result.
  control_arm_result = response.results.first
  treatment_arm_result = response.results.last

  puts "Created control arm with resource name #{control_arm_result.resource_name}."
  puts "Created treatment arm with resource name #{treatment_arm_result.resource_name}."

  treatment_arm_result.experiment_arm.in_design_campaigns.first
endcreate_experiment.rb

Perl

sub create_experiment_arms {
  my ($api_client, $customer_id, $base_campaign_id, $experiment) = @_;

  my $operations = [];
  push @$operations,
    Google::Ads::GoogleAds::V24::Services::ExperimentArmService::ExperimentArmOperation
    ->new({
      create => Google::Ads::GoogleAds::V24::Resources::ExperimentArm->new({
          # The "control" arm references an already-existing campaign.
          control   => "true",
          campaigns => [
            Google::Ads::GoogleAds::V24::Utils::ResourceNames::campaign(
              $customer_id, $base_campaign_id
            )
          ],
          experiment   => $experiment,
          name         => "control arm",
          trafficSplit => 40
        })});

  push @$operations,
    Google::Ads::GoogleAds::V24::Services::ExperimentArmService::ExperimentArmOperation
    ->new({
      create => Google::Ads::GoogleAds::V24::Resources::ExperimentArm->new({
          # The non-"control" arm, also called a "treatment" arm, will automatically
          # generate draft campaigns that you can modify before starting the
          # experiment.
          control      => "false",
          experiment   => $experiment,
          name         => "experiment arm",
          trafficSplit => 60
        })});

  my $response = $api_client->ExperimentArmService()->mutate({
    customerId => $customer_id,
    operations => $operations,
    # We want to fetch the draft campaign IDs from the treatment arm, so the
    # easiest way to do that is to have the response return the newly created
    # entities.
    responseContentType => MUTABLE_RESOURCE
  });

  # Results always return in the order that you specify them in the request.
  # Since we created the treatment arm last, it will be the last result.
  my $control_arm_result   = $response->{results}[0];
  my $treatment_arm_result = $response->{results}[1];

  printf "Created control arm with resource name '%s'.\n",
    $control_arm_result->{resourceName};
  printf "Created treatment arm with resource name '%s'.\n",
    $treatment_arm_result->{resourceName};
  return $treatment_arm_result->{experimentArm}{inDesignCampaigns}[0];
}create_experiment.pl

curl

כמה נקודות שחשוב לשים לב אליהן:

בדיוק קבוצה אחת צריכה לכלול את המאפיין control עם הערך true.
הסכום של traffic_split בכל קבוצות הניסוי חייב להיות 100.
בקבוצת הבקרה צריך לציין קמפיין אחד בדיוק בשדה campaigns.

3. שינוי קמפיינים שמוגדרים כקבוצת הניסוי

כשיוצרים קבוצת ניסוי (כאשר control הוא false), ממשק ה-API יוצר באופן אוטומטי קמפיין טיוטה על סמך קמפיין הבקרה ומאכלס את שם המשאב שלו בשדה in_design_campaigns של קבוצת הניסוי. אפשר להתייחס לקמפיינים האלה שנוצרו בתוך העיצוב כאל קמפיינים רגילים ולשנות אותם בהתאם לשינויים שרוצים לבדוק. קמפיין הבקרה לא יושפע. השינויים האלה מתממשים לקמפיין אמיתי שמוצג למשתמשים כשמתזמנים את הניסוי.

כדי לתזמן את הניסוי, צריך לבצע לפחות שינוי אחד בקמפיין שנמצא בשלב התכנון.

כדי לאחזר את in_design_campaigns של קבוצת ניסוי, אפשר לשלוח שאילתה אל: GoogleAdsService

SELECT experiment_arm.in_design_campaigns
FROM experiment_arm
WHERE experiment_arm.resource_name = "TREATMENT_ARM_RESOURCE_NAME"

תזמון הניסוי

אחרי שיוצרים את הניסוי ואת הזרועות ומשנים את קמפיינים הטיוטה של קבוצת הניסוי, אפשר לתזמן את הניסוי באמצעות ExperimentService.ScheduleExperiment. זו פעולה אסינכרונית שמממשת את הקמפיינים בתהליך העיצוב לקמפיינים בפועל, שמוכנים להצגה ברגע שstart_dateהניסוי מגיע. פרטים על טיפול בפעולות ממושכות מופיעים בקטע שגיאות אסינכרוניות.

דיווח על הניסוי

אחרי שהניסוי יפעל, תוכלו להריץ שאילתות לגבי מדדים כדי להשוות את הביצועים. פרטים נוספים זמינים במדריך הדיווח.

העברה לשלב הבא, קידום או סיום של הניסוי

אחרי שהניסוי פועל מספיק זמן, אפשר לסיים אותו, להעביר אותו לשלב הבא או להשלים אותו באמצעות ExperimentService.

סיום: אם רוצים להפסיק את הניסוי בלי להחיל שינויים, משתמשים באפשרות EndExperiment. קמפיינים לניסוי מפסיקים להציג מודעות, אבל לא מוסרים. זו פעולה סינכרונית.
קידום: אם אתם מרוצים מהביצועים של קבוצת הניסוי ורוצים לשלב את השינויים בקמפיין המקורי, אתם יכולים להשתמש באפשרות PromoteExperiment. הפעולה הזו מעתיקה שינויים מקבוצת הניסוי לקמפיין הבקרה ומפסיקה את הצגת המודעות בקבוצת הניסוי. זוהי פעולה אסינכרונית. פרטים נוספים זמינים במאמר בנושא שגיאות אסינכרוניות. הערה: אי אפשר לקדם ניסויים מסוג PMAX_REPLACEMENT_SHOPPING.
שדרוג חשבון: אם אהבתם את השינויים, אבל אתם רוצים שהם יופיעו בנפרד מהקמפיין המקורי, אתם יכולים להשתמש באפשרות GraduateExperiment. הפעולה הזו תמיר את קמפיין הניסוי לקמפיין רגיל ועצמאי, שהצגת המודעות בו תימשך מחוץ להקשר של הניסוי. קמפיין הבקרה לא משתנה. זו פעולה סינכרונית.

דרישות ספציפיות לסוג

PMAX_REPLACEMENT_SHOPPING:

נדרשות בדיוק שתי קבוצות (קבוצת בקרה אחת וקבוצת ניסוי אחת).
בקבוצת הבקרה צריך לציין קמפיין שופינג אחד בשדה campaigns.
בזרוע הניסוי יש שתי אפשרויות להגדרת הקמפיין למיקסום הביצועים:
- כדי ליצור קמפיין חדש למיקסום הביצועים: משאירים את השדה campaigns של קבוצת הניסוי ריק. ה-API יוצר באופן אוטומטי קמפיין בתוך העיצוב על סמך קמפיין השופינג של קבוצת הבקרה, כפי שמתואר בשלב 3.
- כדי להשתמש בקמפיין קיים למיקסום הביצועים: מציינים את שם המשאב של הקמפיין למיקסום הביצועים בשדה campaigns של זרוע הניסוי. אם בוחרים באפשרות הזו, לא נוצר קמפיין בתהליך העיצוב, ואפשר לדלג על שלב 3.
מומלץ להחריג מההערכה את הנתונים מ-7 הימים הראשונים, כדי לתת לקמפיין זמן לסיים את תקופת ההסתגלות ותקופת הלמידה.
אי אפשר לקדם אותם.

YOUTUBE_CUSTOM:

אפשר להוסיף עד 10 קבוצות ניסוי.
כדי לבדוק נכסים, מגדירים את הערך creative_asset_testing_info בקבוצת הניסוי.

סקירה כללית

ניסויים בתוך קמפיין

ניסויים שמנוהלים על ידי המערכת קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

הגדרה

1. יצירת ניסוי

Java

C#‎

PHP

Python

Ruby

Perl

curl

2. יצירת קבוצות ניסוי

Java

C#‎

PHP

Python

Ruby

Perl

curl

3. שינוי קמפיינים שמוגדרים כקבוצת הניסוי

תזמון הניסוי

דיווח על הניסוי

העברה לשלב הבא, קידום או סיום של הניסוי

דרישות ספציפיות לסוג

ניסויים שמנוהלים על ידי המערכת