รองรับหลายภาษาด้วย Google แปลภาษา

Business Messages ' ภาษา และ Google แปลภาษา การแปลอัตโนมัติและอัจฉริยะ ช่วยให้คุณขยายการเข้าถึงของ Agent ได้โดยการสื่อสารกับผู้ใช้ เป็นภาษาที่พวกเขาต้องการ บทแนะนํานี้จะอธิบายวิธีการรวมหลักฐานของ Google แปลภาษากับเว็บฮุคของ Business Messages

สิ่งที่ต้องมี

ในการเริ่มต้น คุณจะต้องจัดเตรียม 2-3 สิ่งต่อไปนี้

• การลงทะเบียนพาร์ทเนอร์ที่ได้รับอนุมัติโดยสมบูรณ์ด้วย Business Messages โปรดดูคําแนะนําในการลงทะเบียนเป็นพาร์ทเนอร์
• Agent ของ Business Messages รวมถึงคีย์บัญชีบริการ หากต้องการสร้าง Agent โปรดดูคู่มือการสร้าง Agent แรก
• คอมพิวเตอร์ที่ติดตั้ง Google Cloud SDK และ Node.js (เวอร์ชัน 10 ขึ้นไป) ตรวจดูว่าคุณได้ลงชื่อเข้าสู่ระบบและตั้งค่ารหัสโปรเจ็กต์ที่ใช้งานอยู่ใน Google Cloud SDK แล้ว
• อุปกรณ์ Android หรือ iOS ที่ใช้ทดสอบ

รับโค้ด

บทแนะนํานี้จะแนะนําตัวอย่างโค้ดของเว็บฮุคที่ผสานรวมกับ Google แปลภาษา หากต้องการโคลนโค้ด ให้โคลนที่เก็บจาก GitHub โดยทําดังนี้

git clone https://github.com/google-business-communications/bm-nodejs-translation-tutorial

ไปที่ไดเรกทอรีที่โคลนและวางคีย์บัญชีบริการลงในไดเรกทอรีทรัพยากร

cp credentials.json bm-nodejs-translation-sample/resources/bm-agent-service-account-credentials.json

เคล็ดลับ: หากต้องการความช่วยเหลือในการตั้งค่าหรือดาวน์โหลดคีย์บริการ โปรดดูคู่มือ Google Cloud สําหรับจัดการบัญชีบริการ

เมื่อดําเนินการเสร็จแล้ว คุณจะติดตั้งใช้งานโค้ดได้โดยทําดังนี้

gcloud app deploy

ใช้อุปกรณ์เคลื่อนที่ส่งข้อความบางส่วนไปยังตัวแทน ลองส่งข้อความในภาษาต่างๆ และดูว่าเกิดอะไรขึ้น

ตั้งค่า Translate API

โค้ดตัวอย่างมาพร้อมกับแพ็กเกจโหนดสําหรับ Translate API ที่ติดตั้งไว้แล้ว หากสนใจติดตั้งแพ็กเกจ Node หรือวิธีติดตั้ง Translate API ในภาษาเขียนโปรแกรมภาษาอื่น โปรดดูเอกสาร Cloud Translate API

หากต้องการใช้ Translate API คุณต้องนําเข้าไลบรารีและสร้างไคลเอ็นต์ API แปลภาษา เปิดไฟล์ routes/index.js เส้นที่เกี่ยวข้องมีดังนี้

// Import the Translate API library.
const { Translate } = require("@google-cloud/translate").v2;
// Create a new Translate API client.
const translate = new Translate();

นับจากนี้เป็นต้นไป คุณจะสามารถเข้าถึงเมธอดของ API แปลภาษาในออบเจ็กต์แปลภาษาได้

ดูตัวแปรที่สร้างขึ้นใกล้กับด้านบนของไฟล์ดังนี้

const SERVER_LANGUAGE = "en";
let currentLanguage = SERVER_LANGUAGE;

โค้ดตัวอย่างจะจัดเก็บภาษาเซิร์ฟเวอร์ไว้เป็นค่าคงที่ เนื่องจากเป็นค่าที่ค่อนข้างคงที่ แต่ภาษาปัจจุบันของการสนทนาอาจเปลี่ยนแปลงได้ ระบบจึงติดตามการสนทนาในตัวแปร currentLanguage

