สถาปัตยกรรม

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

แนวคิดหลัก

เพื่อให้เข้าใจสถาปัตยกรรมของ TensorFlow Serving คุณต้องเข้าใจแนวคิดหลักต่อไปนี้:

เสิร์ฟ

Servables เป็นนามธรรมหลักใน TensorFlow Serving Servables เป็นอ็อบเจ็กต์พื้นฐานที่ไคลเอ็นต์ใช้ในการคำนวณ (เช่น การค้นหาหรือการอนุมาน)

ขนาดและความละเอียดของ Servable นั้นยืดหยุ่นได้ Servable เดียวอาจรวมอะไรก็ได้ตั้งแต่ชาร์ดเดียวของตารางค้นหาไปจนถึงโมเดลเดียวไปจนถึงทูเพิลของโมเดลการอนุมาน Servables สามารถเป็นได้ทุกประเภทและอินเทอร์เฟซ ทำให้มีความยืดหยุ่นและการปรับปรุงในอนาคต เช่น:

  • ผลการสตรีม
  • API ทดลอง
  • โหมดการทำงานแบบอะซิงโครนัส

Servables ไม่ได้จัดการวงจรชีวิตของตนเอง

เสิร์ฟทั่วไปรวมถึงต่อไปนี้:

  • a TensorFlow SavedModelBundle ( tensorflow::Session )
  • ตารางการค้นหาสำหรับการฝังหรือการค้นหาคำศัพท์

รุ่นที่ให้บริการ

TensorFlow Serving สามารถจัดการ เวอร์ชัน หนึ่งหรือมากกว่าของเซิร์ฟเวอร์ได้ตลอดอายุการใช้งานของอินสแตนซ์เซิร์ฟเวอร์เดียว ซึ่งช่วยให้สามารถโหลดการกำหนดค่าอัลกอริธึมใหม่ น้ำหนัก และข้อมูลอื่นๆ เมื่อเวลาผ่านไป เวอร์ชันทำให้สามารถโหลดเซิร์ฟเวอร์ได้มากกว่าหนึ่งเวอร์ชันพร้อมกัน ซึ่งสนับสนุนการเปิดตัวและการทดลองทีละน้อย ในช่วงเวลาที่ให้บริการ ลูกค้าอาจขอเวอร์ชันล่าสุดหรือรหัสเวอร์ชันเฉพาะสำหรับรุ่นใดรุ่นหนึ่ง

สตรีมที่ให้บริการได้

สตรีม ที่ให้บริการได้คือลำดับของเวอร์ชันของเซิร์ฟเวอร์ จัดเรียงตามการเพิ่มหมายเลขเวอร์ชัน

โมเดล

TensorFlow Serving แสดงถึง โมเดล เป็นหนึ่งหรือมากกว่า Servables โมเดลที่เรียนรู้ด้วยเครื่องอาจรวมถึงอัลกอริธึมอย่างน้อยหนึ่งอัลกอริธึม (รวมถึงน้ำหนักที่เรียนรู้) และตารางการค้นหาหรือฝัง

คุณสามารถแสดง โมเดลแบบผสม ได้ด้วยวิธีใดวิธีหนึ่งต่อไปนี้:

  • เสิร์ฟอิสระหลายตัว
  • เสิร์ฟแบบผสมเดียว

เสิร์ฟอาจสอดคล้องกับเศษส่วนของแบบจำลอง ตัวอย่างเช่น ตารางการค้นหาขนาดใหญ่สามารถแบ่งส่วนข้อมูลในอินสแตนซ์ TensorFlow Serving จำนวนมากได้

รถตัก

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

แหล่งที่มา

แหล่งที่มา คือโมดูลปลั๊กอินที่ค้นหาและให้บริการ แหล่งที่มาแต่ละแห่งมีสตรีมที่สามารถแสดงได้เป็นศูนย์หรือมากกว่า สำหรับสตรีมที่ให้บริการได้แต่ละรายการ ซอร์สจะจัดเตรียมอินสแตนซ์ Loader หนึ่งอินสแตนซ์สำหรับแต่ละเวอร์ชันที่เปิดให้โหลดได้ (ที่จริงแล้วแหล่งที่มาถูกผูกมัดร่วมกับ SourceAdapters ที่เป็นศูนย์หรือมากกว่า และรายการสุดท้ายในสายโซ่จะปล่อย Loaders)

