สร้างเส้นโค้งการเข้าถึง

เมื่อรวบรวมการตั้งค่าการกำหนดเป้าหมายและส่วนผสมผลิตภัณฑ์สำหรับแผนการโฆษณาแล้ว คุณจะสร้างเส้นโค้งของงบประมาณเทียบกับการเข้าถึงที่อาจเกิดขึ้นได้โดยใช้วิธีGenerateReachForecast ใน ReachPlanService ดูรายละเอียดเกี่ยวกับฟิลด์คำขอได้ในอภิธานศัพท์และคู่มือแผนสื่อ

เมตริกการคาดการณ์

การตอบกลับจาก GenerateReachForecast จะมีเมตริกต่างๆ ภายในข้อความ Forecast ซึ่งให้ข้อมูลเชิงลึกเกี่ยวกับ ประสิทธิภาพที่อาจเกิดขึ้นของแคมเปญที่คุณวางแผนไว้ เมตริกเหล่านี้ประกอบด้วยรายการต่อไปนี้

  • การเข้าถึง (ตามเป้าหมายและทั้งหมด รวมถึงการดูร่วมกัน)
  • การแสดงผล (ตามเป้าหมายและทั้งหมด รวมถึงการดูร่วมกันและการแสดงผลที่มองเห็นได้)
  • รายละเอียดความถี่ที่มีประสิทธิภาพ (จำนวนผู้ใช้ที่ไม่ซ้ำที่เข้าถึงได้อย่างน้อย จำนวนครั้งที่แน่นอน (เช่น การแสดงผล 1+, 2+, 3+))
  • การกระทำของผู้ใช้ (ยอดดู TrueView, Conversion และการคลิก)

บันทึกเส้นโค้ง

คุณบันทึกได้เฉพาะเส้นโค้งแต่ละเส้นเพื่ออำนวยความสะดวกให้แก่ผู้ใช้ ห้ามแคชเส้นโค้งอัตราการแสดงโฆษณาจำนวนมากโดยเด็ดขาด หากคุณต้องการสร้างเส้นโค้งจำนวนมาก โปรดติดต่อตัวแทนของ Google ก่อน

การจัดการข้อผิดพลาด

คำขอไปยัง ReachPlanService ต้องเป็นไปตามโครงสร้าง API พื้นฐาน และอาจแสดงข้อผิดพลาดที่พบบ่อยหากตรวจสอบไม่ผ่าน

นอกเหนือจากข้อผิดพลาดที่พบบ่อยแล้ว ReachPlanService ยังแสดงข้อผิดพลาดที่เฉพาะเจาะจงกับการวางแผนการเข้าถึงที่ระบุไว้ในReachPlanError

การเปลี่ยนแปลงสำหรับ YouTube Select

บริการแผนการเข้าถึงของ YouTube Select (YTS) รองรับการกำหนดเป้าหมายระดับรายการเทียบกับการแสดงทั่วเครือข่ายก่อนหน้านี้ สำหรับสถานที่ที่มีสิทธิ์ทั้งหมดของ YTS ในการกำหนดราคาแบบจองทันที ใช้ฟิลด์ youtube_select_lineup_targeting ใน ReachPlanService.ListPlannableProducts เพื่อระบุว่ามีรายการใดบ้าง

เมื่อใช้การจองทันที ข้อผิดพลาดเหล่านี้อาจเกิดขึ้นเมื่อขอการคาดการณ์สำหรับ YTS ด้วย

  1. มีพื้นที่โฆษณาไม่เพียงพอ
  2. บัญชีที่ไม่ได้ใช้จ่ายถูกปิดใช้

คาดการณ์การเข้าถึงสำหรับ Demand Gen

เมื่อสร้างเส้นโค้งสำหรับDEMAND_GENผลิตภัณฑ์ที่วางแผนได้ คุณต้องระบุอัตรา Conversion ที่คาดไว้สำหรับผลิตภัณฑ์แต่ละรายการด้วย

หากต้องการรับคำแนะนำเกี่ยวกับอัตรา Conversion สำหรับผลิตภัณฑ์ที่วางแผนได้ที่รองรับ ให้ใช้วิธีGenerateConversionRates วิธีนี้จะแสดงคำแนะนำอัตรา Conversion โดยอิงตามประสิทธิภาพที่ผ่านมาของบัญชี หรืออัตราที่แนะนำโดยอิงตามประสิทธิภาพของผู้ลงโฆษณาทุกราย

