Vom System verwaltete Tests

Bei systemverwalteten Tests werden Änderungen per A/B-Test geprüft. Dazu werden eine oder mehrere modifizierbare Testkampagnen erstellt, die parallel zu einer ursprünglichen Kontrollkampagne laufen. Dieser Workflow wird für die folgenden ExperimentType-Werte unterstützt:

• SEARCH_CUSTOM: Ein benutzerdefinierter Test mit Suchkampagnen.
• DISPLAY_CUSTOM: Ein benutzerdefinierter Test, der aus Displaykampagnen besteht.
• HOTEL_CUSTOM: Ein benutzerdefinierter Test mit Hotelkampagnen.
• YOUTUBE_CUSTOM: Ein benutzerdefinierter Test, der aus Videokampagnen besteht.
• PMAX_REPLACEMENT_SHOPPING: Ein Test, mit dem Sie die Leistung Ihrer Shopping-Kampagnen im Vergleich zu Performance Max-Kampagnen untersuchen können.

Einrichtung

Die Einrichtung von systemverwalteten Tests erfolgt in folgenden Schritten:

1. Erstellen Sie ein Experiment.
2. ExperimentArm-Ressourcen für Kontroll- und Testgruppen erstellen
3. Ändern Sie in_design_campaigns in den Testgruppen.

1. Test erstellen

Der erste Schritt beim Ausführen eines Tests mit der Google Ads API ist das Erstellen eines Experiment. In dieser Ressource werden einige wichtige Informationen zum Test definiert, den Sie durchführen möchten. In diesem Schritt geben Sie keine der am Test beteiligten Kampagnen an.

Hier finden Sie einen Überblick über einige wichtige Felder für ein Experiment:

• name: Jeder Test muss einen eindeutigen Namen haben.
• description: Ein optionales Feld, das Sie später referenzieren können. Hat keine Auswirkungen auf die Durchführung des Tests.
• suffix: Das Suffix wird an das Ende der Namen der Testkampagnen angehängt, damit Sie sie von der Kontrollkampagne unterscheiden können. Diese Konzepte werden in Schritt 2 näher erläutert.
• type: Der Typ des auszuführenden Tests. Verwenden Sie für systemverwaltete Tests SEARCH_CUSTOM, DISPLAY_CUSTOM, HOTEL_CUSTOM, YOUTUBE_CUSTOM oder PMAX_REPLACEMENT_SHOPPING.
• status: Legen Sie dieses Feld beim Erstellen eines Tests auf SETUP fest. Später, wenn Sie den Test starten, können Sie in diesem Feld den aktuellen Status abrufen.
• start_date und end_date: Geben Sie an, wann der Test beginnen und enden soll.
• sync_enabled: Standardmäßig deaktiviert. Wenn diese Option auf true festgelegt ist, werden Änderungen, die Sie an der ursprünglichen Kampagne vornehmen, während der Test läuft, automatisch in die Testkampagne kopiert. Weitere Informationen

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

Hinweis:Für diesen Schritt ist kein direktes REST-Codebeispiel verfügbar. Sie können ihn jedoch mit einer manuellen REST-Anfrage ausführen.

Weitere Informationen finden Sie in der Dokumentation zur Google Ads API-REST-Schnittstelle und auf den methodenspezifischen Referenzseiten. Sie müssen die JSON-Nutzlast anhand der Proto-Definitionen erstellen.

Wichtige Ressourcen:

• REST verwenden
• Struktur der REST-Schnittstelle
• JSON-Feldzuordnungen
• Weitere Informationen finden Sie in der REST API-Referenz für den jeweiligen Dienst und die jeweilige Methode.

2. Testgruppen erstellen

Erstellen Sie als Nächstes ExperimentArm-Ressourcen, um die Kontroll- und Testgruppen für den Test zu definieren. Alle Arme müssen in einer einzigen Anfrage erstellt werden.

Jeder Test muss genau eine Kontrollgruppe und mindestens eine Behandlungsgruppe haben. Mit der Kontrollgruppe wird die Ausgangskampagne für den Vergleich festgelegt. Jede Testgruppe führt zu einer neuen Kampagne, in der Sie Änderungen vornehmen können, um sie zu testen.

Sie müssen auch traffic_split angeben. Das ist der Prozentsatz des Traffics, der an die einzelnen Gruppen weitergeleitet wird. Die Summe der Traffic-Aufteilungen für alle Gruppen muss 100 ergeben.

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

Hinweis:Für diesen Schritt ist kein direktes REST-Codebeispiel verfügbar. Sie können ihn jedoch mit einer manuellen REST-Anfrage ausführen.

Weitere Informationen finden Sie in der Dokumentation zur Google Ads API-REST-Schnittstelle und auf den methodenspezifischen Referenzseiten. Sie müssen die JSON-Nutzlast anhand der Proto-Definitionen erstellen.

Wichtige Ressourcen:

• REST verwenden
• Struktur der REST-Schnittstelle
• JSON-Feldzuordnungen
• Weitere Informationen finden Sie in der REST API-Referenz für den jeweiligen Dienst und die jeweilige Methode.

Einige wichtige Punkte:

