Eksperymenty w ramach kampanii

Eksperymenty w ramach kampanii służą do testowania konkretnej funkcji w jednej kampanii. W przeciwieństwie do eksperymentów zarządzanych przez system, w których ruch jest dzielony między kampanie kontrolne i eksperymentalne, eksperymenty w ramach kampanii dzielą ruch w kampanii na podstawie tego, czy funkcja jest włączona czy nie.

Ten proces jest obsługiwany w przypadku tych ExperimentType wartości:

ADOPT_AI_MAX
Testuje wpływ funkcji AI Max na kampanie w sieci wyszukiwania.
ADOPT_BROAD_MATCH_KEYWORDS
Testuje wpływ słów kluczowych w dopasowaniu przybliżonym na kampanie w sieci wyszukiwania.
PMAX_TEXT_CUSTOMIZATION_FINAL_URL_EXPANSION
Używany specjalnie do testowania funkcji kampanii Performance Max: dostosowywania tekstu i rozwinięcia końcowego adresu URL. Umożliwia sztucznej inteligencji Google kierowanie ruchu na trafne strony docelowe oraz generowanie komponentów tekstowych lepiej dopasowanych do wyszukiwanych haseł.

Konfiguracja

  1. Zdefiniuj Experiment, podając typ eksperymentu, grupę kontrolną ExperimentArm i grupę eksperymentalną ExperimentArm. Każda grupa powinna odwoływać się do tej samej kampanii.
  2. Włącz funkcję testową w eksperymencie za pomocą maski pola. W przypadku ADOPT_BROAD_MATCH_KEYWORDS nie jest to konieczne. Zamiast tego ustawienie kampanii w dopasowaniu przybliżonym zostanie włączone automatycznie po utworzeniu eksperymentu.
  3. Wyślij GoogleAdsService.Mutate żądanie, które zawiera operacje mutacji umożliwiające utworzenie eksperymentu i grup eksperymentalnych oraz (w stosownych przypadkach) włączenie funkcji testowej.

Po skonfigurowaniu ruch jest dzielony w ramach kampanii w taki sposób, że 50% ruchu jest kierowane do włączonej funkcji (grupa eksperymentalna), a 50% – nie (grupa kontrolna).

Java

// Create the experiment resource name using a temporary ID.
String experimentResourceName = ResourceNames.experiment(customerId, -1L);

// Create the experiment.
Experiment experiment =
    Experiment.newBuilder()
        .setResourceName(experimentResourceName)
        .setName("ADOPT_AI_MAX Experiment #" + UUID.randomUUID())
        .setType(ExperimentType.ADOPT_AI_MAX)
        .build();
MutateOperation experimentOperation =
    MutateOperation.newBuilder()
        .setExperimentOperation(ExperimentOperation.newBuilder().setCreate(experiment).build())
        .build();

// Create the control arm. Both arms in an intra-campaign experiment reference the same base
// campaign.
ExperimentArm controlArm =
    ExperimentArm.newBuilder()
        .setExperiment(experimentResourceName)
        .setName("Control Arm")
        .setControl(true)
        .setTrafficSplit(50)
        .addCampaigns(ResourceNames.campaign(customerId, campaignId))
        .build();
MutateOperation controlArmOperation =
    MutateOperation.newBuilder()
        .setExperimentArmOperation(
            ExperimentArmOperation.newBuilder().setCreate(controlArm).build())
        .build();

// Create the treatment arm.
ExperimentArm treatmentArm =
    ExperimentArm.newBuilder()
        .setExperiment(experimentResourceName)
        .setName("Treatment Arm")
        .setControl(false)
        .setTrafficSplit(50)
        .addCampaigns(ResourceNames.campaign(customerId, campaignId))
        .build();
MutateOperation treatmentArmOperation =
    MutateOperation.newBuilder()
        .setExperimentArmOperation(
            ExperimentArmOperation.newBuilder().setCreate(treatmentArm).build())
        .build();

// Create a campaign operation with an update mask to enable AI Max and configure asset
// automation settings.
// Note: For intra-campaign experiments, these settings are applied to the base campaign but are
// only active for the treatment traffic split.
Campaign campaign =
    Campaign.newBuilder()
        .setResourceName(ResourceNames.campaign(customerId, campaignId))
        .setAiMaxSetting(AiMaxSetting.newBuilder().setEnableAiMax(true).build())
        .addAssetAutomationSettings(
            AssetAutomationSetting.newBuilder()
                .setAssetAutomationType(AssetAutomationType.TEXT_ASSET_AUTOMATION)
                .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN)
                .build())
        .addAssetAutomationSettings(
            AssetAutomationSetting.newBuilder()
                .setAssetAutomationType(
                    AssetAutomationType.FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION)
                .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN)
                .build())
        .build();