อินเทอร์เฟซของ TensorFlow Serving สำหรับ Sources สามารถค้นหาเซิร์ฟเวอร์ได้จากระบบจัดเก็บข้อมูลตามอำเภอใจ TensorFlow Serving มีการนำแหล่งอ้างอิงทั่วไปไปใช้งาน ตัวอย่างเช่น แหล่งที่มาอาจเข้าถึงกลไกต่างๆ เช่น RPC และสามารถสำรวจระบบไฟล์ได้

แหล่งที่มาสามารถรักษาสถานะที่ใช้ร่วมกันระหว่างหลายเซิร์ฟเวอร์หรือหลายเวอร์ชัน สิ่งนี้มีประโยชน์สำหรับเซิร์ฟเวอร์ที่ใช้การอัพเดตเดลต้า (diff) ระหว่างเวอร์ชันต่างๆ

รุ่นที่ต้องการ

เวอร์ชัน Aspired แสดงถึงชุดของเวอร์ชันที่ให้บริการได้ซึ่งควรโหลดและพร้อมใช้งาน แหล่งที่มาจะสื่อสารชุดของเวอร์ชันที่แสดงผลได้นี้สำหรับสตรีมที่แสดงผลได้ครั้งละหนึ่งรายการ เมื่อแหล่งที่มาแสดงรายการเวอร์ชันที่ต้องการใหม่ให้กับตัวจัดการ ก็จะเข้ามาแทนที่รายการก่อนหน้าสำหรับสตรีมที่ให้บริการนั้น ตัวจัดการจะยกเลิกการโหลดเวอร์ชันที่โหลดไว้ก่อนหน้านี้ซึ่งไม่ปรากฏในรายการอีกต่อไป

ดู บทแนะนำขั้นสูง เพื่อดูว่าการโหลดเวอร์ชันทำงานอย่างไรในทางปฏิบัติ

ผู้จัดการ

ผู้จัดการ จัดการวงจรชีวิตของ Servables ทั้งหมด ซึ่งรวมถึง:

  • กำลังโหลด Servables
  • เสิร์ฟอาหาร
  • ขนถ่าย Servables

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

TensorFlow Serving Managers มีอินเทอร์เฟซที่แคบและเรียบง่าย -- GetServableHandle() -- สำหรับลูกค้าในการเข้าถึงอินสแตนซ์ที่ให้บริการที่โหลดได้

แกน

การใช้ TensorFlow Serving APis มาตรฐานทำให้ TensorFlow Serving Core จัดการลักษณะต่อไปนี้ของ servables:

  • วงจรชีวิต
  • เมตริก

TensorFlow Serving Core ถือว่าเซิร์ฟเวอร์และตัวโหลดเป็นวัตถุทึบแสง

ชีวิตของผู้รับใช้

tf ที่ให้บริการไดอะแกรมสถาปัตยกรรม

พูดอย่างกว้างๆ:

  1. แหล่งที่มาสร้างตัวโหลดสำหรับเวอร์ชันที่ให้บริการ
  2. รถตักจะถูกส่งเป็นเวอร์ชัน Aspired ไปยังตัวจัดการ ซึ่งจะโหลดและให้บริการตามคำขอของลูกค้า

รายละเอียดเพิ่มเติม:

  1. ปลั๊กอินต้นทางสร้างตัวโหลดสำหรับเวอร์ชันเฉพาะ Loader มีข้อมูลเมตาที่จำเป็นในการโหลด Servable
  2. แหล่งที่มาใช้การโทรกลับเพื่อแจ้งผู้จัดการเกี่ยวกับเวอร์ชัน Aspired
  3. ผู้จัดการใช้นโยบายเวอร์ชันที่กำหนดค่าไว้เพื่อกำหนดการดำเนินการถัดไป ซึ่งอาจเป็นการยกเลิกการโหลดเวอร์ชันที่โหลดก่อนหน้านี้หรือเพื่อโหลดเวอร์ชันใหม่
  4. หากตัวจัดการพิจารณาว่าปลอดภัย ตัวจัดการจะมอบทรัพยากรที่จำเป็นให้กับตัวโหลดและบอกให้ตัวโหลดโหลดเวอร์ชันใหม่
  5. ลูกค้าขอ Servable จากผู้จัดการ โดยระบุเวอร์ชันอย่างชัดเจนหรือเพียงแค่ขอเวอร์ชันล่าสุด ผู้จัดการส่งคืนหมายเลขอ้างอิงสำหรับ Servable

