آزمایش‌های مدیریت‌شده توسط سیستم

آزمایش‌های مدیریت‌شده توسط سیستم، با ایجاد یک یا چند کمپین درمانی قابل اصلاح که در کنار یک کمپین کنترل اصلی اجرا می‌شوند، برای آزمایش A/B تغییرات استفاده می‌شوند. این گردش کار برای مقادیر ExperimentType زیر پشتیبانی می‌شود:

• SEARCH_CUSTOM : یک آزمایش سفارشی متشکل از کمپین‌های جستجو.
• DISPLAY_CUSTOM : یک آزمایش سفارشی متشکل از کمپین‌های نمایشی.
• HOTEL_CUSTOM : یک آزمایش سفارشی متشکل از کمپین‌های هتل.
• YOUTUBE_CUSTOM : یک آزمایش سفارشی متشکل از کمپین‌های ویدیویی.
• PMAX_REPLACEMENT_SHOPPING : آزمایشی برای سنجش عملکرد کمپین‌های خرید شما در مقایسه با Performance Max.

راه‌اندازی

راه‌اندازی آزمایش‌های مدیریت‌شده توسط سیستم، مراحل زیر را دنبال می‌کند:

1. یک Experiment ایجاد کنید.
2. منابع ExperimentArm را برای کنترل و درمان ایجاد کنید.
3. in_design_campaigns در بخش‌های درمانی اصلاح کنید.

۱. یک آزمایش ایجاد کنید

اولین قدم برای اجرای یک آزمایش با استفاده از API گوگل ادز، ایجاد یک Experiment است. این منبع برخی از اطلاعات کلیدی در مورد آزمایشی که می‌خواهید اجرا کنید را تعریف می‌کند. در این مرحله، شما هیچ یک از کمپین‌های درگیر در آزمایش را مشخص نمی‌کنید.

در اینجا مروری بر برخی از زمینه‌های کلیدی برای یک Experiment ارائه شده است:

• name : هر آزمایش باید یک نام منحصر به فرد داشته باشد.
• description : یک فیلد اختیاری که می‌توانید بعداً برای ارجاع از آن استفاده کنید. تاثیری بر نحوه اجرای آزمایش ندارد.
• suffix : این پسوند به انتهای نام کمپین‌های درمانی اضافه می‌شود تا بتوانید آنها را از کمپین کنترل متمایز کنید. این مفاهیم در مرحله ۲ بیشتر توضیح داده خواهند شد.
• type : چه نوع آزمایشی اجرا شود. برای آزمایش‌های مدیریت‌شده توسط سیستم، از SEARCH_CUSTOM ، DISPLAY_CUSTOM ، HOTEL_CUSTOM ، YOUTUBE_CUSTOM یا PMAX_REPLACEMENT_SHOPPING استفاده کنید.
• status : هنگام ایجاد یک آزمایش، این فیلد را روی SETUP تنظیم کنید. بعداً، پس از شروع آزمایش، این فیلد به شما امکان می‌دهد وضعیت فعلی را بررسی کنید.
• start_date و end_date : مشخص کنید که آزمایش چه زمانی باید شروع و پایان یابد.
• sync_enabled : به طور پیش‌فرض غیرفعال است. اگر روی true تنظیم شود، تغییرات اعمال شده در کمپین اصلی هنگام اجرای آزمایش شما به طور خودکار در کمپین آزمایشی کپی می‌شوند. اطلاعات بیشتر .

جاوا

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
      

سی شارپ

/// <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
      

پی اچ پی

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
      

پایتون

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
      

روبی

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
      

پرل

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
      

حلقه زدن

نکته: اگرچه نمونه کد REST مستقیم برای این مرحله در اینجا ارائه نشده است، می‌توانید با استفاده از یک درخواست REST دستی به این هدف دست یابید.

به مستندات رابط کاربری REST گوگل ادز و صفحات مرجع مختص به روش مراجعه کنید. شما باید بر اساس تعاریف پروتو، JSON payload را بسازید.

منابع کلیدی:

• استفاده از REST
• ساختار رابط REST
• نگاشت‌های فیلد JSON
• برای سرویس و روش خاص، به مرجع REST API مراجعه کنید.

۲. بازوهای آزمایش ایجاد کنید

در مرحله بعد، منابع ExperimentArm را برای تعریف گروه‌های کنترل و درمان برای آزمایش ایجاد کنید. همه بازوها باید در یک درخواست واحد ایجاد شوند.

هر آزمایش باید دقیقاً یک بازوی کنترل و یک یا چند بازوی درمانی داشته باشد. بازوی کنترل، کمپین پایه را برای مقایسه مشخص می‌کند و هر بازوی درمانی منجر به یک کمپین جدید می‌شود که می‌توانید در آن تغییراتی برای آزمایش ایجاد کنید.

همچنین باید traffic_split مشخص کنید که درصد ترافیک هدایت شده به هر بازو است. مجموع تقسیم ترافیک در تمام بازوها باید ۱۰۰ باشد.

جاوا

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
      

سی شارپ

/// <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
      

پی اچ پی

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
      

پایتون

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]
      

روبی

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
      

پرل

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
      

حلقه زدن

نکته: اگرچه نمونه کد REST مستقیم برای این مرحله در اینجا ارائه نشده است، می‌توانید با استفاده از یک درخواست REST دستی به این هدف دست یابید.

به مستندات رابط کاربری REST گوگل ادز و صفحات مرجع مختص به روش مراجعه کنید. شما باید بر اساس تعاریف پروتو، JSON payload را بسازید.

منابع کلیدی:

• استفاده از REST
• ساختار رابط REST
• نگاشت‌های فیلد JSON
• برای سرویس و روش خاص، به مرجع REST API مراجعه کنید.

