Sistem tarafından yönetilen denemeler

Sistem tarafından yönetilen denemeler, orijinal bir kontrol kampanyasıyla birlikte yayınlanan bir veya daha fazla değiştirilebilir değerlendirme kampanyası oluşturarak değişiklikleri A/B testine tabi tutmak için kullanılır. Bu iş akışı aşağıdaki ExperimentType değerleri için desteklenir:

  • SEARCH_CUSTOM: Arama ağı kampanyalarından oluşan özel bir deneme.
  • DISPLAY_CUSTOM: Görüntülü Reklam Ağı kampanyalarından oluşan özel bir deneme.
  • HOTEL_CUSTOM: Otel kampanyalarından oluşan özel bir deneme.
  • YOUTUBE_CUSTOM: Video kampanyalarından oluşan özel bir deneme.
  • PMAX_REPLACEMENT_SHOPPING: Alışveriş kampanyalarınızın Maksimum Performans'a kıyasla nasıl performans gösterdiğini test etmeye yönelik bir deneme.

Kurulum

Sistem tarafından yönetilen denemelerin kurulumu aşağıdaki adımlardan oluşur:

  1. Experiment oluşturun.
  2. Kontrol ve deneme için ExperimentArm kaynakları oluşturun.
  3. Deney kollarındaki in_design_campaigns değerini değiştirin.

1. Deneme oluşturun

Google Ads API'yi kullanarak bir deneme çalıştırmanın ilk adımı Experiment oluşturmaktır. Bu kaynak, çalıştırmak istediğiniz deneme hakkında bazı önemli bilgileri tanımlar. Bu adımda denemeye dahil olan kampanyalardan herhangi birini belirtmezsiniz.

Experiment için bazı önemli alanlara genel bir bakış:

  • name: Her denemenin benzersiz bir adı olmalıdır.
  • description: Daha sonra başvurmak için kullanabileceğiniz isteğe bağlı bir alan. Denemenin çalıştırılma şeklini etkilemez.
  • suffix: Sonek, deney kampanyalarının adlarının sonuna eklenir. Böylece bu kampanyaları kontrol kampanyasından ayırt edebilirsiniz. Bu kavramlar 2. adımda daha ayrıntılı olarak açıklanacaktır.
  • type: Hangi tür denemenin çalıştırılacağı. Sistem tarafından yönetilen denemeler için SEARCH_CUSTOM, DISPLAY_CUSTOM, HOTEL_CUSTOM, YOUTUBE_CUSTOM veya PMAX_REPLACEMENT_SHOPPING değerini kullanın.
  • status: Deneme oluştururken bu alanı SETUP olarak ayarlayın. Daha sonra, denemeye başladığınızda bu alan mevcut durumu kontrol etmenize olanak tanır.
  • start_date ve end_date: Denemenin ne zaman başlayıp biteceğini belirtin.
  • sync_enabled: Varsayılan olarak devre dışıdır. true olarak ayarlanırsa denemeniz çalışırken orijinal kampanyada yapılan değişiklikler otomatik olarak deneme kampanyasına kopyalanır. Daha fazla bilgi

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. Deneme kolları oluşturma

Ardından, denemenin kontrol ve değerlendirme gruplarını tanımlamak için ExperimentArm kaynakları oluşturun. Tüm kollar tek bir istekte oluşturulmalıdır.

Her denemede tam olarak bir kontrol kolu ve bir veya daha fazla değerlendirme kolu olmalıdır. Kontrol kolu, karşılaştırma için ana kampanyayı tanımlar ve her bir deney kolu, test etmek için değişiklik yapabileceğiniz yeni bir kampanya oluşturur.

Ayrıca, her kola yönlendirilen trafik yüzdesi olan traffic_split değerini de belirtmeniz gerekir. Tüm kollardaki trafik bölünmelerinin toplamı 100 olmalıdır.

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

Önemli noktalar:

  • Tam olarak bir kolda control, true olarak ayarlanmalıdır.
  • traffic_split, tüm kollarda toplamda 100 olmalıdır.
  • Kontrol kolu, campaigns alanında tam olarak bir kampanya belirtmelidir.

3. Deney kampanyalarını değiştirme

