Eksperymenty zarządzane przez system

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

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

Konfiguracja

Konfigurowanie eksperymentów zarządzanych przez system przebiega w tych etapach:

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

1. Utworzenie eksperymentu

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

Oto przegląd najważniejszych pól w przypadku Experiment:

• name: Każdy eksperyment musi mieć unikalną nazwę.
• description: pole opcjonalne, które możesz wykorzystać w przyszłości. Nie ma to wpływu na przebieg eksperymentu.
• suffix: sufiks zostanie dodany na końcu nazw kampanii eksperymentalnych, aby można było odróżnić je od kampanii kontrolnej. Te pojęcia zostaną dokładniej wyjaśnione w kroku 2.
• type: typ eksperymentu do przeprowadzenia. W przypadku eksperymentów zarządzanych przez system użyj wartości 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 umożliwi Ci sprawdzenie jego bieżącego stanu.
• start_date i end_date: określ, kiedy eksperyment ma się rozpocząć i zakończyć.
• sync_enabled: domyślnie wyłączona. Jeśli ustawisz tę opcję na true, zmiany wprowadzone w pierwotnej kampanii w trakcie trwania eksperymentu będą automatycznie kopiowane 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())
                  .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;
  }
}
CreateExperiment.java
      

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;
}
CreateExperiment.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 przypadku nie podajemy przykładowego kodu REST, ale możesz to zrobić za pomocą ręcznego żądania REST.

Zapoznaj się z dokumentacją interfejsu REST Google Ads API i stronami referencyjnymi dotyczącymi poszczególnych metod. Musisz utworzyć ładunek JSON na podstawie definicji protokołu.

Najważniejsze materiały:

• Korzystanie z interfejsu REST
• Struktura interfejsu REST
• Mapowania pól JSON
• Informacje o konkretnej usłudze i metodzie znajdziesz w dokumentacji API REST.

2. Tworzenie grup eksperymentalnych

Następnie utwórz zasoby ExperimentArm, aby zdefiniować grupy kontrolną i eksperymentalną na potrzeby eksperymentu. Wszystkie grupy muszą zostać utworzone w ramach jednego żądania.

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

Musisz też określić wartość traffic_split, czyli odsetek ruchu kierowanego do każdej gałęzi. 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(
              // 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);
  }
}
CreateExperiment.java
      

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);
}
CreateExperiment.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 przypadku nie podajemy przykładowego kodu REST, ale możesz to zrobić za pomocą ręcznego żądania REST.

Zapoznaj się z dokumentacją interfejsu REST Google Ads API i stronami referencyjnymi dotyczącymi poszczególnych metod. Musisz utworzyć ładunek JSON na podstawie definicji protokołu.

Najważniejsze materiały:

• Korzystanie z interfejsu REST
• Struktura interfejsu REST
• Mapowania pól JSON
• Informacje o konkretnej usłudze i metodzie znajdziesz w dokumentacji API REST.

Kilka najważniejszych informacji:

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

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

3. Modyfikowanie kampanii eksperymentalnych

Gdy tworzysz kampanię eksperymentalną (gdzie control to 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 trakcie projektowania jako zwykłe kampanie i wprowadzać w nich zmiany, które chcesz przetestować. Nie wpłynie to na kampanię kontrolną. Zmiany te są wprowadzane w prawdziwej kampanii, która może wyświetlać reklamy, gdy zaplanujesz eksperyment.

Zanim zaplanujesz eksperyment, musisz wprowadzić co najmniej 1 zmianę w kampanii w trakcie projektowania.

Aby pobrać in_design_campaigns dla grupy eksperymentalnej, możesz wysłać zapytanie: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.

Zaplanuj eksperyment

Po utworzeniu eksperymentu i grup porównawczych oraz zmodyfikowaniu kampanii w wersji roboczej grupy eksperymentalnej możesz zaplanować eksperyment za pomocą ikony ExperimentService.ScheduleExperiment. Jest to operacja asynchroniczna, która przekształca kampanie w fazie projektowania w rzeczywiste kampanie gotowe do wyświetlania reklam po osiągnięciu start_date eksperymentu. Więcej informacji o obsłudze długotrwałych operacji znajdziesz w sekcji Błędy asynchroniczne.

Raport z eksperymentu

Po uruchomieniu eksperymentu możesz wysyłać zapytania o dane, aby porównywać skuteczność. Szczegółowe informacje znajdziesz w przewodniku po raportowaniu.

Przejście na korzystanie, promowanie lub zakończenie eksperymentu

Po odpowiednio długim czasie trwania eksperymentu możesz go zakończyć, promować lub przekształcić w kampanię standardową, korzystając z ikony ExperimentService.

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

Wymagania dotyczące poszczególnych typów

PMAX_REPLACEMENT_SHOPPING:

• Wymaga dokładnie 2 grup (1 kontrolnej i 1 eksperymentalnej).
• W polu campaigns grupy kontrolnej musi być określona 1 kampania produktowa.
• W przypadku grupy eksperymentalnej masz 2 opcje konfigurowania kampanii Performance Max:
  • Aby utworzyć nową kampanię Performance Max: pozostaw puste pole campaigns grupy eksperymentalnej. Interfejs API automatycznie tworzy kampanię w trakcie projektowania na podstawie kontrolnej kampanii produktowej, zgodnie z opisem w kroku 3.
  • Aby użyć istniejącej kampanii PMax: w polu campaigns grupy eksperymentalnej podaj nazwę zasobu kampanii PMax. Jeśli wybierzesz tę opcję, nie zostanie utworzona żadna kampania w trakcie projektowania i możesz pominąć krok 3.
• Zalecamy odrzucenie pierwszych 7 dni statystyk z oceny, aby dać kampanii czas na zakończenie okresu początkowego i nauki.
• Nie można promować.

YOUTUBE_CUSTOM:

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