ชิ้นงานในแคมเปญ Performance Max

แคมเปญ Performance Max มีลักษณะเฉพาะบางอย่างเกี่ยวกับชิ้นงาน

  1. มีชิ้นงานประเภทต่างๆ ตามจำนวนขั้นต่ำที่กำหนด
  2. ชิ้นงานจะจัดกลุ่มไว้ในคอลเล็กชันที่เรียกว่าAssetGroup ซึ่งเป็นเอกลักษณ์ของแคมเปญ Performance Max
  3. โดยแมชชีนเลิร์นนิงสามารถสร้างชิ้นงานบางรายการได้โดยอัตโนมัติ

หลักเกณฑ์การใช้แบรนด์: การเชื่อมโยงชื่อและโลโก้ธุรกิจ

แม้ว่าชิ้นงานส่วนใหญ่ในแคมเปญ Performance Max จะจัดระเบียบอยู่ภายในกลุ่มชิ้นงาน แต่ชิ้นงานสําคัญที่แสดงถึงเอกลักษณ์ของแบรนด์ ซึ่งได้แก่ ชื่อธุรกิจและโลโก้ธุรกิจ จะได้รับการจัดการแตกต่างออกไปหากเปิดใช้หลักเกณฑ์การใช้แบรนด์สําหรับแคมเปญ

ชิ้นงานหลักเกณฑ์การใช้แบรนด์เหล่านี้ลิงก์โดยตรงที่ระดับแคมเปญ ไม่ใช่ที่ระดับกลุ่มชิ้นงาน ซึ่งทำได้โดยใช้แหล่งข้อมูล CampaignAsset คุณ ลิงก์ชิ้นงานกับแคมเปญ โดยระบุ AssetFieldType ที่เหมาะสม ดังนี้

  • BUSINESS_NAME สำหรับชิ้นงานชื่อธุรกิจ (ซึ่งเป็นชิ้นงานข้อความ)
  • LOGO สำหรับชิ้นงานโลโก้ธุรกิจ (ซึ่งเป็นชิ้นงานรูปภาพ)

การลิงก์ระดับแคมเปญนี้ช่วยให้มั่นใจได้ว่าแบรนด์จะได้รับการนำเสนออย่างสอดคล้องกันในกลุ่มชิ้นงานทั้งหมดภายในแคมเปญ Performance Max

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

ข้อมูลโค้ดต่อไปนี้แสดงการสร้างชิ้นงานที่ทำซ้ำที่จำเป็นในคำขอใหม่

Java

/** Creates multiple text assets and returns the list of resource names. */
private List<String> createMultipleTextAssets(
    GoogleAdsClient googleAdsClient, long customerId, List<String> texts) {
  List<MutateOperation> mutateOperations = new ArrayList<>();
  for (String text : texts) {
    Asset asset = Asset.newBuilder().setTextAsset(TextAsset.newBuilder().setText(text)).build();
    AssetOperation assetOperation = AssetOperation.newBuilder().setCreate(asset).build();
    mutateOperations.add(MutateOperation.newBuilder().setAssetOperation(assetOperation).build());
  }

  List<String> assetResourceNames = new ArrayList<>();
  // Creates the service client.
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    // Sends the operations in a single Mutate request.
    MutateGoogleAdsResponse response =
        googleAdsServiceClient.mutate(Long.toString(customerId), mutateOperations);
    for (MutateOperationResponse result : response.getMutateOperationResponsesList()) {
      if (result.hasAssetResult()) {
        assetResourceNames.add(result.getAssetResult().getResourceName());
      }
    }
    printResponseDetails(response);
  }
  return assetResourceNames;
}

C#

/// <summary>
/// Creates multiple text assets and returns the list of resource names.
/// </summary>
/// <param name="client">The Google Ads Client.</param>
/// <param name="customerId">The customer's ID.</param>
/// <param name="texts">The texts to add.</param>
/// <returns>A list of asset resource names.</returns>
private List<string> CreateMultipleTextAssets(
    GoogleAdsClient client,
    long customerId,
    string[] texts)
{
    // Get the GoogleAdsService.
    GoogleAdsServiceClient googleAdsServiceClient =
        client.GetService(Services.V25.GoogleAdsService);

    MutateGoogleAdsRequest request = new MutateGoogleAdsRequest()
    {
        CustomerId = customerId.ToString()
    };

    foreach (string text in texts)
    {
        request.MutateOperations.Add(
            new MutateOperation()
            {
                AssetOperation = new AssetOperation()
                {
                    Create = new Asset()
                    {
                        TextAsset = new TextAsset()
                        {
                            Text = text
                        }
                    }
                }
            }
        );
    }

    // Send the operations in a single Mutate request.
    MutateGoogleAdsResponse response = googleAdsServiceClient.Mutate(request);

    List<string> assetResourceNames = new List<string>();

    foreach (MutateOperationResponse operationResponse in response.MutateOperationResponses)
    {
        MutateAssetResult assetResult = operationResponse.AssetResult;
        assetResourceNames.Add(assetResult.ResourceName);
    }

    PrintResponseDetails(response);

    return assetResourceNames;
}

