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())
                  // 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.
                  .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;
  }
}
CreateSearchCustomExperiment.java

C#‎

private static string CreateExperimentResource(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()}",
        // We specify SearchCustom 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.
        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;
}CreateSearchCustomExperiment.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(
              // In standard campaign experiments, creating the treatment arm automatically
              // generates a draft campaign 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);
  }
}
CreateSearchCustomExperiment.java

C#‎

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.
    // In standard campaign experiments, creating the treatment arm automatically
    // generates a draft campaign 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);
}CreateSearchCustomExperiment.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. שינוי קמפיינים שמוגדרים כקבוצת הניסוי

תזמון הניסוי

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

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

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

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