สำหรับผลิตภัณฑ์ DEMAND_GEN GenerateConversionRates อาจแสดงคำแนะนำหลายรายการสำหรับผลิตภัณฑ์เดียวกัน คำแนะนำบางรายการจะมีฟิลด์ surface_targeting ที่มีข้อมูล ซึ่งบ่งชี้ว่าคำแนะนำนั้นใช้ได้กับชุดค่าผสมของแพลตฟอร์มนั้นๆ เท่านั้น (เช่น YouTube Shorts) หากไม่ได้ระบุ surface_targeting ไว้ แสดงว่าคำแนะนำคือค่าเฉลี่ยของแคมเปญ Demand Gen สำหรับผลิตภัณฑ์นั้น เมื่อสร้างการคาดการณ์สำหรับแคมเปญ Demand Gen ที่มีการกำหนดเป้าหมายตามแพลตฟอร์ม คุณควรใช้คำแนะนำอัตรา Conversion ที่เฉพาะเจาะจงที่สุดที่มีอยู่

นอกเหนือจากอัตรา Conversion แล้ว ผู้ใช้ Demand Gen ยังสามารถใช้ GenerateReachForecast เพื่อคาดการณ์ clicks ซึ่งมีความเกี่ยวข้องอย่างยิ่งกับ แคมเปญที่เพิ่มประสิทธิภาพเพื่อการคลิก เช่น Demand Gen ที่ใช้การเสนอราคาแบบเพิ่มจำนวนคลิกสูงสุด

ตัวอย่างโค้ด

เส้นโค้งประกอบด้วยการแสดงผลและการเข้าถึงผู้ใช้ในจำนวนที่แน่นอน รวมถึงขนาดของกลุ่มเป้าหมายที่สอดคล้องกับประชากรจากการทำสำมะโนประชากรและขนาดกลุ่มเป้าหมาย YouTube สำหรับข้อมูลประชากรและประเทศที่ขอ

Java

private void getReachCurve(
    ReachPlanServiceClient reachPlanServiceClient, GenerateReachForecastRequest request) {
  GenerateReachForecastResponse response = reachPlanServiceClient.generateReachForecast(request);
  System.out.println("Reach curve output:");
  System.out.println(
      "Currency, Cost Micros, On-Target Reach, On-Target Imprs, Total Reach, Total Imprs,"
          + " Products");
  for (ReachForecast point : response.getReachCurve().getReachForecastsList()) {
    System.out.printf(
        "%s, \"",
        Joiner.on(", ")
            .join(
                request.getCurrencyCode(),
                String.valueOf(point.getCostMicros()),
                String.valueOf(point.getForecast().getOnTargetReach()),
                String.valueOf(point.getForecast().getOnTargetImpressions()),
                String.valueOf(point.getForecast().getTotalReach()),
                String.valueOf(point.getForecast().getTotalImpressions())));
    for (PlannedProductReachForecast product : point.getPlannedProductReachForecastsList()) {
      System.out.printf("[Product: %s, ", product.getPlannableProductCode());
      System.out.printf("Budget Micros: %s]", product.getCostMicros());
    }
    System.out.printf("\"%n");
  }
}
ForecastReach.java

C#

public void GetReachCurve(ReachPlanServiceClient reachPlanService,
    GenerateReachForecastRequest request)
{
    GenerateReachForecastResponse response = reachPlanService.GenerateReachForecast(
        request);
    Console.WriteLine("Reach curve output:");
    Console.WriteLine(
        "Currency, Cost Micros, On-Target Reach, On-Target Impressions, Total Reach," +
        " Total Impressions, Products");
    foreach (ReachForecast point in response.ReachCurve.ReachForecasts)
    {
        Console.Write($"{request.CurrencyCode}, ");
        Console.Write($"{point.CostMicros}, ");
        Console.Write($"{point.Forecast.OnTargetReach}, ");
        Console.Write($"{point.Forecast.OnTargetImpressions}, ");
        Console.Write($"{point.Forecast.TotalReach}, ");
        Console.Write($"{point.Forecast.TotalImpressions}, ");
        Console.Write("\"[");
        foreach (PlannedProductReachForecast productReachForecast in
            point.PlannedProductReachForecasts)
        {
            Console.Write($"(Product: {productReachForecast.PlannableProductCode}, ");
            Console.Write($"Budget Micros: {productReachForecast.CostMicros}), ");
        }

        Console.WriteLine("]\"");
    }
}
ForecastReach.cs