หมายเหตุ: ในสถานการณ์จริง Agent จะจัดการกับการสนทนาหลายรายการพร้อมกัน ซึ่งหมายความว่าคุณจะต้องเก็บข้อมูลสถานะการสนทนาโดยใช้โซลูชันพื้นที่เก็บข้อมูล เช่น Cloud Datastore จากนั้นคุณจะใช้รหัสการสนทนาเพื่อค้นหาภาษาปัจจุบันของการสนทนานั้นได้ ดูตัวอย่างการใช้ Cloud Datastore ด้วยวิธีนี้ได้ที่ Live Agent CodeCode

ตรวจจับภาษาขาเข้า

โค้ดตัวอย่างจะตรวจหาว่าภาษาที่จะเข้ามาใหม่มีการเปลี่ยนแปลงหรือไม่ และถ้าพร้อม ให้แจ้งให้ผู้ใช้เลือกภาษาที่ต้องการใช้ในการสนทนา ลองใช้ฟีเจอร์นี้ในอุปกรณ์เคลื่อนที่โดยพิมพ์ข้อความที่ตัวแทนเป็นภาษาอื่นนอกเหนือจากภาษาอังกฤษ หากไม่ทราบภาษาอื่นๆ ลองพิมพ์&"Hola" (นั่นแปลว่าสเปนสําหรับ "สวัสดี"!)

ตัวแทนจะตอบกลับพร้อมข้อความแจ้งให้ถามผู้ใช้ว่าต้องการเปลี่ยนภาษาหรือไม่ ซึ่งระบบจะแสดงการตอบกลับที่แนะนําที่ผู้ใช้จะคลิกเพื่อเปลี่ยนไปใช้ภาษานั้นได้

มาดูฟีเจอร์การตรวจหาภาษากันก่อนเลย

/**
 * Detects input text language.
 *
 * @param {string} text The text received from the consumer.
 * @param {Context} context The user message request context.
 * @return A Promise with the detected language code.
 */
async function detectLanguage(text, context) {
  return new Promise(function (resolve, reject) {
    translate
      .detect(text)
      .then((result) => {
        if (result && result.length > 0) {
          if (result[0].confidence > CONFIDENCE_THRESHOLD) {
            resolve(result[0].language);
          }
          resolve(bcp47.parse(context.resolvedLocale).language);
        } else {
          reject("No language detected");
        }
      })
      .catch((err) => {
        console.error("ERROR:", err);
        reject(err);
      });
  });
}

วิธีนี้ใช้วิธีการตรวจหาในไคลเอ็นต์แปลภาษา เนื่องจาก Translate API อาจตรวจจับภาษาได้หลายภาษาด้วยความมั่นใจในระดับต่างๆ (และรองรับอินพุตหลายรายการ) วิธีนี้จึงแสดงผลการค้นหาอาร์เรย์ ตัวอย่างจะแสดงผลลัพธ์แรก ซึ่งเป็นผลลัพธ์ที่มีความเชื่อมั่นสูงสุด

การใช้ภาษาที่แก้ไขแล้ว

บางครั้ง Translate API กําหนดภาษาของข้อความที่มีความเชื่อมั่นสูงไม่ได้ ตัวอย่างเช่น หากแมวของคุณทํางานทั่วแป้นพิมพ์และป้อนสตริงที่ไม่มีความหมาย Translate API จะยังคงพยายามตรวจหาภาษา แต่ภาษาที่ตรวจพบอาจไม่ถูกต้อง (แต่สุดท้ายแล้ว Google แปลภาษา ยังไม่รองรับภาษาแมวเหมียว) Translate API จะระบุค่านี้ด้วยการตั้งค่าความเชื่อมั่นต่ําในผลลัพธ์ translate.detect&#39

ในสถานการณ์นี้ โค้ดตัวอย่างจะกลับไปใช้ภาษาในภาษาที่ Business Messages แก้ไข ซึ่งเป็น Business Messages API ที่เดาข้อความได้ดีที่สุดโดยพิจารณาจากบริบทของ'ข้อความ เนื่องจากภาษาที่แก้ไขอยู่ในรูปแบบ BCP-47 คุณจึงใช้แพ็กเกจ Node.js ที่เกี่ยวข้องเพื่อแยกวิเคราะห์รหัสภาษาจากภาษาดังกล่าวได้