PHP

    private static function createMultipleTextAssets(
        GoogleAdsClient $googleAdsClient,
        int $customerId,
        array $texts
    ): array {
        // Here again, we use the GoogleAdService to create multiple text assets in a single
        // request.
        $operations = [];
        foreach ($texts as $text) {
            // Creates a mutate operation for a text asset.
            $operations[] = new MutateOperation(
                [
                'asset_operation' => new AssetOperation(
                    [
                    'create' => new Asset(['text_asset' => new TextAsset(['text' => $text])])
                    ]
                )
                ]
            );
        }

        // Issues a mutate request to add all assets.
        $googleAdsService = $googleAdsClient->getGoogleAdsServiceClient();
        /**
 * @var MutateGoogleAdsResponse $mutateGoogleAdsResponse
*/
        $mutateGoogleAdsResponse =
            $googleAdsService->mutate(MutateGoogleAdsRequest::build($customerId, $operations));

        $assetResourceNames = [];
        foreach ($mutateGoogleAdsResponse->getMutateOperationResponses() as $response) {
            /**
 * @var MutateOperationResponse $response
*/
            $assetResourceNames[] = $response->getAssetResult()->getResourceName();
        }
        self::printResponseDetails($mutateGoogleAdsResponse);

        return $assetResourceNames;
    }

Python

def create_multiple_text_assets(
    client: GoogleAdsClient, customer_id: str, texts: List[str]
) -> List[str]:
    """Creates multiple text assets and returns the list of resource names.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        texts: a list of strings, each of which will be used to create a text
          asset.

    Returns:
        asset_resource_names: a list of asset resource names.
    """
    # Here again we use the GoogleAdService to create multiple text
    # assets in a single request.
    googleads_service: GoogleAdsServiceClient = client.get_service(
        "GoogleAdsService"
    )

    operations: List[MutateOperation] = []
    for text in texts:
        mutate_operation: MutateOperation = client.get_type("MutateOperation")
        asset: Asset = mutate_operation.asset_operation.create
        asset.text_asset.text = text
        operations.append(mutate_operation)

    # Send the operations in a single Mutate request.
    response: MutateGoogleAdsResponse = googleads_service.mutate(
        customer_id=customer_id,
        mutate_operations=operations,
    )
    asset_resource_names: List[str] = []
    for result in response.mutate_operation_responses:
        if result._pb.HasField("asset_result"):
            asset_resource_names.append(result.asset_result.resource_name)
    print_response_details(response)
    return asset_resource_names

Ruby

# Creates multiple text assets and returns the list of resource names.
def create_multiple_text_assets(client, customer_id, texts)
  operations = texts.map do |text|
    client.operation.mutate do |m|
      m.asset_operation = client.operation.create_resource.asset do |asset|
        asset.text_asset = client.resource.text_asset do |text_asset|
          text_asset.text = text
        end
      end
    end
  end

  # Send the operations in a single Mutate request.
  response = client.service.google_ads.mutate(
    customer_id: customer_id,
    mutate_operations: operations,
  )

  asset_resource_names = []
  response.mutate_operation_responses.each do |result|
    if result.asset_result
      asset_resource_names.append(result.asset_result.resource_name)
    end
  end
  print_response_details(response)
  asset_resource_names
end

Perl

sub create_multiple_text_assets {
  my ($api_client, $customer_id, $texts) = @_;

  # Here again we use the GoogleAdService to create multiple text assets in a
  # single request.
  my $operations = [];
  foreach my $text (@$texts) {
    # Create a mutate operation for a text asset.
    push @$operations,
      Google::Ads::GoogleAds::V25::Services::GoogleAdsService::MutateOperation
      ->new({
        assetOperation =>
          Google::Ads::GoogleAds::V25::Services::AssetService::AssetOperation->
          new({
            create => Google::Ads::GoogleAds::V25::Resources::Asset->new({
                textAsset =>
                  Google::Ads::GoogleAds::V25::Common::TextAsset->new({
                    text => $text
                  })})})});
  }

  # Issue a mutate request to add all assets.
  my $mutate_google_ads_response = $api_client->GoogleAdsService()->mutate({
    customerId       => $customer_id,
    mutateOperations => $operations
  });

  my $asset_resource_names = [];
  foreach
    my $response (@{$mutate_google_ads_response->{mutateOperationResponses}})
  {
    push @$asset_resource_names, $response->{assetResult}{resourceName};
  }
  print_response_details($mutate_google_ads_response);

  return $asset_resource_names;
}

curl

การจัดการชิ้นงานโดยอัตโนมัติ

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

การปรับแต่งข้อความ

การปรับแต่งข้อความช่วยให้ AI ของ Google สร้างและปรับแต่งชิ้นงานข้อความสำหรับโฆษณาได้โดยอัตโนมัติ คุณสามารถเพิ่มประสิทธิภาพฟีเจอร์นี้ได้โดยการเชื่อมโยงการรวม URL (ฟีดหน้าเว็บ) ในบัญชีกับแคมเปญ Performance Max เพื่อสร้างชิ้นงานข้อความ