CampaignOperation campaignOp =
    CampaignOperation.newBuilder()
        .setUpdate(campaign)
        .setUpdateMask(FieldMasks.allSetFieldsOf(campaign))
        .build();
MutateOperation campaignMutateOperation =
    MutateOperation.newBuilder().setCampaignOperation(campaignOp).build();

// Send all mutate operations in a single Mutate request.
List<MutateOperation> mutateOperations =
    ImmutableList.of(
        experimentOperation,
        controlArmOperation,
        treatmentArmOperation,
        campaignMutateOperation);

try (GoogleAdsServiceClient googleAdsServiceClient =
    googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {

  MutateGoogleAdsRequest request =
      MutateGoogleAdsRequest.newBuilder()
          .setCustomerId(Long.toString(customerId))
          .addAllMutateOperations(mutateOperations)
          .build();

  MutateGoogleAdsResponse response = googleAdsServiceClient.mutate(request);

C#

// Create the experiment resource name using a temporary ID.
string experimentResourceName = ResourceNames.Experiment(customerId, -1);

// Create the experiment.
MutateOperation experimentOperation = new MutateOperation()
{
    ExperimentOperation = new ExperimentOperation()
    {
        Create = new Experiment()
        {
            ResourceName = experimentResourceName,
            Name = $"ADOPT_AI_MAX Experiment #{ExampleUtilities.GetRandomString()}",
            Type = ExperimentType.AdoptAiMax
        }
    }
};

// Create the control arm. Both arms in an intra-campaign experiment
// reference the same base campaign.
MutateOperation controlArmOperation = new MutateOperation()
{
    ExperimentArmOperation = new ExperimentArmOperation()
    {
        Create = new ExperimentArm()
        {
            Experiment = experimentResourceName,
            Name = "Control Arm",
            Control = true,
            TrafficSplit = 50,
            Campaigns = { ResourceNames.Campaign(customerId, campaignId) }
        }
    }
};

// Create the treatment arm.
MutateOperation treatmentArmOperation = new MutateOperation()
{
    ExperimentArmOperation = new ExperimentArmOperation()
    {
        Create = new ExperimentArm()
        {
            Experiment = experimentResourceName,
            Name = "Treatment Arm",
            Control = false,
            TrafficSplit = 50,
            Campaigns = { ResourceNames.Campaign(customerId, campaignId) }
        }
    }
};

// Create a campaign operation with an update mask to enable AI Max and
// configure asset automation settings.
// Note: For intra-campaign experiments, these settings are applied to the
// base campaign but are only active for the treatment traffic split.
Campaign campaign = new Campaign()
{
    ResourceName = ResourceNames.Campaign(customerId, campaignId),
    AiMaxSetting = new Campaign.Types.AiMaxSetting { EnableAiMax = true }
};

campaign.AssetAutomationSettings.Add(new Campaign.Types.AssetAutomationSetting
{
    AssetAutomationType = AssetAutomationType.TextAssetAutomation,
    AssetAutomationStatus = AssetAutomationStatus.OptedIn
});

campaign.AssetAutomationSettings.Add(new Campaign.Types.AssetAutomationSetting
{
    AssetAutomationType = AssetAutomationType.FinalUrlExpansionTextAssetAutomation,
    AssetAutomationStatus = AssetAutomationStatus.OptedIn
});

MutateOperation campaignOperation = new MutateOperation()
{
    CampaignOperation = new CampaignOperation()
    {
        Update = campaign,
        UpdateMask = FieldMasks.AllSetFieldsOf(campaign)
    }
};

// Send all mutate operations in a single Mutate request.
List<MutateOperation> mutateOperations = new List<MutateOperation>
{
    experimentOperation,
    controlArmOperation,
    treatmentArmOperation,
    campaignOperation
};

MutateGoogleAdsResponse response = googleAdsService.Mutate(
    customerId.ToString(), mutateOperations);

PHP

This example is not yet available in PHP; you can take a look at the other languages.

Python

# Create the experiment resource name using a temporary ID.
experiment_resource_name = googleads_service.experiment_path(
    customer_id, "-1"
)

# Create the experiment.
experiment_operation = client.get_type("MutateOperation")
experiment = experiment_operation.experiment_operation.create
experiment.resource_name = experiment_resource_name
experiment.name = f"ADOPT_AI_MAX Experiment #{uuid4()}"
experiment.type_ = client.enums.ExperimentTypeEnum.ADOPT_AI_MAX

# Create the control arm. Both arms in an intra-campaign experiment
# reference the same base campaign.
control_arm_operation = client.get_type("MutateOperation")
control_arm = control_arm_operation.experiment_arm_operation.create
control_arm.experiment = experiment_resource_name
control_arm.name = "Control Arm"
control_arm.control = True
control_arm.traffic_split = 50
control_arm.campaigns.append(
    googleads_service.campaign_path(customer_id, campaign_id)
)

# Create the treatment arm.
treatment_arm_operation = client.get_type("MutateOperation")
treatment_arm = treatment_arm_operation.experiment_arm_operation.create
treatment_arm.experiment = experiment_resource_name
treatment_arm.name = "Treatment Arm"
treatment_arm.control = False
treatment_arm.traffic_split = 50
treatment_arm.campaigns.append(
    googleads_service.campaign_path(customer_id, campaign_id)
)

# Create a campaign operation with an update mask to enable AI Max and
# configure asset automation settings.
# Note: For intra-campaign experiments, these settings are applied to the
# base campaign but are only active for the treatment traffic split.
campaign_operation = client.get_type("MutateOperation")
campaign = campaign_operation.campaign_operation.update
campaign.resource_name = googleads_service.campaign_path(
    customer_id, campaign_id
)
campaign.ai_max_setting.enable_ai_max = True

for asset_automation_type_enum in [
    client.enums.AssetAutomationTypeEnum.TEXT_ASSET_AUTOMATION,
    client.enums.AssetAutomationTypeEnum.FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION,
]:
    asset_automation_setting = client.get_type(
        "Campaign"
    ).AssetAutomationSetting()
    asset_automation_setting.asset_automation_type = (
        asset_automation_type_enum
    )
    asset_automation_setting.asset_automation_status = (
        client.enums.AssetAutomationStatusEnum.OPTED_IN
    )
    campaign.asset_automation_settings.append(asset_automation_setting)

client.copy_from(
    campaign_operation.campaign_operation.update_mask,
    protobuf_helpers.field_mask(None, campaign._pb),
)

# Send all mutate operations in a single Mutate request.
mutate_operations = [
    experiment_operation,
    control_arm_operation,
    treatment_arm_operation,
    campaign_operation,
]

response = googleads_service.mutate(
    customer_id=customer_id,
    mutate_operations=mutate_operations,
)

Ruby

This example is not yet available in Ruby; you can take a look at the other languages.

Perl

This example is not yet available in Perl; you can take a look at the other languages.

curl

Raportowanie eksperymentu

Ponieważ ruch kontrolny i eksperymentalny jest mieszany w ramach jednej kampanii, ty musisz używać bezpośredniego raportowania eksperymentu do porównywania danych między grupą kontrolną a grupą eksperymentalną. Standardowe raportowanie na poziomie kampanii pokazuje tylko zagregowane dane dotyczące całej kampanii i nie może rozróżniać tych 2 grup.

Aby pobrać statystyki kliknięć w przypadku eksperymentu w ramach kampanii ADOPT_AI_MAX, możesz użyć tego zapytania GAQL.

SELECT
  experiment.resource_name,
  experiment.name,
  metrics.clicks,
  metrics.control_clicks,
  metrics.clicks_point_estimate,
  metrics.clicks_p_value
FROM experiment
WHERE experiment.type = 'ADOPT_AI_MAX'

Promowanie lub zakończenie eksperymentu

Po ocenie wyników możesz zakończyć lub promować eksperyment za pomocą ExperimentService.

  • Zakończ: jeśli nie jesteś zadowolony(-a) z wyników, użyj EndExperiment. Funkcja zostanie wyłączona, a kampania wróci do wyświetlania całego ruchu bez funkcji eksperymentalnej. Jest to operacja synchroniczna.
  • Promuj: jeśli jesteś zadowolony(-a) z wyników, użyj PromoteExperiment. Spowoduje to zastosowanie zmiany eksperymentalnej jako nowego stałego stanu kampanii. Jest to operacja asynchroniczna. Więcej informacji znajdziesz w artykule Asynchroniczne błędy.

Operacja graduate nie jest obsługiwana w przypadku eksperymentów w ramach kampanii, ponieważ nie ma oddzielnej kampanii eksperymentalnej, którą można by zmodyfikować.

Wstecz
Eksperymenty zarządzane przez system
Dalej
Eksperymenty dotyczące optymalizacji komponentów