PHP

private static function getReachCurve(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    array $productMix,
    string $locationId,
    string $currencyCode
) {
    // Valid durations are between 1 and 90 days.
    $duration = new CampaignDuration(['duration_in_days' => 28]);
    $targeting = new Targeting([
        'plannable_location_id' => $locationId,
        'age_range' => ReachPlanAgeRange::AGE_RANGE_18_65_UP,
        'genders' => [
            new GenderInfo(['type' => GenderType::FEMALE]),
            new GenderInfo(['type' => GenderType::MALE])
        ],
        'devices' => [
            new DeviceInfo(['type' => Device::DESKTOP]),
            new DeviceInfo(['type' => Device::MOBILE]),
            new DeviceInfo(['type' => Device::TABLET])
        ]
    ]);

    // See the docs for defaults and valid ranges:
    // https://developers.google.com/google-ads/api/reference/rpc/latest/GenerateReachForecastRequest
    $response = $googleAdsClient->getReachPlanServiceClient()->generateReachForecast(
        GenerateReachForecastRequest::build($customerId, $duration, $productMix)
            ->setCurrencyCode($currencyCode)
            ->setTargeting($targeting)
    );

    printf(
        "Reach curve output:%sCurrency, Cost Micros, On-Target Reach, On-Target Imprs," .
            " Total Reach, Total Imprs, Products%s",
        PHP_EOL,
        PHP_EOL
    );
    foreach ($response->getReachCurve()->getReachForecasts() as $point) {
        $products = '';
        /** @var ReachForecast $point */
        foreach ($point->getPlannedProductReachForecasts() as $plannedProductReachForecast) {
            /** @var PlannedProductReachForecast $plannedProductReachForecast */
            $products .= sprintf(
                '(Product: %s, Budget Micros: %s)',
                $plannedProductReachForecast->getPlannableProductCode(),
                $plannedProductReachForecast->getCostMicros()
            );
        }
        printf(
            "%s, %d, %d, %d, %d, %d, %s%s",
            $currencyCode,
            $point->getCostMicros(),
            $point->getForecast()->getOnTargetReach(),
            $point->getForecast()->getOnTargetImpressions(),
            $point->getForecast()->getTotalReach(),
            $point->getForecast()->getTotalImpressions(),
            $products,
            PHP_EOL
        );
    }
}
ForecastReach.php

Python

def request_reach_curve(
    client: GoogleAdsClient,
    customer_id: str,
    product_mix: list[PlannedProduct],
    location_id: str,
    currency_code: str,
):
    """Creates a sample request for a given product mix.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: The customer ID for the reach forecast.
        product_mix: The product mix for the reach forecast.
        location_id: The location ID to plan for.
        currency_code: Three-character ISO 4217 currency code.
    """
    # See the docs for defaults and valid ranges:
    # https://developers.google.com/google-ads/api/reference/rpc/latest/GenerateReachForecastRequest
    request: GenerateReachForecastRequest = client.get_type(
        "GenerateReachForecastRequest"
    )
    request.customer_id = customer_id
    # Valid durations are between 1 and 90 days.
    request.campaign_duration.duration_in_days = 28
    request.currency_code = currency_code
    request.cookie_frequency_cap = 0
    request.min_effective_frequency = 1
    request.planned_products = product_mix

    request.targeting.plannable_location_id = location_id
    request.targeting.age_range = (
        client.enums.ReachPlanAgeRangeEnum.AGE_RANGE_18_65_UP
    )

    # Add gender targeting to the request.
    gender_type: GenderTypeEnum
    for gender_type in [
        client.enums.GenderTypeEnum.FEMALE,
        client.enums.GenderTypeEnum.MALE,
    ]:
        gender: GenderInfo = client.get_type("GenderInfo")
        gender.type_ = gender_type
        request.targeting.genders.append(gender)

    # Add device targeting to the request.
    device_type: DeviceEnum
    for device_type in [
        client.enums.DeviceEnum.DESKTOP,
        client.enums.DeviceEnum.MOBILE,
        client.enums.DeviceEnum.TABLET,
    ]:
        device: DeviceInfo = client.get_type("DeviceInfo")
        device.type_ = device_type
        request.targeting.devices.append(device)

    reach_plan_service: ReachPlanServiceClient = client.get_service(
        "ReachPlanService"
    )
    response: GenerateReachForecastResponse = (
        reach_plan_service.generate_reach_forecast(request=request)
    )

    print(
        "Currency, Cost, On-Target Reach, On-Target Imprs, Total Reach,"
        " Total Imprs, Products"
    )
    point: ReachForecast
    for point in response.reach_curve.reach_forecasts:
        product_splits = []
        p: PlannedProductReachForecast
        for p in point.planned_product_reach_forecasts:
            product_splits.append(
                {p.plannable_product_code: p.cost_micros / ONE_MILLION}
            )
        print(
            [
                currency_code,
                point.cost_micros / ONE_MILLION,
                point.forecast.on_target_reach,
                point.forecast.on_target_impressions,
                point.forecast.total_reach,
                point.forecast.total_impressions,
                product_splits,
            ]
        )