ตัวอย่างเช่น สมมติว่าแหล่งที่มาแสดงถึงกราฟ TensorFlow พร้อมน้ำหนักแบบจำลองที่อัปเดตบ่อยครั้ง น้ำหนักจะถูกเก็บไว้ในไฟล์บนดิสก์

  1. แหล่งที่มาตรวจพบเวอร์ชันใหม่ของน้ำหนักโมเดล มันสร้างตัวโหลดที่มีตัวชี้ไปยังข้อมูลแบบจำลองบนดิสก์
  2. แหล่งที่มาจะแจ้งให้ Dynamic Manager ทราบเกี่ยวกับเวอร์ชัน Aspired
  3. Dynamic Manager ใช้นโยบายเวอร์ชันและตัดสินใจโหลดเวอร์ชันใหม่
  4. Dynamic Manager บอก Loader ว่ามีหน่วยความจำเพียงพอ Loader สร้างตัวอย่างกราฟ TensorFlow ด้วยน้ำหนักใหม่
  5. ไคลเอนต์ร้องขอหมายเลขอ้างอิงของรุ่นรุ่นล่าสุด และตัวจัดการไดนามิกส่งคืนหมายเลขอ้างอิงไปยังเวอร์ชันใหม่ของ Servable

ความสามารถในการขยาย

TensorFlow Serving มีจุดต่อขยายหลายจุดซึ่งคุณสามารถเพิ่มฟังก์ชันการทำงานใหม่ได้

นโยบายเวอร์ชัน

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

TensorFlow Serving ประกอบด้วยสองนโยบายที่รองรับกรณีการใช้งานที่เป็นที่รู้จักส่วนใหญ่ นโยบายการรักษาความพร้อมใช้งาน (หลีกเลี่ยงการโหลดเวอร์ชันศูนย์ โดยทั่วไปจะโหลดเวอร์ชันใหม่ก่อนที่จะยกเลิกการโหลดเวอร์ชันเก่า) และนโยบายการรักษาทรัพยากร (หลีกเลี่ยงการโหลดสองเวอร์ชันพร้อมกัน ดังนั้นจึงต้องใช้ทรัพยากรเป็นสองเท่า ยกเลิกการโหลดเวอร์ชันเก่าก่อนโหลด ใหม่) สำหรับการใช้งาน TensorFlow Serving อย่างง่าย โดยที่ความพร้อมในการให้บริการของแบบจำลองมีความสำคัญและต้นทุนทรัพยากรต่ำ นโยบายการรักษาความพร้อมใช้งานจะช่วยให้แน่ใจว่าเวอร์ชันใหม่ได้รับการโหลดและพร้อมก่อนที่จะยกเลิกการโหลดเวอร์ชันเก่า สำหรับการใช้งาน TensorFlow Serving ที่ซับซ้อน เช่น การจัดการเวอร์ชันข้ามเซิร์ฟเวอร์หลายอินสแตนซ์ นโยบายการรักษาทรัพยากรต้องการทรัพยากรน้อยที่สุด (ไม่มีบัฟเฟอร์เพิ่มเติมสำหรับการโหลดเวอร์ชันใหม่)

แหล่งที่มา

แหล่งที่มาใหม่สามารถรองรับระบบไฟล์ใหม่ ข้อเสนอระบบคลาวด์ และแบ็กเอนด์อัลกอริธึม TensorFlow Serving มีส่วนประกอบพื้นฐานบางอย่างที่ช่วยให้สร้างแหล่งข้อมูลใหม่ได้ง่ายและรวดเร็ว ตัวอย่างเช่น TensorFlow Serving มียูทิลิตีเพื่อล้อมพฤติกรรมการหยั่งเสียงรอบแหล่งที่มาอย่างง่าย แหล่งที่มามีความเกี่ยวข้องอย่างใกล้ชิดกับตัวโหลดสำหรับอัลกอริธึมเฉพาะและเซิร์ฟเวอร์ข้อมูลที่ให้บริการโฮสต์

ดูเอกสาร แหล่งที่มาที่กำหนดเอง สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการสร้างแหล่งที่มาที่กำหนดเอง

รถตัก

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

ดูเอกสาร Custom Servable เพื่อเรียนรู้วิธีสร้าง Custom Servable

แบทเชอร์

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