چند نکته کلیدی:

• دقیقاً باید control یکی از بازوها روی true تنظیم شده باشد.
• مجموع traffic_split باید در تمام بازوها به ۱۰۰ برسد.
• بازوی کنترل باید دقیقاً یک کمپین را در فیلد campaigns خود مشخص کند.

توجه: هنگام ایجاد بازوهای آزمایش نمی‌توانید از شکست جزئی استفاده کنید.

۳. اصلاح کمپین‌های درمانی

وقتی یک بازوی درمانی ایجاد می‌کنید (که در آن control false است)، API به طور خودکار یک کمپین پیش‌نویس بر اساس کمپین کنترل ایجاد می‌کند و نام منبع آن را در فیلد in_design_campaigns بازوی درمانی قرار می‌دهد. می‌توانید این کمپین‌های درون‌طراحی را به عنوان کمپین‌های معمولی در نظر بگیرید و آنها را با تغییراتی که می‌خواهید آزمایش کنید، اصلاح کنید. کمپین کنترل تحت تأثیر قرار نمی‌گیرد. این تغییرات هنگام برنامه‌ریزی آزمایش، به یک کمپین واقعی و قابل اجرا تبدیل می‌شوند.

قبل از اینکه بتوانید آزمایش را برنامه‌ریزی کنید، حداقل باید یک تغییر در یک کمپین درون‌طراحی ایجاد شود.

برای بازیابی in_design_campaigns برای یک بازوی درمانی، می‌توانید GoogleAdsService کوئری بگیرید:

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

نکته: کمپین‌های پیش‌نویس فقط در صورتی بازگردانده می‌شوند که پارامتر include_drafts=true را به کوئری خود اضافه کنید.

آزمایش را زمان‌بندی کنید

پس از ایجاد آزمایش و بازوها و اصلاح کمپین‌های پیش‌نویس درمان، می‌توانید آزمایش را با استفاده از ExperimentService.ScheduleExperiment زمان‌بندی کنید. این یک عملیات ناهمزمان است که کمپین‌های درون‌طراحی را به کمپین‌های واقعی تبدیل می‌کند و پس از رسیدن start_date آزمایش، آماده ارائه خدمات است. برای جزئیات بیشتر در مورد مدیریت عملیات طولانی‌مدت، به خطاهای ناهمزمان مراجعه کنید.

گزارش آزمایش

Once the experiment is running, you can query for metrics to compare performance. See the Reporting guide for details.

فارغ‌التحصیل شوید، ارتقا دهید یا آزمایش را پایان دهید

پس از اینکه آزمایش به مدت کافی اجرا شد، می‌توانید با استفاده از ExperimentService آن را پایان دهید، ارتقا دهید یا به سطح بالاتری ببرید.

• پایان : اگر می‌خواهید آزمایش را بدون اعمال تغییرات متوقف کنید، EndExperiment استفاده کنید. کمپین‌های درمانی ارائه خدمات را متوقف می‌کنند، اما حذف نمی‌شوند. این یک عملیات همزمان است.
• Promote : اگر از عملکرد بازوی درمان راضی هستید و می‌خواهید تغییرات را در کمپین اصلی خود اعمال کنید، از PromoteExperiment استفاده کنید. این کار تغییرات را از بازوی درمان به کمپین کنترل کپی می‌کند و مانع از ارائه خدمات توسط بازوی درمان می‌شود. این یک عملیات ناهمزمان است؛ برای جزئیات بیشتر به خطاهای ناهمزمان مراجعه کنید. توجه: آزمایش‌هایی از نوع PMAX_REPLACEMENT_SHOPPING قابل ارتقا نیستند.
• فارغ‌التحصیلی : اگر تغییرات را دوست داشتید، اما می‌خواهید آنها جدا از کمپین اصلی وجود داشته باشند، از GraduateExperiment استفاده کنید. این کار کمپین درمانی را به یک کمپین استاندارد و مستقل تبدیل می‌کند که همچنان خارج از چارچوب آزمایش به کار خود ادامه می‌دهد. کمپین کنترل اصلاح نمی‌شود. این یک عملیات همزمان است.

الزامات خاص نوع

PMAX_REPLACEMENT_SHOPPING :

• دقیقاً به دو بازو نیاز دارد (یک کنترل، یک درمان).
• بازوی کنترل باید یک کمپین خرید را در فیلد campaigns خود مشخص کند.
• برای بخش درمان، شما دو گزینه برای راه‌اندازی کمپین Performance Max دارید:
  • برای ایجاد یک کمپین جدید PMax: فیلد campaigns بخش درمان را خالی بگذارید. API به طور خودکار یک کمپین درون‌طراحی بر اساس کمپین خرید کنترل، همانطور که در مرحله ۳ توضیح داده شده است، ایجاد می‌کند.
  • برای استفاده از یک کمپین PMax موجود : نام منبع کمپین PMax را در فیلد campaigns بازوی درمانی مشخص کنید. اگر این گزینه را انتخاب کنید، هیچ کمپینی در طراحی ایجاد نمی‌شود و می‌توانید از مرحله ۳ صرف نظر کنید.
• توصیه می‌شود آمار ۷ روز اول ارزیابی خود را کنار بگذارید تا به کمپین زمان بدهید تا مرحله‌ی تقویت و یادگیری خود را به پایان برساند.
• قابل ترفیع نیست.

YOUTUBE_CUSTOM :

• حداکثر 10 بازو را پشتیبانی می‌کند.
• برای آزمایش دارایی‌ها، creative_asset_testing_info را روی بازوی آزمایش تنظیم کنید.