forecast_reach.py

Ruby

def get_reach_curve(
  client,
  reach_plan_service,
  customer_id,
  product_mix,
  location_id,
  currency_code)
  duration = client.resource.campaign_duration do |d|
    # Valid durations are between 1 and 90 days.
    d.duration_in_days = 28
  end

  targeting = client.resource.targeting do |t|
    t.plannable_location_id = location_id
    t.age_range = :AGE_RANGE_18_65_UP
    t.genders << client.resource.gender_info do |gender|
      gender.type = :FEMALE
    end
    t.genders << client.resource.gender_info do |gender|
      gender.type = :MALE
    end
    t.devices << client.resource.device_info do |device|
      device.type = :DESKTOP
    end
    t.devices << client.resource.device_info do |device|
      device.type = :MOBILE
    end
    t.devices << client.resource.device_info do |device|
      device.type = :TABLET
    end
  end

  # See the docs for defaults and valid ranges:
  # https://developers.google.com/google-ads/api/reference/rpc/latest/GenerateReachForecastRequest
  response = reach_plan_service.generate_reach_forecast(
    customer_id: customer_id,
    campaign_duration: duration,
    planned_products: product_mix,
    currency_code: currency_code,
    targeting: targeting,
  )

  puts "Reach curve output:"
  puts "Currency, Cost Micros, On-Target Reach, On-Target Imprs, " \
    "Total Reach, Total Imprs, Products"

  response.reach_curve.reach_forecasts.each do |point|
    products = ""
    point.planned_product_reach_forecasts.each do |product|
      products += "(Product: #{product.plannable_product_code}, "\
        "Cost Micros: #{product.cost_micros})"
    end
    puts "#{currency_code}, #{point.cost_micros}, " \
      "#{point.forecast.on_target_reach}, " \
      "#{point.forecast.on_target_impressions}, " \
      "#{point.forecast.total_reach}, " \
      "#{point.forecast.total_impressions}, " \
      "#{products}"
  end
end
forecast_reach.rb

Perl

sub pull_reach_curve {
  my ($reach_plan_service, $reach_request) = @_;

  my $response = $reach_plan_service->generate_reach_forecast($reach_request);
  print "Reach curve output:\n";
  print "Currency,\tCost Micros,\tOn-Target Reach,\tOn-Target Imprs,\t" .
    "Total Reach,\tTotal Imprs,\tProducts\n";
  foreach my $point (@{$response->{reachCurve}{reachForecasts}}) {
    printf "%s,\t%d,\t%d,\t%d,\t%d,\t%d,\t'[", $reach_request->{currencyCode},
      $point->{costMicros}, $point->{forecast}{onTargetReach},
      $point->{forecast}{onTargetImpressions}, $point->{forecast}{totalReach},
      $point->{forecast}{totalImpressions};
    foreach my $productReachForecast (@{$point->{plannedProductReachForecasts}})
    {
      printf "(Product: %s, Budget Micros: %d), ",
        $productReachForecast->{plannableProductCode},
        $productReachForecast->{costMicros};
    }
    print "]'\n";
  }
}
forecast_reach.pl

curl

ก่อนหน้า
ระบุแผนการโฆษณา