Bir deney kolu oluşturduğunuzda (burada control, false olur), API, kontrol kampanyasına dayalı bir taslak kampanya oluşturur ve kaynak adını deney kolunun in_design_campaigns alanına girer. Bu tasarım içi kampanyaları normal kampanyalar gibi değerlendirebilir ve test etmek istediğiniz değişikliklerle değiştirebilirsiniz. Kontrol kampanyası etkilenmez. Bu değişiklikler, denemeyi planladığınızda gerçek ve yayınlanabilir bir kampanyaya dönüştürülür.

Denemeyi planlayabilmeniz için tasarım içi kampanyada en az bir değişiklik yapılması gerekir.

Bir deney kolu için in_design_campaigns değerini almak üzere GoogleAdsService sorgusunu kullanabilirsiniz:

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

Denemeyi planlama

Denemeyi ve kolları oluşturup deney taslağı kampanyalarını değiştirdikten sonra ExperimentService.ScheduleExperiment kullanarak denemeyi planlayabilirsiniz. Bu, tasarım aşamasındaki kampanyaları, denemenin start_date geldiğinde yayınlanmaya hazır gerçek kampanyalara dönüştüren eşzamansız bir işlemdir. Uzun süren işlemlerin işlenmesiyle ilgili ayrıntılar için Asenkron hatalar başlıklı makaleye bakın.

Deneme hakkında rapor oluşturma

Deneme yayınlandıktan sonra performansı karşılaştırmak için metrikleri sorgulayabilirsiniz. Ayrıntılar için Raporlama kılavuzu'na bakın.

Denemeyi tamamlama, tanıtma veya sonlandırma

Denemenin yeterli süre boyunca çalışmasına izin verdikten sonra ExperimentService simgesini kullanarak denemeyi sonlandırabilir, tanıtabilir veya son test aşamasına geçirebilirsiniz.

  • Sonlandır: Değişiklikleri uygulamadan denemeyi durdurmak istiyorsanız EndExperiment simgesini kullanın. Deney kampanyalarının yayını durdurulur ancak kampanyalar kaldırılmaz. Bu işlem eşzamanlıdır.
  • Tanıtım: Deney kolunun performansından memnunsanız ve değişiklikleri orijinal kampanyanıza dahil etmek istiyorsanız PromoteExperiment simgesini kullanın. Bu işlem, deney kolundaki değişiklikleri kontrol kampanyasına kopyalar ve deney kolunun yayınlanmasını durdurur. Bu eşzamansız bir işlemdir. Ayrıntılar için Eşzamansız hatalar bölümüne bakın. Not: PMAX_REPLACEMENT_SHOPPING türündeki denemeler tanıtılamaz.
  • Tamamla: Değişiklikleri beğendiyseniz ancak orijinal kampanyadan ayrı olarak bulunmalarını istiyorsanız GraduateExperiment simgesini kullanın. Bu işlem, deney kampanyasını standart ve bağımsız bir kampanyaya dönüştürür. Bu kampanya, deney bağlamı dışında yayınlanmaya devam eder. Kontrol kampanyası değiştirilmez. Bu işlem eşzamanlıdır.

Türe özgü koşullar

PMAX_REPLACEMENT_SHOPPING:

  • Tam olarak iki kol (bir kontrol, bir değerlendirme) gerektirir.
  • Kontrol kolu, campaigns alanında bir Alışveriş kampanyası belirtmelidir.
  • Deney kolu için Maksimum Performans kampanyasını oluşturma konusunda iki seçeneğiniz vardır:
    • Yeni bir Maksimum Performans kampanyası oluşturmak için: Deney kolunun campaigns alanını boş bırakın. API, 3. adımda açıklandığı gibi kontrol Alışveriş kampanyasına dayalı olarak otomatik bir tasarım içi kampanya oluşturur.
    • Mevcut bir Maksimum Performans kampanyasını kullanmak için: Değerlendirme kolunun campaigns alanında Maksimum Performans kampanyasının kaynak adını belirtin. Bu seçeneği belirlerseniz tasarım içi kampanya oluşturulmaz ve 3. adımı atlayabilirsiniz.
  • Kampanyanın öğrenme dönemini tamamlaması için istatistiklerin ilk 7 gününü değerlendirmenizin dışında bırakmanız önerilir.
  • Tanıtılamaz.

YOUTUBE_CUSTOM:

  • En fazla 10 kol desteklenir.
  • Öğeleri test etmek için deneme kolunda creative_asset_testing_info seçeneğini ayarlayın.
Önceki
Genel bakış
Sonraki
Kampanya içi denemeler