คุณจะทดสอบลักษณะการทํางานนี้ได้โดยพิมพ์สตริงที่ไม่มีความหมายลงใน Agent ในกรณีส่วนใหญ่ คุณไม่ควรเห็นข้อความแจ้งเปลี่ยนภาษา (เว้นแต่ภาษาที่แก้ไขแล้วจะแตกต่างจากภาษาปัจจุบัน) ตัวแทนแค่พูดว่า มันไม่เข้าใจคําขอของคุณ

การแจ้งให้เปลี่ยนภาษา

หลังจากที่ตรวจพบว่าภาษามีการเปลี่ยนแปลง ตัวแทนจะส่งข้อความแจ้งเพื่อเปลี่ยนภาษาอีกครั้ง

if (detectedLanguage != currentLanguage) {
        translateText(
          "Which language would you like to use?",
          SERVER_LANGUAGE,
          currentLanguage
        ).then((normalizedTranslationNotice) => {
          sendResponse(
            normalizedTranslationNotice,
            conversationId,
            [
              ...new Set([detectedLanguage, currentLanguage, SERVER_LANGUAGE]),
            ].map((x) => createSuggestedReply(x))
          );
        });
      }

โค้ดจะสร้างข้อความแจ้ง แปลเป็นภาษาปัจจุบัน (ข้อมูลเพิ่มเติมในส่วนการแปลข้อความขาออก) จากนั้นส่งการตอบกลับพร้อมการตอบกลับที่แนะนํา ผู้ใช้อาจต้องการใช้ภาษาต่อไปนี้

• ภาษาขาเข้าที่ตรวจพบ
• ภาษาของการสนทนาในปัจจุบัน
• ภาษาในตัวของเซิร์ฟเวอร์

เนื่องจากอาจมีการทับซ้อนกันใน 3 ภาษานี้ (เช่น หากภาษาปัจจุบันเป็นภาษาเซิร์ฟเวอร์อยู่แล้ว) เซิร์ฟเวอร์จะใช้ออบเจ็กต์ที่ตั้งค่าไว้เพื่อนํารายการที่ซ้ํากันออก จากนั้นระบบจะสร้างคําตอบที่แนะนําสําหรับแต่ละภาษาดังนี้

/**
 * Create a suggested reply for a language code.
 * @param {string} languageCode A ISO 6391 language code.
 * @return {Suggestion} The suggestion object for switching to the language.
 */
function createSuggestedReply(languageCode) {
  return {
    reply: {
      text: ISO6391.getNativeName(languageCode),
      postbackData: SWITCH_LANGUAGE_POSTBACK + languageCode,
    },
  };
}

คําตอบที่แนะนําจะแสดงชื่อภาษาในภาษานั้นเอง เช่น ภาษาสเปนแสดงเป็น "Español." หากต้องการดูข้อมูลเกี่ยวกับภาษาจากรหัสภาษา 2 หลัก ให้ใช้ไลบรารี ISO-639-1 สําหรับ Node.js

สังเกตข้อมูล Postback ที่จะส่งไปยังเซิร์ฟเวอร์เมื่อผู้ใช้คลิกคําแนะนํานี้ ข้อมูล Postback จะบอกให้เซิร์ฟเวอร์ทราบว่าจะตอบสนองอย่างไรและให้บริบทเกี่ยวกับคําแนะนํานั้น

เมธอด sendResponse จะแนบออบเจ็กต์คําแนะนําเหล่านี้ไปพร้อมกับการตอบกลับ

let messageObject = {
    …
    suggestions: suggestedReplies,
  };

กําลังเปลี่ยนภาษาของการสนทนา

กลับไปที่อุปกรณ์เคลื่อนที่แล้วลองคลิกตัวเลือกภาษาใหม่ในข้อความแจ้งจากก่อนหน้านี้ เช่น หากพิมพ์ "Hola&&tt; ให้ลองคลิก "Español" ในคําตอบที่แนะนํา

ตัวแทนจะตอบกลับด้วยภาษาใหม่ เราจะพูดถึงวิธีแปลการตอบกลับขาออกในขั้นตอนต่อไป ตอนนี้ ให้ดูโค้ดที่ได้รับและประมวลผลการตอบกลับที่แนะนําที่คุณคลิก

