Eksperymenty zarządzane przez system

Eksperymenty zarządzane przez system służą do testowania zmian A/B poprzez utworzenie co najmniej 1 kampanii eksperymentalnej, którą można modyfikować i która jest uruchamiana równolegle z pierwotną kampanią kontrolną. Ten proces jest obsługiwany w przypadku tych ExperimentType wartości:

• SEARCH_CUSTOM: eksperyment niestandardowy obejmujący kampanie w sieci wyszukiwania.
• DISPLAY_CUSTOM: eksperyment niestandardowy obejmujący kampanie w sieci reklamowej.
• HOTEL_CUSTOM: eksperyment niestandardowy obejmujący kampanie reklam hoteli.
• YOUTUBE_CUSTOM: eksperyment niestandardowy obejmujący kampanie wideo.
• PMAX_REPLACEMENT_SHOPPING: eksperyment, który pozwala sprawdzić skuteczność kampanii produktowych w porównaniu z kampaniami Performance Max.

Konfiguracja

Konfiguracja eksperymentów zarządzanych przez system obejmuje te kroki:

1. Utwórz Experiment.
2. Utwórz zasoby ExperimentArm dla grupy kontrolnej i eksperymentalnej.
3. Zmodyfikuj in_design_campaigns w grupach eksperymentalnych.

1. Utwórz eksperyment

Pierwszym krokiem w przeprowadzaniu eksperymentu za pomocą interfejsu Google Ads API jest utworzenie Experiment. Ten zasób określa najważniejsze informacje o eksperymencie, który chcesz przeprowadzić. Na tym etapie nie określasz żadnej z kampanii biorących udział w eksperymencie.

Oto omówienie najważniejszych pól Experiment:

• name: każdy eksperyment musi mieć unikalną nazwę.
• description: pole opcjonalne, którego możesz użyć do późniejszego odwoływania się. Nie ma wpływu na sposób przeprowadzania eksperymentu.
• suffix: sufiks zostanie dodany na końcu nazw kampanii eksperymentalnych, dzięki czemu będzie można je odróżnić od kampanii kontrolnej. Te pojęcia zostaną dokładniej wyjaśnione w kroku 2.
• type: rodzaj eksperymentu, który ma zostać przeprowadzony. W przypadku eksperymentów zarządzanych przez system użyj SEARCH_CUSTOM, DISPLAY_CUSTOM, HOTEL_CUSTOM, YOUTUBE_CUSTOM lub PMAX_REPLACEMENT_SHOPPING.
• status: podczas tworzenia eksperymentu ustaw to pole na SETUP. Później, gdy rozpoczniesz eksperyment, to pole pozwoli Ci sprawdzić jego bieżący stan.
• start_date i end_date: określ, kiedy eksperyment ma się rozpocząć i zakończyć.
• sync_enabled: domyślnie wyłączone. Jeśli ustawisz wartość true, zmiany wprowadzone w pierwotnej kampanii w trakcie trwania eksperymentu zostaną automatycznie skopiowane do kampanii z eksperymentem. Więcej informacji.

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_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::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

Uwaga: w tym kroku nie podajemy bezpośredniego przykładu kodu REST, ale możesz to zrobić za pomocą ręcznego żądania REST.

Zapoznaj się z dokumentacją interfejsu Google Ads API REST i stronami referencyjnymi dotyczącymi poszczególnych metod. Będziesz musiał(-a) utworzyć ładunek JSON na podstawie definicji proto.

Key Resources:

• Using REST
• REST Interface Structure
• JSON Field Mappings
• Consult the REST API Reference for the specific service and method.

2. Tworzenie grup eksperymentalnych

Następnie utwórz ExperimentArm zasoby, aby zdefiniować grupę kontrolną i eksperymentalną. Wszystkie grupy muszą zostać utworzone w jednym żądaniu.

Każdy eksperyment musi mieć dokładnie 1 grupę kontrolną i co najmniej 1 grupę eksperymentalną. Grupa kontrolna identyfikuje kampanię podstawową do porównania, a każda grupa eksperymentalna tworzy nową kampanię, w której możesz wprowadzać zmiany do testowania.

Musisz też określić traffic_split, czyli procent ruchu kierowanego do każdej grupy. Suma podziałów ruchu we wszystkich grupach musi wynosić 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
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::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

Uwaga: w tym kroku nie podajemy bezpośredniego przykładu kodu REST, ale możesz to zrobić za pomocą ręcznego żądania REST.

Zapoznaj się z dokumentacją interfejsu Google Ads API REST i stronami referencyjnymi dotyczącymi poszczególnych metod. Będziesz musiał(-a) utworzyć ładunek JSON na podstawie definicji proto.

Key Resources:

• Using REST
• REST Interface Structure
• JSON Field Mappings
• Consult the REST API Reference for the specific service and method.

Kilka najważniejszych kwestii:

