Thử nghiệm do hệ thống quản lý

Thử nghiệm do hệ thống quản lý được dùng để thử nghiệm A/B các thay đổi bằng cách tạo một hoặc nhiều chiến dịch thử nghiệm có thể sửa đổi chạy song song với một chiến dịch đối chứng gốc. Quy trình này được hỗ trợ cho các giá trị ExperimentType sau đây:

  • SEARCH_CUSTOM: Thử nghiệm tuỳ chỉnh bao gồm các chiến dịch tìm kiếm.
  • DISPLAY_CUSTOM: Thử nghiệm tuỳ chỉnh bao gồm các chiến dịch hiển thị.
  • HOTEL_CUSTOM: Một thử nghiệm tuỳ chỉnh bao gồm các chiến dịch khách sạn.
  • YOUTUBE_CUSTOM: Một thử nghiệm tuỳ chỉnh bao gồm các chiến dịch Video.
  • PMAX_REPLACEMENT_SHOPPING: Một thử nghiệm để kiểm tra hiệu suất của chiến dịch Mua sắm so với chiến dịch Tối đa hoá hiệu suất.

Thiết lập

Quy trình thiết lập thử nghiệm do hệ thống quản lý bao gồm các bước sau:

  1. Tạo một Experiment.
  2. Tạo tài nguyên ExperimentArm cho nhóm đối chứng và nhóm thử nghiệm.
  3. Sửa đổi in_design_campaigns trong nhóm thử nghiệm.

1. Tạo thử nghiệm

Bước đầu tiên trong việc chạy thử nghiệm bằng Google Ads API là tạo một Experiment. Tài nguyên này xác định một số thông tin chính về thử nghiệm mà bạn muốn chạy. Bạn không chỉ định bất kỳ chiến dịch nào tham gia vào thử nghiệm ở bước này.

Sau đây là thông tin tổng quan về một số trường chính của Experiment:

  • name: Mỗi thử nghiệm phải có một tên riêng biệt.
  • description: Một trường không bắt buộc mà bạn có thể dùng để tham chiếu sau này. Không ảnh hưởng đến cách chạy thử nghiệm.
  • suffix: Hậu tố sẽ được thêm vào cuối tên của chiến dịch thử nghiệm để bạn có thể phân biệt các chiến dịch này với chiến dịch đối chứng. Những khái niệm này sẽ được giải thích thêm ở bước 2.
  • type: Loại thử nghiệm cần chạy. Đối với các thử nghiệm do hệ thống quản lý, hãy sử dụng SEARCH_CUSTOM, DISPLAY_CUSTOM, HOTEL_CUSTOM, YOUTUBE_CUSTOM hoặc PMAX_REPLACEMENT_SHOPPING.
  • status: Khi tạo một thử nghiệm, hãy đặt trường này thành SETUP. Sau đó, khi bạn bắt đầu thử nghiệm, trường này sẽ cho phép bạn kiểm tra trạng thái hiện tại.
  • start_date và end_date: Chỉ định thời điểm bắt đầu và kết thúc thử nghiệm.
  • sync_enabled: Tắt theo mặc định. Nếu bạn đặt thành true, thì những thay đổi bạn thực hiện cho chiến dịch gốc trong khi thử nghiệm đang chạy sẽ tự động được sao chép sang chiến dịch thử nghiệm. Tìm hiểu thêm.

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;
  }
}

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;
}

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;
}

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

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

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;
}

curl

2. Tạo nhóm thử nghiệm

Tiếp theo, hãy tạo tài nguyên ExperimentArm để xác định nhóm đối chứng và nhóm thử nghiệm cho thử nghiệm. Bạn phải tạo tất cả các nhóm thử nghiệm trong một yêu cầu duy nhất.

Mỗi thử nghiệm phải có chính xác một nhóm đối chứng và một hoặc nhiều nhóm thử nghiệm. Nhóm đối chứng xác định chiến dịch căn bản để so sánh và mỗi nhóm can thiệp sẽ tạo ra một chiến dịch mới mà bạn có thể thực hiện các thay đổi để thử nghiệm.

Bạn cũng phải chỉ định traffic_split, là tỷ lệ phần trăm lưu lượng truy cập được chuyển hướng đến từng nhóm thử nghiệm. Tổng mức phân tách lưu lượng truy cập trên tất cả các nhóm phải là 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);
  }
}

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);
}

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];
}

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]

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

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];
}

curl

Một số điểm chính:

  • Bạn phải đặt control thành true cho đúng một nhóm.
  • Tổng traffic_split của tất cả các nhóm phải bằng 100.
  • Nhóm đối chứng phải chỉ định đúng một chiến dịch trong trường campaigns.

3. Sửa đổi chiến dịch thử nghiệm