• Genau eine Gruppe muss control auf true festgelegt haben.
• Die traffic_split muss für alle Gruppen zusammen 100 ergeben.
• In der Kontrollgruppe muss im Feld campaigns genau eine Kampagne angegeben werden.

Hinweis :Sie können Teilausfall nicht verwenden, wenn Sie Testgruppen erstellen.

3. Testkampagnen ändern

Wenn Sie eine Testgruppe erstellen (wobei control gleich false ist), wird über die API automatisch ein Kampagnenentwurf auf Grundlage der Kontrollkampagne erstellt und der zugehörige Ressourcenname wird in das Feld in_design_campaigns der Testgruppe eingefügt. Sie können diese Kampagnen wie reguläre Kampagnen behandeln und die Änderungen vornehmen, die Sie testen möchten. Die Kontrollkampagne ist davon nicht betroffen. Diese Änderungen werden in einer echten, auslieferbaren Kampagne umgesetzt, wenn Sie den Test planen.

Sie müssen mindestens eine Änderung an einer Kampagne vornehmen, die sich noch in der Designphase befindet, bevor Sie den Test planen können.

Wenn Sie die in_design_campaigns für einen Behandlungsarm abrufen möchten, können Sie GoogleAdsService abfragen:

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

Tipp :Kampagnenentwürfe werden nur zurückgegeben, wenn Sie der Abfrage den include_drafts=true-Parameter hinzufügen.

Test planen

Nachdem Sie den Test und die Testgruppen erstellt und die Kampagnen im Testentwurf bearbeitet haben, können Sie den Test mit ExperimentService.ScheduleExperiment planen. Dies ist ein asynchroner Vorgang, bei dem die Kampagnen im Design in tatsächliche Kampagnen umgewandelt werden, die ausgeliefert werden können, sobald das start_date des Tests eintrifft. Weitere Informationen zum Umgang mit Vorgängen mit langer Ausführungszeit finden Sie unter Asynchrone Fehler.

Bericht zum Test

Sobald der Test läuft, können Sie Messwerte abfragen, um die Leistung zu vergleichen. Weitere Informationen finden Sie im Berichtleitfaden.

Test übernehmen, beenden oder in eine Kampagne umwandeln

Nachdem das Experiment ausreichend lange gelaufen ist, können Sie es mit ExperimentService beenden, hochstufen oder in die nächste Phase überführen.

• Beenden: Wenn Sie den Test beenden möchten, ohne Änderungen anzuwenden, verwenden Sie EndExperiment. Die Testkampagnen werden nicht mehr ausgeliefert, aber nicht entfernt. Dies ist ein synchroner Vorgang.
• Bewerben: Wenn Sie mit der Leistung des Testarms zufrieden sind und die Änderungen in Ihre ursprüngliche Kampagne übernehmen möchten, verwenden Sie PromoteExperiment. Dadurch werden Änderungen aus der Testgruppe in die Kontrollkampagne kopiert und die Auslieferung der Testgruppe wird beendet. Dies ist ein asynchroner Vorgang. Weitere Informationen finden Sie unter Asynchrone Fehler. Hinweis: Tests vom Typ PMAX_REPLACEMENT_SHOPPING können nicht hochgestuft werden.
• Umstellen: Wenn Ihnen die Änderungen gefallen, Sie sie aber separat von der ursprünglichen Kampagne verwenden möchten, verwenden Sie GraduateExperiment. Dadurch wird die Testkampagne in eine unabhängige Standardkampagne umgewandelt, die auch außerhalb des Tests ausgeliefert wird. Die Kontrollkampagne wird nicht geändert. Dies ist ein synchroner Vorgang.

Typspezifische Anforderungen

PMAX_REPLACEMENT_SHOPPING:

• Es sind genau zwei Gruppen erforderlich (eine Kontrollgruppe und eine Testgruppe).
• In der Kontrollverzweigung muss im Feld campaigns eine Shopping-Kampagne angegeben werden.
• Für die Testgruppe haben Sie zwei Möglichkeiten, die Performance Max-Kampagne einzurichten:
  • So erstellen Sie eine neue Performance Max-Kampagne: Lassen Sie das Feld campaigns für die Testgruppe leer. Über die API wird automatisch eine In-Design-Kampagne auf Grundlage der Shopping-Kontrollkampagne erstellt, wie in Schritt 3 beschrieben.
  • So verwenden Sie eine bestehende Performance Max-Kampagne: Geben Sie den Ressourcennamen der Performance Max-Kampagne im Feld campaigns des Testlaufs an. Wenn Sie diese Option auswählen, wird keine In-Design-Kampagne erstellt und Sie können Schritt 3 überspringen.
• Es wird empfohlen, die Statistiken der ersten sieben Tage aus der Auswertung herauszunehmen, damit die Kampagne genügend Zeit hat, die Anlauf- und Lernphase abzuschließen.
• Kann nicht beworben werden.

YOUTUBE_CUSTOM:

• Es werden maximal 10 Testgruppen unterstützt.
• Wenn Sie Assets testen möchten, legen Sie creative_asset_testing_info für die Testgruppe fest.