• Dokładnie 1 grupa musi mieć ustawioną wartość control na true.
• Wartość traffic_split musi wynosić 100 we wszystkich grupach.
• Grupa kontrolna musi określać dokładnie 1 kampanię w polu campaigns.

Uwaga: podczas tworzenia grup eksperymentalnych nie można używać częściowego niepowodzenia.

3. Modyfikowanie kampanii eksperymentalnych

Gdy tworzysz kampanię eksperymentalną (w której control ma wartość false), interfejs API automatycznie tworzy roboczą wersję kampanii na podstawie kampanii kontrolnej i wypełnia jej nazwę zasobu w polu in_design_campaigns kampanii eksperymentalnej. Możesz traktować te kampanie w wersji roboczej jako zwykłe kampanie i modyfikować je za pomocą zmian, które chcesz przetestować. Nie będzie to miało wpływu na kampanię kontrolną. Te zmiany są realizowane w postaci rzeczywistej kampanii, która może wyświetlać reklamy, gdy zaplanujesz eksperyment.

Zanim zaplanujesz eksperyment, musisz wprowadzić co najmniej 1 zmianę w kampanii w wersji roboczej.

Aby pobrać in_design_campaigns dla grupy eksperymentalnej, możesz wysłać zapytanie do GoogleAdsService:

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

Wskazówka: kampanie w wersji roboczej są zwracane tylko wtedy, gdy do zapytania dodasz include_drafts=true parametr.

Planowanie eksperymentu

Po utworzeniu eksperymentu i grup oraz zmodyfikowaniu kampanii eksperymentalnych w wersji roboczej możesz zaplanować eksperyment za pomocą ExperimentService.ScheduleExperiment. Jest to operacja asynchroniczna, która przekształca kampanie w wersji roboczej w rzeczywiste kampanie gotowe do wyświetlania reklam po nadejściu start_date eksperymentu. Szczegółowe informacje o obsłudze operacji długotrwałych znajdziesz w sekcji Błędy asynchroniczne.

Raportowanie eksperymentu

Gdy eksperyment jest uruchomiony, możesz wysyłać zapytania o dane, aby porównać skuteczność. Szczegółowe informacje znajdziesz w przewodniku po raportowaniu.

Zakończenie, promowanie lub ukończenie eksperymentu

Po odpowiednio długim czasie trwania eksperymentu możesz go zakończyć, promować lub ukończyć za pomocą ExperimentService.

• Zakończ: jeśli chcesz zatrzymać eksperyment bez wprowadzania zmian, użyj EndExperiment. Kampanie eksperymentalne przestaną wyświetlać reklamy, ale nie zostaną usunięte. Jest to operacja synchroniczna.
• Promuj: jeśli jesteś zadowolony(-a) ze skuteczności grupy eksperymentalnej i chcesz wprowadzić zmiany w pierwotnej kampanii, użyj PromoteExperiment. Spowoduje to skopiowanie zmian z grupy eksperymentalnej do kampanii kontrolnej i zatrzymanie wyświetlania reklam w grupie eksperymentalnej. Jest to operacja asynchroniczna. Więcej informacji znajdziesz w sekcji Błędy asynchroniczne. Uwaga: nie można promować eksperymentów typu PMAX_REPLACEMENT_SHOPPING.
• Ukończ: jeśli zmiany Ci się podobają, ale chcesz, aby istniały oddzielnie od pierwotnej kampanii, użyj GraduateExperiment. Spowoduje to przekształcenie kampanii eksperymentalnej w standardową, niezależną kampanię, która będzie nadal wyświetlać reklamy poza kontekstem eksperymentu. Kampania kontrolna nie zostanie zmodyfikowana. Jest to operacja synchroniczna.

Wymagania dotyczące poszczególnych typów

PMAX_REPLACEMENT_SHOPPING:

• Wymaga dokładnie 2 grup (1 kontrolnej i 1 eksperymentalnej).
• Grupa kontrolna musi określać 1 kampanię produktową w polu campaigns.
• W przypadku grupy eksperymentalnej masz 2 opcje konfiguracji kampanii Performance Max:
  • Aby utworzyć nową kampanię Performance Max: pozostaw puste pole campaigns grupy eksperymentalnej. Interfejs API automatycznie utworzy kampanię w wersji roboczej na podstawie kampanii produktowej w grupie kontrolnej, jak opisano w kroku 3.
  • Aby użyć istniejącej kampanii Performance Max: określ nazwę zasobu kampanii Performance Max w polu campaigns grupy eksperymentalnej. Jeśli wybierzesz tę opcję, nie zostanie utworzona żadna kampania w wersji roboczej i możesz pominąć krok 3.
• Zalecamy odrzucenie pierwszych 7 dni statystyk z oceny, aby dać kampanii czas na zakończenie fazy rozruchu i nauki.
• Nie można promować.

YOUTUBE_CUSTOM:

• Obsługuje maksymalnie 10 grup.
• Aby przetestować komponenty, ustaw creative_asset_testing_info w grupie eksperymentalnej.