if (requestBody.suggestionResponse !== undefined) {
    let postbackData = requestBody.suggestionResponse.postbackData;
    if (postbackData.startsWith(SWITCH_LANGUAGE_POSTBACK)) {
      let languageCode = postbackData.substr(SWITCH_LANGUAGE_POSTBACK.length);
      currentLanguage = languageCode;
      translateText(
        "The language was set to " +
          ISO6391.getName(languageCode) +
          ". Please repeat your request.",
        SERVER_LANGUAGE,
        languageCode
      ).then((translationNotice) => {
        sendResponse(translationNotice, conversationId, []);
      });
    }
  }

หากคําขอมีการตอบกลับคําแนะนํา เซิร์ฟเวอร์จะใช้ข้อมูล Postback เพื่อระบุสิ่งที่ต้องทํา ในกรณีง่ายๆ นี้ เซิร์ฟเวอร์จะรองรับข้อมูล Postback เพียงประเภทเดียว นั่นคือ SWITCH_LANGUAGE_POSTBACK ซึ่งบ่งบอกว่าการสนทนาควรเปลี่ยนเป็นภาษาในภาษาต่อไปนี้ทันที หลังจากแยกวิเคราะห์รหัสภาษานี้แล้ว เซิร์ฟเวอร์จะส่งข้อความเพื่อแจ้งให้ผู้ใช้ทราบว่าภาษามีการเปลี่ยนแปลง

การแปลข้อความขาเข้า

เนื่องจากตอนนี้ภาษาเปลี่ยนแปลงไป คุณสามารถส่งคําขอไปยังตัวแทนในภาษานั้นได้ในอุปกรณ์เคลื่อนที่ ลองส่งคําว่า ""help" ในภาษาใหม่ หากเปลี่ยนภาษาเป็นภาษาสเปน ให้พิมพ์ "ayuda" แล้วส่งข้อความ

เซิร์ฟเวอร์จะเข้าใจคําขอความช่วยเหลือและการตอบกลับของคุณด้วยเมนูตัวเลือก ลองใช้วิธีใดก็ได้เพื่อดูตัวอย่างคําตอบแบบฮาร์ดโค้ด

โค้ดตัวอย่างใช้เมธอด translateText เพื่อแปลทั้งข้อความขาเข้าและขาออก ลองดูเลย

/**
 * Translates text to a given target language. No translation if source and
 * target language match.
 *
 * @param {string} text the text to translate
 * @param {string} sourceLanguage The language of the source text.
 * @param {string} targetLanguage The target language.
 * @return A Promise with the translated text.
 */
async function translateText(text, sourceLanguage, targetLanguage) {
  if (sourceLanguage === targetLanguage) {
    return new Promise(function (resolve, reject) {
      resolve(text);
    });
  }
  return new Promise(function (resolve, reject) {
    translate
      .translate(text, targetLanguage)
      .then((result) => {
        if (result && result.length > 0) {
          resolve(result[0]);
        } else {
          reject("Could not translate message");
        }
      })
      .catch((err) => {
        console.error("ERROR:", err);
        reject(err);
      });
  });
}

หากภาษาต้นฉบับตรงกับภาษาเป้าหมาย ก็ไม่จําเป็นต้องดําเนินการใดๆ มิเช่นนั้น เซิร์ฟเวอร์จะเรียกใช้วิธีการแปลภาษาในไคลเอ็นต์ Translate API วิธีการแปลสามารถใช้หลายอินพุตได้เช่นเดียวกับวิธีตรวจจับ เนื่องจากเซิร์ฟเวอร์จะให้เพียงอินพุตเดียว จึงได้รับผลลัพธ์แรกจาก Translate API

ดูหัวข้อของวิธีการโทรกลับที่ตอบกลับข้อความขาเข้าในภาษาปัจจุบัน ดังนี้

translateText(incomingMessage, currentLanguage, SERVER_LANGUAGE).then(
          (normalizedMessage) => {
            let serverResponse = chooseResponseMessage(normalizedMessage);
            …
          }
        );

เซิร์ฟเวอร์ใช้เอาต์พุตจาก translateText เพื่อเลือกข้อความตอบกลับ ส่วนถัดไปจะอธิบายขั้นตอนการเลือกข้อความตอบกลับและการแปล

การแปลข้อความขาออก

