การทดสอบที่จัดการโดยระบบ

การทดสอบที่ระบบจัดการใช้เพื่อทดสอบ A/B การเปลี่ยนแปลงโดยการสร้างแคมเปญทดสอบที่แก้ไขได้อย่างน้อย 1 รายการซึ่งทํางานควบคู่ไปกับแคมเปญควบคุมเดิม เวิร์กโฟลว์นี้รองรับค่าต่อไปนี้ ExperimentType

• SEARCH_CUSTOM: การทดสอบที่กำหนดเองซึ่งประกอบด้วยแคมเปญ Search
• DISPLAY_CUSTOM: การทดสอบที่กําหนดเองซึ่งประกอบด้วยแคมเปญ Display
• HOTEL_CUSTOM: การทดสอบที่กำหนดเองซึ่งประกอบด้วยแคมเปญโรงแรม
• YOUTUBE_CUSTOM: การทดสอบที่กําหนดเองซึ่งประกอบด้วยแคมเปญวิดีโอ
• PMAX_REPLACEMENT_SHOPPING: การทดสอบเพื่อดูประสิทธิภาพของแคมเปญ Shopping เทียบกับ Performance Max

ตั้งค่า

การตั้งค่าการทดสอบที่ระบบจัดการจะทำตามขั้นตอนต่อไปนี้

1. สร้าง Experiment
2. สร้างแหล่งข้อมูล ExperimentArm สำหรับกลุ่มควบคุมและกลุ่มทดสอบ
3. แก้ไข 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.V25.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_name
create_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
end
create_experiment.rb
      

Perl

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

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

  my $operation =
    Google::Ads::GoogleAds::V25::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

หมายเหตุ: แม้ว่าเราจะไม่ได้ให้ตัวอย่างโค้ด REST โดยตรงสำหรับขั้นตอนนี้ แต่คุณก็ทำได้โดยใช้คำขอ REST ด้วยตนเอง

โปรดดูเอกสารประกอบเกี่ยวกับอินเทอร์เฟซ REST ของ Google Ads API และหน้าอ้างอิงเฉพาะเมธอด คุณจะต้องสร้างเพย์โหลด JSON ตามคำจำกัดความของ Proto

แหล่งข้อมูลสำคัญ

• การใช้ REST
• โครงสร้างอินเทอร์เฟซ REST
• การแมปฟิลด์ JSON
• โปรดดูบริการและเมธอดที่เฉพาะเจาะจงในเอกสารอ้างอิง REST API

2. สร้างกลุ่มทดสอบ

จากนั้นสร้างทรัพยากร ExperimentArm เพื่อกําหนด กลุ่มควบคุมและกลุ่มทดสอบสําหรับการทดสอบ ต้องสร้างกลุ่มทั้งหมดในคำขอเดียว

การทดสอบแต่ละรายการต้องมีกลุ่มควบคุม 1 กลุ่มและกลุ่มทดสอบอย่างน้อย 1 กลุ่ม กลุ่มควบคุมจะระบุแคมเปญพื้นฐานเพื่อใช้ในการเปรียบเทียบ และกลุ่มทดสอบแต่ละกลุ่มจะส่งผลให้เกิดแคมเปญใหม่ที่คุณสามารถทำการเปลี่ยนแปลงเพื่อทดสอบได้

นอกจากนี้ คุณต้องระบุ 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.V25.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
end
create_experiment.rb
      