หากต้องการลิงก์การรวม URL กับแคมเปญ ให้ใช้กระบวนการเดียวกับที่ใช้สำหรับโฆษณา Search แบบไดนามิก ดังนี้

  1. สร้างชิ้นงานสําหรับแต่ละหน้าของเว็บไซต์
  2. รวม URL ของหน้าแพ็กเกจลงใน AssetSet
  3. เชื่อมโยงชุดชิ้นงานกับแคมเปญ

หลังจากเชื่อมโยงการรวม URL (ฟีดหน้าเว็บ) แล้ว ให้ตรวจสอบว่า AssetAutomationSetting ประเภท TEXT_ASSET_AUTOMATION ตั้งค่าเป็น OPTED_IN

ซึ่งเป็นการตั้งค่าเริ่มต้นหากคุณไม่ได้ตั้งค่า AssetAutomationSetting เมื่อ สร้างแคมเปญ

การใช้การตั้งค่านี้หมายความว่าแคมเปญของคุณสามารถใช้เนื้อหาจากหน้า Landing Page, โดเมน และชิ้นงานที่ให้ไว้เพื่อปรับแต่งโฆษณา เมื่อระบบคาดการณ์แล้วว่าจะช่วยปรับปรุงประสิทธิภาพได้ เราขอแนะนำให้ปล่อยค่านี้ไว้เป็น OPTED_IN

หลักเกณฑ์เกี่ยวกับข้อความ

หลักเกณฑ์เกี่ยวกับข้อความช่วยให้คุณปรับแต่งข้อความของแบรนด์สำหรับชิ้นงานข้อความที่สร้างขึ้นโดยอัตโนมัติได้โดยการระบุการยกเว้นคำและข้อจำกัดเกี่ยวกับข้อความ

หากต้องการใช้หลักเกณฑ์เกี่ยวกับข้อความ ให้ป้อนข้อมูลในช่อง text_guidelines ของแหล่งข้อมูล Campaign

  • การยกเว้นคำ: ระบุรายการคำหรือวลีที่ตรงกันที่จะยกเว้น จากชิ้นงานข้อความที่สร้างขึ้น การยกเว้นแต่ละรายการมีความยาวได้สูงสุด 30 อักขระ โดยมี การยกเว้นได้สูงสุด 25 รายการ
  • ข้อจำกัดเกี่ยวกับข้อความ: ระบุวิธีการแบบอิสระ (สูงสุด 300 อักขระต่อรายการ) เพื่อเป็นแนวทางในการสร้างข้อความ AI คุณระบุข้อจำกัดได้สูงสุด 40 รายการ รองรับเฉพาะ RESTRICTION_BASED_EXCLUSION สำหรับประเภทการจำกัด

ชิ้นงานวิดีโอ

หากคุณไม่เพิ่มวิดีโอลงในกลุ่มชิ้นงาน Performance Max ระบบอาจสร้างชิ้นงานวิดีโออย่างน้อย 1 รายการจากชิ้นงานในกลุ่มชิ้นงาน หากไม่ต้องการให้วิดีโอที่สร้างขึ้นโดยอัตโนมัติแสดงในแคมเปญ Performance Max อีกต่อไป คุณสามารถอัปโหลดวิดีโอที่กำหนดเองของคุณเอง แล้ววิดีโอที่สร้างขึ้นโดยอัตโนมัติจะหยุดแสดง

การทำงานอัตโนมัติอัจฉริยะอาจเพิ่มประสิทธิภาพชิ้นงานวิดีโอ YouTube โดยการปรับการวางแนววิดีโอและตัดวิดีโอให้สั้นลงอย่างชาญฉลาดเพื่อไฮไลต์ช่วงเวลาสำคัญ หากต้องการเก็บชิ้นงานวิดีโอต้นฉบับไว้ ให้ตั้งค่า AssetAutomationSettingประเภท GENERATE_ENHANCED_YOUTUBE_VIDEOS เป็น OPTED_OUT

นอกจากนี้ Google ยังค้นหาและใช้วิดีโอที่เกี่ยวข้องจากแหล่งที่มาที่ได้รับอนุมัติ เช่น หน้า Landing Page, ช่อง YouTube และช่องทางโซเชียลทั่วไปที่ลิงก์ในหน้า Landing Page (วิดีโอที่ AI จัดหามา) ได้ด้วย ฟีเจอร์เสริมนี้จะ ปิดใช้โดยค่าเริ่มต้น หากต้องการเลือกใช้ ให้ตั้งค่า AssetAutomationSetting ของประเภท AUTOMATED_VIDEO_CRAWL เป็น OPTED_IN และกำหนดค่า automated_video_crawl_setting ด้วย URL แหล่งที่มาและแพลตฟอร์มที่ได้รับอนุมัติ ดูรายละเอียดได้ที่คำแนะนำในการตั้งค่าการทำงานอัตโนมัติของชิ้นงาน

ก่อนหน้า
พารามิเตอร์ ValueTrack
ถัดไป
ข้อกำหนดด้านชิ้นงาน