หลังจากที่เซิร์ฟเวอร์แปลข้อความขาเข้าของคุณเป็นภาษาอังกฤษแบบเนทีฟแล้ว เซิร์ฟเวอร์จะต้องเลือก แปล และส่งคําตอบที่เหมาะกับคําขอของผู้ใช้ โค้ดตัวอย่างนี้ใช้กลอุบายง่ายๆ ที่จับคู่คีย์เวิร์ดกับคําตอบ ลองดูเมธอด chooseResponseMessage

/**
 * Select a topically appropriate response based on the message
 * content that the user sent to the agent.
 *
 * @param {string} incomingMessage The content of the message that the user typed in.
 * @param {string} conversationId The unique id for this user and agent.
 * @return {string} A response message.
 */
function chooseResponseMessage(incomingMessage) {
  let responseMapping = {
    balance: "Your current balance is $500.",
    deposit: "Please enter your deposit amount.",
    transfer:
      "Please enter the account number where you wish to transfer the funds.",
    withdraw: "Please enter the amount you wish to withdraw.",
    help: "Please choose what you'd like to do: balance, deposit, transfer, or withdraw.",
  };

  for (const [key, value] of Object.entries(responseMapping)) {
    if (incomingMessage.toLowerCase().includes(key)) {
      return value;
    }
  }

  return "I didn't understand your request. Please try again.";
}

รูปแบบนี้รองรับภาษาอังกฤษบนเซิร์ฟเวอร์เท่านั้น ซึ่งหมายความว่าเซิร์ฟเวอร์ต้องแปลข้อความขาเข้าและขาออกทั้งหมด ระบบที่ซับซ้อนขึ้นอาจรองรับหลายภาษาและตอบสนองคําขอในภาษาต่างๆ ได้อย่างลื่นไหล เช่น หากตัวแทนของคุณรองรับภาษาสเปน อาจเป็นเพราะมีคีย์สําหรับ&&tt;ayuda" อยู่ในแผนที่การตอบกลับอยู่แล้ว นอกจากนี้ ระบบที่ซับซ้อนยังอาจอาศัยวิธีการอื่นๆ ในการเลือกคําตอบที่เหมาะสม เช่น ML หรืออัลกอริทึม วิธีหนึ่งในการสร้างคําตอบที่ชาญฉลาดมากขึ้นด้วย Business Messages คือการผสานรวมกับ Dialogflow

ในตอนนี้ ให้ดูที่โค้ดที่จะส่งข้อความที่เลือกกลับไปยังผู้ใช้

let serverResponse = chooseResponseMessage(normalizedMessage);
            translateText(
              serverResponse,
              SERVER_LANGUAGE,
              currentLanguage
            ).then((normalizedResponse) => {
              sendResponse(normalizedResponse, conversationId, []);
            });

โค้ดตัวอย่างใช้เมธอด translateText ซ้ําเพื่อแปลการตอบกลับที่เลือกเป็นภาษาของการสนทนาปัจจุบัน เมธอด sendResponse จะทําหน้าที่สร้างออบเจ็กต์ข้อความใหม่และส่งไปยังผู้ใช้

สรุป

ในบทแนะนํานี้ คุณได้เรียนรู้วิธีสร้างการผสานรวมที่ง่ายดายกับ Cloud Translate API และใช้ประโยชน์จากฟีเจอร์ภาษาของ Business Messages เพื่อเข้าถึงผู้ใช้ได้มากขึ้น คุณใช้โค้ดตัวอย่างในบทแนะนํานี้เป็นจุดเริ่มต้นสําหรับการผสานรวมของคุณเองได้ หรือจะลองโค้ดใหม่ก็ได้ ลองดูแนวคิดบางส่วนกัน

• ส่งข้อความ 2 ภาษาที่มีทั้งเนื้อหาข้อความต้นฉบับและเนื้อหาที่แปลโดยอัตโนมัติ
• นําเสนอภาษาที่รองรับแบบเต็มภาษาให้แก่ผู้ใช้เมื่อพวกเขาเริ่มสนทนา
• ใช้ประโยชน์จากฟีเจอร์แปลภาษา API ขั้นสูง เช่น อภิธานศัพท์เพื่อแปลคําเฉพาะสําหรับธุรกิจได้อย่างน่าเชื่อถือ

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

ลิงก์ที่เกี่ยวข้อง

• คู่มือการแปลและ Localization
• เอกสาร Cloud Translate API