Perl

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

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

  push @$operations,
    Google::Ads::GoogleAds::V25::Services::ExperimentArmService::ExperimentArmOperation
    ->new({
      create => Google::Ads::GoogleAds::V25::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

หมายเหตุ: แม้ว่าเราจะไม่ได้ให้ตัวอย่างโค้ด REST โดยตรงสำหรับขั้นตอนนี้ แต่คุณก็ทำได้โดยใช้คำขอ REST ด้วยตนเอง

โปรดดูเอกสารประกอบเกี่ยวกับอินเทอร์เฟซ REST ของ Google Ads API และหน้าอ้างอิงเฉพาะเมธอด คุณจะต้องสร้างเพย์โหลด JSON ตามคำจำกัดความของ Proto

แหล่งข้อมูลสำคัญ

• การใช้ REST
• โครงสร้างอินเทอร์เฟซ REST
• การแมปฟิลด์ JSON
• โปรดดูบริการและเมธอดที่เฉพาะเจาะจงในเอกสารอ้างอิง REST API

ประเด็นสำคัญบางส่วน

• ต้องมีกลุ่มทดสอบ 1 กลุ่มที่ตั้งค่า control เป็น true
• traffic_split ต้องรวมกันได้ 100 ในทุกกลุ่ม
• กลุ่มควบคุมต้องระบุแคมเปญ 1 รายการในฟิลด์ campaigns

หมายเหตุ: คุณไม่สามารถใช้การล้มเหลวบางส่วน เมื่อสร้างกลุ่มการทดสอบ

3. แก้ไขแคมเปญทดสอบ

เมื่อคุณสร้างกลุ่มทดสอบ (เมื่อ control เป็น false) API จะสร้างแคมเปญร่างโดยอัตโนมัติตามแคมเปญควบคุมและป้อนชื่อทรัพยากรในฟิลด์ in_design_campaigns ของกลุ่มทดสอบ คุณสามารถถือว่าแคมเปญในดีไซน์เหล่านี้เป็นแคมเปญปกติและแก้ไข แคมเปญด้วยการเปลี่ยนแปลงที่ต้องการทดสอบ แคมเปญควบคุมจะไม่ได้รับผลกระทบ การเปลี่ยนแปลงเหล่านี้จะกลายเป็นแคมเปญจริงที่แสดงได้เมื่อคุณกําหนดเวลาการทดสอบ

คุณต้องทำการเปลี่ยนแปลงแคมเปญที่อยู่ระหว่างการออกแบบอย่างน้อย 1 รายการก่อนจึงจะ กำหนดเวลาการทดสอบได้

หากต้องการดึงข้อมูล in_design_campaigns สำหรับกลุ่มทดสอบ คุณสามารถค้นหา GoogleAdsServiceได้โดยใช้คำสั่งต่อไปนี้

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

เคล็ดลับ: ระบบจะแสดงแคมเปญฉบับร่างก็ต่อเมื่อคุณเพิ่มinclude_drafts=true พารามิเตอร์ลงในการค้นหา

กำหนดเวลาการทดสอบ

หลังจากสร้างการทดสอบและกลุ่มต่างๆ รวมถึงแก้ไขแคมเปญแบบร่างทดสอบแล้ว คุณสามารถกําหนดเวลาการทดสอบได้โดยใช้ ExperimentService.ScheduleExperiment นี่คือการดำเนินการแบบไม่พร้อมกันซึ่งจะเปลี่ยนแคมเปญในดีไซน์ให้เป็น แคมเปญจริงที่พร้อมแสดงเมื่อstart_dateของการทดสอบมาถึง ดูรายละเอียดเกี่ยวกับการจัดการการดำเนินการที่ใช้เวลานาน ได้ที่ข้อผิดพลาดแบบไม่พร้อมกัน

รายงานผลการทดสอบ

เมื่อการทดสอบทํางานแล้ว คุณสามารถค้นหาเมตริกเพื่อเปรียบเทียบ ประสิทธิภาพได้ ดูรายละเอียดได้ที่คำแนะนำในการรายงาน

จบการทดสอบ โปรโมต หรือสิ้นสุดการทดสอบ

หลังจากปล่อยให้การทดสอบทํางานเป็นระยะเวลาที่เพียงพอแล้ว คุณสามารถเลือกที่จะสิ้นสุด โปรโมต หรือจบการทดสอบได้โดยใช้ ExperimentService

• สิ้นสุด: หากต้องการหยุดการทดสอบโดยไม่ใช้การเปลี่ยนแปลง ให้ใช้ EndExperiment แคมเปญทดสอบจะหยุดแสดง แต่จะไม่ถูกนำออก นี่คือการดำเนินการแบบซิงโครนัส
• โปรโมต: หากพอใจกับประสิทธิภาพของกลุ่มทดสอบและต้องการรวมการเปลี่ยนแปลงเข้ากับแคมเปญเดิม ให้ใช้ PromoteExperiment ซึ่งจะคัดลอกการเปลี่ยนแปลงจากกลุ่มทดสอบไปยังแคมเปญควบคุมและหยุด ไม่ให้กลุ่มทดสอบแสดง นี่เป็นการดำเนินการแบบอะซิงโครนัส โปรดดูรายละเอียดในข้อผิดพลาดแบบอะซิงโครนัส หมายเหตุ: โปรโมตการทดสอบประเภท PMAX_REPLACEMENT_SHOPPING ไม่ได้
• เปลี่ยนไปใช้: หากชอบการเปลี่ยนแปลง แต่ต้องการให้การเปลี่ยนแปลงแยกจากแคมเปญเดิม ให้ใช้GraduateExperiment ซึ่งจะเปลี่ยนแคมเปญทดสอบให้เป็นแคมเปญมาตรฐานที่เป็นอิสระ ซึ่งจะแสดงต่อไปนอกบริบทของการทดสอบ ระบบจะไม่แก้ไขแคมเปญควบคุม นี่คือการดำเนินการแบบซิงโครนัส

ข้อกำหนดเฉพาะประเภท

PMAX_REPLACEMENT_SHOPPING:

• ต้องมี 2 กลุ่ม (กลุ่มควบคุม 1 กลุ่มและกลุ่มทดสอบ 1 กลุ่ม)
• กลุ่มควบคุมต้องระบุแคมเปญ Shopping 1 รายการในช่อง campaigns
• สําหรับกลุ่มทดสอบ คุณมี 2 ตัวเลือกในการตั้งค่าแคมเปญ Performance Max ดังนี้
  • หากต้องการสร้างแคมเปญ PMax ใหม่ ให้เว้นช่องcampaigns ของกลุ่มทดสอบไว้ API จะสร้างแคมเปญในดีไซน์โดยอัตโนมัติตามแคมเปญ Shopping ที่ควบคุม ตามที่อธิบายไว้ในขั้นตอนที่ 3
  • หากต้องการใช้แคมเปญ PMax ที่มีอยู่ ให้ระบุชื่อทรัพยากรของ แคมเปญ PMax ในช่อง campaigns ของกลุ่มทดสอบ หากเลือกตัวเลือกนี้ ระบบจะไม่สร้างแคมเปญในดีไซน์ และคุณสามารถข้ามขั้นตอนที่ 3 ได้
• เราขอแนะนำให้ทิ้งสถิติ 7 วันแรกจากการประเมินเพื่อให้แคมเปญมีเวลาสิ้นสุดระยะการเพิ่มประสิทธิภาพและระยะการเรียนรู้
• โปรโมตไม่ได้

YOUTUBE_CUSTOM:

• รองรับกลุ่มทดสอบสูงสุด 10 กลุ่ม
• หากต้องการทดสอบชิ้นงาน ให้ตั้งค่า creative_asset_testing_info ในกลุ่มทดสอบ