Khi bạn tạo một nhóm can thiệp (trong đó control là false), API sẽ tự động tạo một chiến dịch dự thảo dựa trên chiến dịch đối chứng và điền sẵn tên tài nguyên của chiến dịch đó vào trường in_design_campaigns của nhóm can thiệp. Bạn có thể coi những chiến dịch trong thiết kế này là chiến dịch thông thường và sửa đổi chúng bằng những thay đổi mà bạn muốn thử nghiệm. Chiến dịch đối chứng sẽ không bị ảnh hưởng. Những thay đổi này sẽ được hiện thực hoá thành một chiến dịch thực tế, có thể phân phát khi bạn lên lịch cho thử nghiệm.

Bạn phải thực hiện ít nhất một thay đổi đối với chiến dịch đang được thiết kế thì mới có thể lên lịch cho thử nghiệm.

Để truy xuất in_design_campaigns cho một nhóm can thiệp, bạn có thể truy vấn GoogleAdsService:

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

Lên lịch thử nghiệm

Sau khi tạo thử nghiệm và các nhóm thử nghiệm, đồng thời sửa đổi các chiến dịch dự thảo thử nghiệm, bạn có thể lên lịch cho thử nghiệm bằng cách sử dụng ExperimentService.ScheduleExperiment. Đây là một thao tác không đồng bộ, hiện thực hoá các chiến dịch trong thiết kế thành các chiến dịch thực tế, sẵn sàng phân phát khi start_date của thử nghiệm đến. Hãy xem phần Lỗi không đồng bộ để biết thông tin chi tiết về cách xử lý các thao tác diễn ra trong thời gian dài.

Báo cáo về thử nghiệm

Sau khi thử nghiệm đang chạy, bạn có thể truy vấn các chỉ số để so sánh hiệu suất. Hãy xem Hướng dẫn báo cáo để biết thông tin chi tiết.

Chuyển dần lên, quảng bá hoặc kết thúc thử nghiệm

Sau khi chạy thử nghiệm trong một khoảng thời gian đủ dài, bạn có thể chọn kết thúc, quảng bá hoặc chuyển dần lên thử nghiệm bằng cách sử dụng biểu tượng ExperimentService.

  • Kết thúc: Nếu bạn muốn dừng thử nghiệm mà không áp dụng các thay đổi, hãy sử dụng EndExperiment. Các chiến dịch thử nghiệm sẽ ngừng phân phát nhưng không bị xoá. Đây là một thao tác đồng bộ.
  • Quảng bá: Nếu bạn hài lòng với hiệu suất của nhóm thử nghiệm và muốn kết hợp các thay đổi vào chiến dịch gốc, hãy sử dụng biểu tượng PromoteExperiment. Thao tác này sẽ sao chép các thay đổi từ nhóm thử nghiệm sang chiến dịch đối chứng và dừng phân phát nhóm thử nghiệm. Đây là một thao tác không đồng bộ; hãy xem phần Lỗi không đồng bộ để biết thông tin chi tiết. Lưu ý: Bạn không thể quảng bá các thử nghiệm thuộc loại PMAX_REPLACEMENT_SHOPPING.
  • Tách riêng: Nếu bạn thích những thay đổi này nhưng muốn tách riêng với chiến dịch ban đầu, hãy sử dụng GraduateExperiment. Thao tác này sẽ chuyển chiến dịch thử nghiệm thành một chiến dịch độc lập, tiêu chuẩn và tiếp tục phân phát bên ngoài bối cảnh của thử nghiệm. Chiến dịch đối chứng không được sửa đổi. Đây là một thao tác đồng bộ.

Yêu cầu theo từng loại

PMAX_REPLACEMENT_SHOPPING:

  • Cần có đúng 2 nhóm (một nhóm đối chứng, một nhóm thử nghiệm).
  • Nhóm đối chứng phải chỉ định một chiến dịch Mua sắm trong trường campaigns.
  • Đối với nhóm can thiệp, bạn có 2 lựa chọn để thiết lập chiến dịch Tối đa hoá hiệu suất:
    • Để tạo một chiến dịch Tối đa hoá hiệu suất mới: Để trống trường campaigns của nhóm thử nghiệm. API sẽ tự động tạo một chiến dịch trong thiết kế dựa trên chiến dịch Mua sắm kiểm soát, như mô tả trong Bước 3.
    • Để sử dụng một chiến dịch Tối đa hoá hiệu suất hiện có: Chỉ định tên tài nguyên của chiến dịch Tối đa hoá hiệu suất trong trường campaigns của nhóm thử nghiệm. Nếu chọn lựa chọn này, bạn sẽ không tạo chiến dịch trong thiết kế và có thể bỏ qua Bước 3.
  • Bạn nên loại bỏ 7 ngày đầu tiên của số liệu thống kê khỏi quá trình đánh giá để chiến dịch có thời gian hoàn tất giai đoạn chạy đà và học.
  • Không thể quảng bá.

YOUTUBE_CUSTOM:

  • Hỗ trợ tối đa 10 nhóm.
  • Để thử nghiệm các thành phần, hãy đặt creative_asset_testing_info cho nhóm thử nghiệm.