การประมวลผลข้อมูลล่วงหน้าสำหรับ ML: ตัวเลือกและคำแนะนำ

เอกสารนี้เป็นเอกสารชุดแรกในชุดสองส่วนที่สำรวจหัวข้อวิศวกรรมข้อมูลและวิศวกรรมคุณลักษณะสำหรับการเรียนรู้ของเครื่อง (ML) โดยมุ่งเน้นที่งานการเรียนรู้แบบมีผู้สอน ส่วนแรกนี้กล่าวถึงแนวทางปฏิบัติที่ดีที่สุดสำหรับการประมวลผลข้อมูลล่วงหน้าในไปป์ไลน์ ML บน Google Cloud เอกสารนี้มุ่งเน้นไปที่การใช้ TensorFlow และไลบรารี TensorFlow Transform ( tf.Transform ) แบบโอเพนซอร์สเพื่อจัดเตรียมข้อมูล ฝึกโมเดล และให้บริการโมเดลสำหรับการคาดการณ์ เอกสารนี้เน้นย้ำถึงความท้าทายในการประมวลผลข้อมูลล่วงหน้าสำหรับ ML และอธิบายถึงตัวเลือกและสถานการณ์ในการดำเนินการเปลี่ยนแปลงข้อมูลบน Google Cloud อย่างมีประสิทธิภาพ

เอกสารนี้จะถือว่าคุณคุ้นเคยกับ BigQuery , Dataflow , Vertex AI และ TensorFlow Keras API

เอกสารที่สอง การประมวลผลข้อมูลล่วงหน้าสำหรับ ML ด้วย Google Cloud มีบทช่วยสอนทีละขั้นตอนเกี่ยวกับวิธีใช้งานไปป์ไลน์ tf.Transform

การแนะนำ

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

การสร้างโมเดล ML เป็นกระบวนการที่มีหลายขั้นตอน แต่ละขั้นตอนนำเสนอความท้าทายทางเทคนิคและแนวความคิดของตัวเอง ซีรีส์สองส่วนนี้มุ่งเน้นไปที่งานการเรียนรู้ภายใต้การดูแลและกระบวนการในการเลือก การแปลง และการเพิ่มข้อมูลต้นฉบับเพื่อสร้างสัญญาณการทำนายที่มีประสิทธิภาพไปยังตัวแปรเป้าหมาย การดำเนินการเหล่านี้รวมความรู้โดเมนเข้ากับเทคนิควิทยาศาสตร์ข้อมูล การดำเนินงานถือเป็นหัวใจสำคัญของ วิศวกรรมคุณลักษณะ

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

เอกสารนี้กล่าวถึงความท้าทายเหล่านี้สำหรับระดับรายละเอียดต่างๆ ของการดำเนินการทางวิศวกรรมฟีเจอร์: การรวมระดับอินสแตนซ์ แบบเต็ม และกรอบเวลา เอกสารนี้ยังอธิบายตัวเลือกและสถานการณ์ในการดำเนินการแปลงข้อมูลสำหรับ ML บน Google Cloud

เอกสารนี้ยังให้ภาพรวมของ TensorFlow Transform ( tf.Transform ) ซึ่งเป็นไลบรารีสำหรับ TensorFlow ที่ช่วยให้คุณกำหนดการแปลงข้อมูลทั้งระดับอินสแตนซ์และแบบเต็มผ่านไปป์ไลน์การประมวลผลข้อมูลล่วงหน้า ไปป์ไลน์เหล่านี้ดำเนินการด้วย Apache Beam และสร้างอาร์ติแฟกต์ที่ช่วยให้คุณใช้การแปลงเดียวกันระหว่างการคาดการณ์ได้เช่นเดียวกับเมื่อมีการให้บริการโมเดล

กำลังประมวลผลข้อมูลล่วงหน้าสำหรับ ML

ส่วนนี้จะแนะนำการดำเนินการประมวลผลข้อมูลล่วงหน้าและขั้นตอนความพร้อมของข้อมูล นอกจากนี้ยังกล่าวถึงประเภทของการดำเนินการก่อนการประมวลผลและรายละเอียดอีกด้วย

วิศวกรรมข้อมูลเปรียบเทียบกับวิศวกรรมฟีเจอร์

การประมวลผลข้อมูลล่วงหน้าสำหรับ ML เกี่ยวข้องกับทั้งวิศวกรรมข้อมูลและวิศวกรรมฟีเจอร์ วิศวกรรมข้อมูลเป็นกระบวนการแปลง ข้อมูลดิบ เป็น ข้อมูลที่เตรียมไว้ จากนั้นวิศวกรรมฟีเจอร์จะปรับแต่งข้อมูลที่เตรียมไว้เพื่อสร้างคุณสมบัติที่โมเดล ML คาดหวัง คำเหล่านี้มีความหมายดังต่อไปนี้:

ข้อมูลดิบ (หรือเพียงแค่ data )

ข้อมูลในรูปแบบแหล่งที่มา โดยไม่ต้องเตรียม ML ล่วงหน้า ในบริบทนี้ ข้อมูลอาจอยู่ในรูปแบบดิบ (ใน Data Lake) หรือในรูปแบบที่ได้รับการแปลง (ในคลังข้อมูล) ข้อมูลที่แปลงแล้วซึ่งอยู่ในคลังข้อมูลอาจถูกแปลงจากรูปแบบดิบดั้งเดิมเพื่อใช้สำหรับการวิเคราะห์ อย่างไรก็ตาม ในบริบทนี้ ข้อมูลดิบ หมายความว่าข้อมูลไม่ได้จัดเตรียมไว้สำหรับงาน ML ของคุณโดยเฉพาะ ข้อมูลยังถือเป็นข้อมูลดิบหากส่งจากระบบสตรีมมิงที่เรียกโมเดล ML สำหรับการคาดการณ์ในที่สุด

ข้อมูลที่เตรียมไว้

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

คุณสมบัติทางวิศวกรรม

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

แผนภาพต่อไปนี้ รูปที่ 1 แสดงขั้นตอนที่เกี่ยวข้องในการเตรียมข้อมูลที่ประมวลผลล่วงหน้า:

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

การดำเนินการประมวลผลล่วงหน้า

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

สำหรับข้อมูลที่มีโครงสร้าง การดำเนินการประมวลผลข้อมูลล่วงหน้ามีดังต่อไปนี้

• การล้างข้อมูล: การลบหรือแก้ไขบันทึกที่มีค่าเสียหายหรือไม่ถูกต้องจากข้อมูลดิบ และลบบันทึกที่ขาดคอลัมน์จำนวนมาก
• การเลือกอินสแตนซ์และการแบ่งพาร์ติชัน: การเลือกจุดข้อมูลจากชุดข้อมูลอินพุตเพื่อสร้าง การฝึกอบรม การประเมิน (การตรวจสอบความถูกต้อง) และชุดการทดสอบ กระบวนการนี้รวมถึงเทคนิคสำหรับการสุ่มตัวอย่างแบบทำซ้ำ การสุ่มตัวอย่างคลาสส่วนน้อยที่มากเกินไป และการแบ่งพาร์ติชันแบบแบ่งชั้น
• การปรับแต่งคุณสมบัติ: การปรับปรุงคุณภาพของคุณสมบัติสำหรับ ML ซึ่งรวมถึงการปรับขนาดและการทำให้ค่าตัวเลขเป็นมาตรฐาน การใส่ค่าที่หายไป การตัดค่าผิดปกติ และการปรับค่าที่มีการแจกแจงที่บิดเบี้ยว
• การแปลงคุณสมบัติ: การแปลงคุณสมบัติเชิงตัวเลขให้เป็นคุณสมบัติเชิงหมวดหมู่ (ผ่าน การเก็บข้อมูล ) และการแปลงคุณสมบัติเชิงหมวดหมู่เป็นการแสดงตัวเลข (ผ่านการเข้ารหัสแบบร้อนแรงเดียว การเรียนรู้ด้วยการนับ การฝังฟีเจอร์แบบกระจัดกระจาย ฯลฯ) บางรุ่นใช้งานได้กับคุณสมบัติตัวเลขหรือหมวดหมู่เท่านั้น ในขณะที่รุ่นอื่นๆ สามารถจัดการกับคุณสมบัติประเภทผสมได้ แม้ว่าโมเดลจะจัดการทั้งสองประเภท แต่ก็สามารถได้รับประโยชน์จากการแสดงที่แตกต่างกัน (ตัวเลขและหมวดหมู่) ของฟีเจอร์เดียวกัน
• การดึงข้อมูลคุณลักษณะ: การลดจำนวนคุณลักษณะโดยการสร้างการแสดงข้อมูลที่มีขนาดต่ำกว่าและมีประสิทธิภาพมากขึ้นโดยใช้เทคนิคต่างๆ เช่น PCA การฝัง การแยกข้อมูล และ การแฮช
• การเลือกคุณสมบัติ: การเลือกชุดย่อยของคุณสมบัติอินพุตสำหรับการฝึกโมเดล และไม่สนใจคุณสมบัติที่ไม่เกี่ยวข้องหรือซ้ำซ้อน โดยใช้ วิธีกรองหรือ Wrapper การเลือกคุณสมบัติอาจเกี่ยวข้องกับการปล่อยคุณสมบัติหากคุณสมบัติขาดหายไปเป็นจำนวนมาก
• การสร้างคุณลักษณะ: การสร้างคุณลักษณะใหม่โดยใช้เทคนิคทั่วไป เช่น การขยายพหุนาม (โดยใช้ฟังก์ชันทางคณิตศาสตร์ที่ไม่แปรเปลี่ยน) หรือ การข้ามคุณลักษณะ (เพื่อจับภาพการโต้ตอบของคุณลักษณะ) คุณสมบัติยังสามารถสร้างได้โดยใช้ตรรกะทางธุรกิจจากโดเมนของกรณีการใช้งาน ML

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

• สำหรับเอกสารข้อความ: การย่อคำและย่อคำ การคำนวณ TF-IDF และการแยก n-gram การค้นหาแบบฝัง
• สำหรับรูปภาพ: การตัด การปรับขนาด การครอบตัด การเบลอแบบเกาส์เซียน และตัวกรองคานารี
• สำหรับข้อมูลทุกประเภท (รวมถึงข้อความและรูปภาพ): ถ่ายโอนการเรียนรู้ ซึ่งถือว่าเลเยอร์ทั้งหมดยกเว้นเลเยอร์สุดท้ายของโมเดลที่ผ่านการฝึกอบรมอย่างเต็มรูปแบบเป็นขั้นตอนทางวิศวกรรมฟีเจอร์

กำลังประมวลผลรายละเอียดล่วงหน้า

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

การดำเนินการก่อนการประมวลผลและการเปลี่ยนแปลงสามารถจัดประเภทได้ดังต่อไปนี้ โดยขึ้นอยู่กับความละเอียดของการดำเนินการ:

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

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

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

  ตัวอย่างเช่น ในการปรับคุณลักษณะตัวเลขให้เป็นมาตรฐานสำหรับการฝึก คุณจะต้องคำนวณค่าเฉลี่ย (μ) และค่าเบี่ยงเบนมาตรฐาน (σ) จากข้อมูลการฝึกทั้งหมด การคำนวณนี้เรียกว่าการดำเนินการแบบ เต็มรอบ (หรือ วิเคราะห์ ) เมื่อคุณให้บริการแบบจำลองสำหรับการคาดการณ์ ค่าของจุดข้อมูลใหม่จะถูกทำให้เป็นมาตรฐานเพื่อหลีกเลี่ยงการบิดเบือนการให้บริการการฝึก ดังนั้น ค่า μ และ σ ที่คำนวณระหว่างการฝึกจึงถูกนำมาใช้เพื่อปรับค่าฟีเจอร์ ซึ่งเป็นการดำเนินการ ระดับอินสแตนซ์ อย่างง่ายดังต่อไปนี้:

  $$ value_{scaled} = (value_{raw} - \mu) \div \sigma $$

  การแปลงฟูลพาสมีดังต่อไปนี้:

  • MinMax ปรับขนาดคุณสมบัติตัวเลขโดยใช้ ค่าต่ำสุด และ สูงสุด ที่คำนวณจากชุดข้อมูลการฝึก
  • คุณสมบัติตัวเลขมาตราส่วนมาตรฐาน (การทำให้เป็นมาตรฐานคะแนน z) โดยใช้ μ และ σ คำนวณบนชุดข้อมูลการฝึกอบรม
  • การรวมคุณสมบัติเชิงตัวเลขโดยใช้ควอนไทล์
  • การใส่ค่าที่หายไปโดยใช้ค่ามัธยฐาน (คุณสมบัติตัวเลข) หรือโหมด (คุณสมบัติหมวดหมู่)
  • การแปลงสตริง (ค่าที่กำหนด) เป็นจำนวนเต็ม (ดัชนี) โดยแยกค่าที่แตกต่างทั้งหมด (คำศัพท์) ของคุณลักษณะหมวดหมู่อินพุต
  • การนับการเกิดขึ้นของคำศัพท์ (ค่าคุณลักษณะ) ในเอกสารทั้งหมด (อินสแตนซ์) เพื่อคำนวณหา TF-IDF
  • การคำนวณ PCA ของคุณสมบัติอินพุตเพื่อฉายข้อมูลลงในพื้นที่มิติที่ต่ำกว่า (พร้อมคุณสมบัติที่ขึ้นต่อเชิงเส้น)

  คุณควรใช้เฉพาะข้อมูลการฝึกเพื่อคำนวณสถิติเช่น μ, σ, min และ max หากคุณเพิ่มข้อมูลการทดสอบและการประเมินผลสำหรับการดำเนินการเหล่านี้ คุณกำลัง รั่วไหลข้อมูล จากข้อมูลการประเมินและทดสอบเพื่อฝึกโมเดล การทำเช่นนี้จะส่งผลต่อความน่าเชื่อถือของผลการทดสอบและการประเมินผล เพื่อให้แน่ใจว่าคุณได้ใช้การเปลี่ยนแปลงที่สม่ำเสมอกับชุดข้อมูลทั้งหมด คุณใช้สถิติเดียวกันที่คำนวณจากข้อมูลการฝึกเพื่อแปลงข้อมูลการทดสอบและการประเมินผล

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

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

  แม่นยำยิ่งขึ้น เมื่อคุณเตรียมข้อมูลการฝึกอบรม หากค่ารวมไม่อยู่ในข้อมูลดิบ ค่าจะถูกสร้างขึ้นในระหว่างขั้นตอนวิศวกรรมข้อมูล ข้อมูลดิบมักจะถูกเก็บไว้ในฐานข้อมูลด้วยรูปแบบ (entity, timestamp, value) ในตัวอย่างก่อนหน้านี้ entity คือตัวระบุส่วนของเส้นทางสำหรับเส้นทางแท็กซี่และตัวระบุชิ้นส่วนเครื่องยนต์สำหรับความล้มเหลวของเครื่องยนต์ คุณสามารถใช้การดำเนินการหน้าต่างเพื่อคำนวณ (entity, time_index, aggregated_value_over_time_window) และใช้คุณลักษณะการรวมเป็นอินพุตสำหรับการฝึกโมเดลของคุณ

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

ไปป์ไลน์ ML บน Google Cloud

ส่วนนี้จะกล่าวถึงองค์ประกอบหลักของไปป์ไลน์แบบ end-to-end โดยทั่วไปเพื่อฝึกอบรมและให้บริการโมเดล TensorFlow ML บน Google Cloud โดยใช้บริการที่มีการจัดการ นอกจากนี้ยังอภิปรายการว่าคุณสามารถใช้การดำเนินการประมวลผลข้อมูลล่วงหน้าประเภทต่างๆ ได้ที่ไหน และความท้าทายทั่วไปที่คุณอาจเผชิญเมื่อคุณใช้การแปลงดังกล่าว ส่วน วิธีการทำงานของ tf.Transform แสดงให้เห็นว่าไลบรารี TensorFlow Transform ช่วยจัดการกับความท้าทายเหล่านี้ได้อย่างไร

สถาปัตยกรรมระดับสูง

แผนภาพต่อไปนี้ รูปที่ 2 แสดงสถาปัตยกรรมระดับสูงของไปป์ไลน์ ML ทั่วไปสำหรับการฝึกและการให้บริการโมเดล TensorFlow ป้าย A, B และ C ในไดอะแกรมอ้างอิงถึงตำแหน่งต่างๆ ในไปป์ไลน์ที่สามารถประมวลผลข้อมูลล่วงหน้าได้ รายละเอียดเกี่ยวกับขั้นตอนเหล่านี้มีอยู่ในส่วนต่อไปนี้

ไปป์ไลน์ประกอบด้วยขั้นตอนต่อไปนี้:

1. หลังจากนำเข้าข้อมูลดิบแล้ว ข้อมูลแบบตารางจะจัดเก็บไว้ใน BigQuery และข้อมูลอื่นๆ เช่น รูปภาพ เสียง และวิดีโอ จะถูกจัดเก็บไว้ใน Cloud Storage ส่วนที่สองของชุดนี้ใช้ข้อมูลแบบตารางที่จัดเก็บไว้ใน BigQuery เป็นตัวอย่าง
2. วิศวกรรมข้อมูล (การเตรียมการ) และวิศวกรรมฟีเจอร์ดำเนินการในวงกว้างโดยใช้ Dataflow การดำเนินการนี้จะสร้างชุดการฝึกอบรม การประเมิน และการทดสอบที่พร้อมใช้งาน ML ซึ่งจัดเก็บไว้ใน Cloud Storage ตามหลักการแล้ว ชุดข้อมูลเหล่านี้จะถูกจัดเก็บเป็นไฟล์ TFRecord ซึ่งเป็นรูปแบบที่ปรับให้เหมาะสมที่สุดสำหรับการคำนวณ TensorFlow
3. แพ็คเกจตัวฝึก โมเดล TensorFlow จะถูกส่งไปยัง Vertex AI Training ซึ่งใช้ข้อมูลที่ประมวลผลล่วงหน้าจากขั้นตอนก่อนหน้าเพื่อฝึกโมเดล ผลลัพธ์ของขั้นตอนนี้คือ TensorFlow SavedModel ที่ได้รับการฝึกอบรมซึ่งส่งออกไปยัง Cloud Storage
4. โมเดล TensorFlow ที่ผ่านการฝึกอบรมถูกปรับใช้กับ Vertex AI Prediction เป็นบริการที่มี REST API เพื่อให้สามารถใช้สำหรับการคาดการณ์ออนไลน์ได้ โมเดลเดียวกันนี้สามารถใช้กับงานการคาดการณ์แบบแบตช์ได้
5. หลังจากปรับใช้โมเดลเป็น REST API แล้ว แอปไคลเอนต์และระบบภายในสามารถเรียกใช้ API ได้โดยการส่งคำขอพร้อมจุดข้อมูลบางส่วน และรับการตอบสนองจากโมเดลพร้อมการคาดการณ์
6. สำหรับการจัดเตรียมและทำให้ไปป์ไลน์นี้เป็นอัตโนมัติ คุณสามารถใช้ Vertex AI Pipelines เป็นตัวกำหนดเวลาเพื่อเรียกใช้ขั้นตอนการจัดเตรียมข้อมูล การฝึกโมเดล และขั้นตอนการปรับใช้โมเดล

คุณยังสามารถใช้ Vertex AI Feature Store เพื่อจัดเก็บคุณสมบัติอินพุตเพื่อทำการคาดการณ์ได้ ตัวอย่างเช่น คุณสามารถสร้างคุณสมบัติทางวิศวกรรมเป็นระยะจากข้อมูลดิบล่าสุด และจัดเก็บไว้ใน Vertex AI Feature Store แอปไคลเอนต์ดึงคุณสมบัติอินพุตที่จำเป็นจาก Vertex AI Feature Store และส่งไปยังโมเดลเพื่อรับการคาดการณ์

จะต้องดำเนินการล่วงหน้าที่ไหน

ในรูปที่ 2 ป้ายกำกับ A, B และ C แสดงให้เห็นว่าการดำเนินการประมวลผลข้อมูลล่วงหน้าสามารถเกิดขึ้นใน BigQuery, Dataflow หรือ TensorFlow ส่วนต่อไปนี้จะอธิบายวิธีการทำงานของแต่ละตัวเลือกเหล่านี้

ตัวเลือก A: BigQuery

โดยทั่วไปแล้ว ตรรกะจะถูกนำมาใช้ใน BigQuery สำหรับการดำเนินการต่อไปนี้

• การสุ่มตัวอย่าง: สุ่มเลือกชุดย่อยจากข้อมูล
• การกรอง: ลบอินสแตนซ์ที่ไม่เกี่ยวข้องหรือไม่ถูกต้องออก
• การแบ่งพาร์ติชัน: การแบ่งข้อมูลเพื่อสร้างชุดการฝึกอบรม การประเมิน และการทดสอบ

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

อย่างไรก็ตาม เราขอแนะนำให้คุณใช้ BigQuery สำหรับวิศวกรรมฟีเจอร์เฉพาะในกรณีที่คุณใช้แบบจำลองของคุณสำหรับการทำนายแบบกลุ่ม (การให้คะแนน) หรือหากฟีเจอร์นั้นได้รับการคำนวณล่วงหน้าใน BigQuery แต่จัดเก็บไว้ใน Vertex AI Feature Store เพื่อใช้ในระหว่างการทำนายแบบออนไลน์ หากคุณวางแผนที่จะปรับใช้โมเดลสำหรับการคาดการณ์ออนไลน์ และหากคุณไม่มีคุณสมบัติทางวิศวกรรมในร้านค้าฟีเจอร์ออนไลน์ คุณจะต้องจำลองการดำเนินการประมวลผลล่วงหน้าของ SQL เพื่อแปลงจุดข้อมูลดิบที่ระบบอื่นสร้างขึ้น กล่าวอีกนัยหนึ่ง คุณต้องใช้ตรรกะสองครั้ง: ครั้งแรกใน SQL เพื่อประมวลผลข้อมูลการฝึกล่วงหน้าใน BigQuery และครั้งที่สองในตรรกะของแอปที่ใช้โมเดลเพื่อประมวลผลจุดข้อมูลออนไลน์ล่วงหน้าสำหรับการคาดการณ์

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

หากคุณใช้โมเดลของคุณสำหรับการทำนายแบทช์เท่านั้น (เช่น การใช้ Vertex AI การทำนายแบทช์ ) และหากข้อมูลสำหรับการให้คะแนนของคุณมาจาก BigQuery คุณจะใช้การดำเนินการประมวลผลล่วงหน้าเหล่านี้เป็นส่วนหนึ่งของสคริปต์ BigQuery SQL ได้ ในกรณีนั้น คุณสามารถใช้สคริปต์ SQL การประมวลผลล่วงหน้าเดียวกันเพื่อเตรียมข้อมูลการฝึกอบรมและการให้คะแนนได้

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

ตัวเลือก B: กระแสข้อมูล

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

Dataflow สามารถทำการเปลี่ยนแปลงระดับอินสแตนซ์ และการเปลี่ยนแปลงฟีเจอร์การรวมในอดีตและแบบเรียลไทม์ได้ โดยเฉพาะอย่างยิ่ง หากโมเดล ML ของคุณคาดหวังคุณสมบัติอินพุต เช่น total_number_of_clicks_last_90sec ฟังก์ชันหน้าต่าง Apache Beam สามารถคำนวณคุณสมบัติเหล่านี้โดยอิงตามการรวมค่าของกรอบเวลาของข้อมูลเหตุการณ์แบบเรียลไทม์ (การสตรีม) (เช่น เหตุการณ์การคลิก) ในการอภิปรายก่อนหน้านี้เกี่ยวกับ รายละเอียดของการเปลี่ยนแปลง สิ่งนี้เรียกว่า "การรวมกลุ่มในอดีตระหว่างการฝึกอบรม แต่เป็นการรวมกลุ่มแบบเรียลไทม์ระหว่างการคาดการณ์"

แผนภาพต่อไปนี้ รูปที่ 3 แสดงบทบาทของ Dataflow ในการประมวลผลข้อมูลสตรีมสำหรับการคาดการณ์แบบเรียลไทม์

ดังที่แสดงในรูปที่ 3 ในระหว่างการประมวลผล เหตุการณ์ที่เรียกว่า จุดข้อมูล จะถูกนำเข้าไปยัง Pub/Sub Dataflow ใช้จุดข้อมูลเหล่านี้ คำนวณฟีเจอร์ตามการสรุปรวมในช่วงเวลาหนึ่ง จากนั้นเรียก API โมเดล ML ที่ปรับใช้สำหรับการคาดการณ์ จากนั้นการคาดการณ์จะถูกส่งไปยังคิว Pub/Sub ขาออก จาก Pub/Sub การคาดการณ์สามารถนำมาใช้โดยระบบดาวน์สตรีม เช่น การตรวจสอบหรือการควบคุม หรือสามารถส่งกลับ (เช่น เป็นการแจ้งเตือน) ไปยังไคลเอ็นต์ที่ร้องขอดั้งเดิมได้ การคาดการณ์ยังสามารถจัดเก็บไว้ในที่เก็บข้อมูลที่มีเวลาแฝงต่ำ เช่น Cloud Bigtable เพื่อการดึงข้อมูลแบบเรียลไทม์ Cloud Bigtable ยังสามารถใช้เพื่อสะสมและจัดเก็บการรวมกลุ่มแบบเรียลไทม์เหล่านี้ เพื่อให้สามารถค้นหาได้เมื่อจำเป็นสำหรับการคาดการณ์

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

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

Dataflow สามารถใช้เพื่อทำการแปลงแบบเต็มพาส โดยการคำนวณสถิติที่จำเป็นในวงกว้าง อย่างไรก็ตาม สถิติเหล่านี้จำเป็นต้องจัดเก็บไว้ที่ไหนสักแห่งเพื่อใช้ในระหว่างการทำนายเพื่อแปลงจุดข้อมูลการทำนาย ด้วยการใช้ไลบรารี TensorFlow Transform ( tf.Transform ) คุณสามารถฝังสถิติเหล่านี้ลงในโมเดลได้โดยตรง แทนที่จะเก็บไว้ที่อื่น วิธีการนี้จะอธิบายในภายหลังใน How tf.Transform works

ตัวเลือก C: TensorFlow

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

• การใช้ตรรกะการเปลี่ยนแปลงระดับอินสแตนซ์ทั้งหมดในฟังก์ชัน input_fn และในฟังก์ชัน serving_fn ฟังก์ชัน input_fn เตรียมชุดข้อมูลโดยใช้ tf.data.Dataset API สำหรับการฝึกโมเดล ฟังก์ชัน serving_fn รับและเตรียมข้อมูลสำหรับการคาดการณ์
• วางโค้ดการแปลงโดยตรงในโมเดล TensorFlow ของคุณโดยใช้ เลเยอร์การประมวลผลล่วงหน้าของ Keras หรือ การสร้างเลเยอร์ที่กำหนดเอง

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

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

ความท้าทายในการประมวลผลล่วงหน้า

ต่อไปนี้เป็นความท้าทายหลักของการดำเนินการประมวลผลข้อมูลล่วงหน้า:

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

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

• การแปลงร่างแบบเต็มพาส คุณไม่สามารถใช้การแปลงแบบเต็มพาส เช่น การปรับขนาดและการแปลงมาตรฐานในโมเดล TensorFlow ของคุณ ในการแปลงแบบเต็มพาส สถิติบางอย่าง (เช่น ค่า max และ min เพื่อปรับขนาดคุณลักษณะตัวเลข) จะต้องได้รับการคำนวณจากข้อมูลการฝึกล่วงหน้า ตามที่อธิบายไว้ใน ตัวเลือก B: Dataflow จากนั้นค่าจะต้องถูกเก็บไว้ที่ไหนสักแห่งเพื่อใช้ระหว่างการแสดงโมเดลสำหรับการคาดการณ์เพื่อแปลงจุดข้อมูลดิบใหม่เป็นการแปลงระดับอินสแตนซ์ ซึ่งจะช่วยหลีกเลี่ยงการบิดเบือนการให้บริการการฝึก คุณสามารถใช้ไลบรารี TensorFlow Transform ( tf.Transform ) เพื่อฝังสถิติในโมเดล TensorFlow ของคุณได้โดยตรง วิธีการนี้จะอธิบายในภายหลังใน How tf.Transform works

• การเตรียมข้อมูลล่วงหน้าเพื่อประสิทธิภาพการฝึกอบรมที่ดีขึ้น การใช้การเปลี่ยนแปลงระดับอินสแตนซ์เป็นส่วนหนึ่งของโมเดลอาจทำให้ประสิทธิภาพของกระบวนการฝึกอบรมลดลง ความเสื่อมโทรมนี้เกิดขึ้นเนื่องจากมีการนำการเปลี่ยนแปลงเดียวกันไปใช้ซ้ำๆ กับข้อมูลการฝึกอบรมเดียวกันในแต่ละยุค ลองจินตนาการว่าคุณมีข้อมูลการฝึกอบรมดิบที่มีคุณสมบัติ 1,000 รายการ และคุณใช้การเปลี่ยนแปลงระดับอินสแตนซ์ผสมกันเพื่อสร้างคุณสมบัติ 10,000 รายการ หากคุณใช้การแปลงเหล่านี้เป็นส่วนหนึ่งของโมเดลของคุณ และหากคุณป้อนข้อมูลการฝึกดิบให้กับโมเดล การดำเนินการ 10,000 รายการเหล่านี้จะถูกนำไปใช้ N ครั้งในแต่ละอินสแตนซ์ โดยที่ N คือจำนวนยุค นอกจากนี้ หากคุณใช้ตัวเร่งความเร็ว (GPU หรือ TPU) ตัวเร่งความเร็วเหล่านี้จะไม่ได้ใช้งานในขณะที่ CPU ทำการเปลี่ยนแปลงเหล่านั้น ซึ่งไม่ใช่การใช้ตัวเร่งความเร็วที่มีราคาแพงอย่างมีประสิทธิภาพ

  ตามหลักการแล้ว ข้อมูลการฝึกจะถูกแปลงก่อนการฝึก โดยใช้เทคนิคที่อธิบายไว้ใน ตัวเลือก B: Dataflow โดยที่การดำเนินการแปลง 10,000 รายการจะถูกใช้เพียงครั้งเดียวในแต่ละอินสแตนซ์การฝึก จากนั้นข้อมูลการฝึกที่ได้รับการแปลงจะถูกนำเสนอต่อโมเดล ไม่มีการเปลี่ยนแปลงใดๆ เพิ่มเติม และตัวเร่งความเร็วก็ยุ่งอยู่ตลอดเวลา นอกจากนี้ การใช้ Dataflow ยังช่วยให้คุณประมวลผลข้อมูลจำนวนมากล่วงหน้าในวงกว้าง โดยใช้บริการที่มีการจัดการเต็มรูปแบบ

  การเตรียมข้อมูลการฝึกอบรมล่วงหน้าสามารถปรับปรุงประสิทธิภาพการฝึกอบรมได้ อย่างไรก็ตาม การใช้ตรรกะการเปลี่ยนแปลงภายนอกโมเดล (แนวทางที่อธิบายไว้ใน ตัวเลือก A: BigQuery หรือ ตัวเลือก B: Dataflow ) ไม่สามารถแก้ไขปัญหาการบิดเบือนการให้บริการการฝึกอบรมได้ เว้นแต่คุณจะจัดเก็บคุณลักษณะทางวิศวกรรมไว้ในที่เก็บคุณลักษณะเพื่อใช้สำหรับทั้งการฝึกและการทำนาย ตรรกะการแปลงต้องถูกนำไปใช้ในที่ใดที่หนึ่งเพื่อนำไปใช้กับจุดข้อมูลใหม่ที่จะมาสำหรับการคาดการณ์ เนื่องจากอินเทอร์เฟซของโมเดลคาดว่าจะมีข้อมูลที่แปลงแล้ว ไลบรารี TensorFlow Transform ( tf.Transform ) สามารถช่วยคุณแก้ไขปัญหานี้ได้ ดังที่อธิบายไว้ในส่วนต่อไปนี้

tf.Transform ทำงานอย่างไร

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

แผนภาพต่อไปนี้ รูปที่ 4 แสดงให้เห็นว่าไลบรารี tf.Transform ประมวลผลล่วงหน้าและแปลงข้อมูลสำหรับการฝึกอบรมและการทำนายอย่างไร กระบวนการนี้อธิบายไว้ในส่วนต่อไปนี้

แปลงข้อมูลการฝึกอบรมและการประเมินผล

คุณประมวลผลข้อมูลดิบล่วงหน้าโดยใช้การเปลี่ยนแปลงที่ใช้งานใน tf.Transform Apache Beam API และเรียกใช้ตามขนาดบน Dataflow การประมวลผลล่วงหน้าเกิดขึ้นในขั้นตอนต่อไปนี้:

• ระยะการวิเคราะห์: ในระหว่างระยะการวิเคราะห์ สถิติที่จำเป็น (เช่น ค่าเฉลี่ย ความแปรปรวน และควอนไทล์) สำหรับการแปลงแบบมีสถานะจะถูกคำนวณจากข้อมูลการฝึกด้วยการดำเนินการแบบเต็มพาส ระยะนี้สร้างชุดของสิ่งประดิษฐ์การแปลง รวมถึงกราฟ transform_fn กราฟ transform_fn คือกราฟ TensorFlow ที่มีตรรกะการเปลี่ยนแปลงเป็นการดำเนินการระดับอินสแตนซ์ โดยจะรวมสถิติที่คำนวณในขั้นตอนการวิเคราะห์เป็นค่าคงที่
• ระยะการแปลง: ในระหว่างระยะการแปลง กราฟ transform_fn จะถูกนำไปใช้กับข้อมูลการฝึกดิบ โดยที่สถิติที่คำนวณแล้วจะถูกนำไปใช้ในการประมวลผลบันทึกข้อมูล (เช่น เพื่อปรับขนาดคอลัมน์ตัวเลข) ในรูปแบบระดับอินสแตนซ์

แนวทางแบบสองเฟสเช่นนี้จะจัดการกับ ความท้าทายในการประมวลผลล่วงหน้า ของการแปลงฟูลพาส

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

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

แนบการแปลงกับโมเดลที่ส่งออก

ตามที่ระบุไว้กราฟ transform_fn ที่ผลิตโดยท่อส่ง tf.Transform จะถูกเก็บไว้เป็นกราฟ tensorflow ที่ส่งออก กราฟที่ส่งออกประกอบด้วยตรรกะการแปลงเป็นการดำเนินการระดับอินสแตนซ์และสถิติทั้งหมดที่คำนวณในการแปลงแบบเต็มรูปแบบเป็นค่าคงที่กราฟ เมื่อโมเดลที่ผ่านการฝึกอบรมถูกส่งออกสำหรับการให้บริการกราฟ transform_fn จะถูกแนบกับ SavedModel ซึ่งเป็นส่วนหนึ่งของฟังก์ชั่น serving_fn ของมัน

ในขณะที่มันให้บริการแบบจำลองสำหรับการทำนาย แต่อินเตอร์เฟสการให้บริการแบบจำลองคาดว่าจุดข้อมูลในรูปแบบดิบ (นั่นคือก่อนการแปลงใด ๆ ) อย่างไรก็ตามอินเทอร์เฟซภายในของโมเดลคาดว่าข้อมูลในรูปแบบการแปลง

กราฟ transform_fn ซึ่งตอนนี้เป็นส่วนหนึ่งของโมเดลใช้ตรรกะการประมวลผลล่วงหน้าทั้งหมดบนจุดข้อมูลที่เข้ามา มันใช้ค่าคงที่ที่เก็บไว้ (เช่นμและσเพื่อทำให้คุณสมบัติตัวเลขเป็นปกติ) ในการดำเนินการระดับอินสแตนซ์ระหว่างการทำนาย ดังนั้นกราฟ transform_fn จะแปลงจุดข้อมูลดิบเป็นรูปแบบการแปลง รูปแบบการแปลงเป็นสิ่งที่คาดหวังโดยอินเทอร์เฟซภายในของแบบจำลองเพื่อสร้างการทำนายดังแสดงในรูปที่ 4

กลไกนี้แก้ไข ความท้าทายการประมวลผลล่วงหน้า ของการฝึกอบรมการฝึกอบรมเนื่องจากตรรกะเดียวกัน (การใช้งาน) ที่ใช้ในการแปลงข้อมูลการฝึกอบรมและการประเมินผลจะถูกนำไปใช้เพื่อแปลงจุดข้อมูลใหม่ระหว่างการทำนาย

สรุปตัวเลือกการประมวลผลล่วงหน้า

ตารางต่อไปนี้สรุปตัวเลือกการประมวลผลข้อมูลล่วงหน้าที่เอกสารนี้กล่าวถึง ในตาราง "N/A" หมายถึง "ไม่สามารถใช้ได้"

^* ด้วย tensorflow การแปลงเช่นการข้ามการฝังและการเข้ารหัสหนึ่งร้อนควรดำเนินการอย่างเปิดเผยว่าเป็นคอลัมน์ feature_columns

อะไรต่อไป

• ในการใช้งานท่อส่ง tf.Transform และเรียกใช้โดยใช้ DataFlow อ่านส่วนที่สองของซีรี่ส์นี้ การประมวลผลข้อมูลล่วงหน้าสำหรับ ML โดยใช้ TensorFlow Transform
• ใช้ความเชี่ยวชาญ Coursera บน ML ด้วย TensorFlow บน Google Cloud
• เรียนรู้เกี่ยวกับแนวปฏิบัติที่ดีที่สุดสำหรับวิศวกรรม ML ใน กฎของ ML
• สำหรับสถาปัตยกรรมอ้างอิงเพิ่มเติมไดอะแกรมและแนวทางปฏิบัติที่ดีที่สุดสำรวจ โซลูชั่นคลาวด์ TFX

เอกสารนี้เป็นครั้งแรกในซีรีย์สองส่วนที่สำรวจหัวข้อของวิศวกรรมข้อมูลและวิศวกรรมคุณลักษณะสำหรับการเรียนรู้ของเครื่อง (ML) โดยมุ่งเน้นไปที่งานการเรียนรู้ภายใต้การดูแล ส่วนแรกนี้กล่าวถึงแนวทางปฏิบัติที่ดีที่สุดสำหรับการประมวลผลข้อมูลล่วงหน้าในท่อ ML บน Google Cloud เอกสารมุ่งเน้นไปที่การใช้ TensorFlow และ Open Source TensorFlow Transform ( tf.Transform ) ห้องสมุดเพื่อเตรียมข้อมูลฝึกอบรมแบบจำลองและให้บริการแบบจำลองสำหรับการทำนาย เอกสารนี้เน้นความท้าทายของข้อมูลการประมวลผลล่วงหน้าสำหรับ ML และอธิบายถึงตัวเลือกและสถานการณ์สำหรับการแปลงข้อมูลบน Google Cloud ได้อย่างมีประสิทธิภาพ

เอกสารนี้สันนิษฐานว่าคุณคุ้นเคยกับ BigQuery , DataFlow , Vertex AI และ Tensorflow Keras API

เอกสารที่สอง การประมวลผลข้อมูลล่วงหน้าสำหรับ ML ด้วย Google Cloud ให้การสอนทีละขั้นตอนสำหรับวิธีการใช้งานท่อ tf.Transform

การแนะนำ

ML ช่วยให้คุณค้นหารูปแบบที่ซับซ้อนและมีประโยชน์ในข้อมูลโดยอัตโนมัติ รูปแบบเหล่านี้จะถูกย่อในแบบจำลอง ML ที่สามารถใช้กับจุดข้อมูลใหม่ - กระบวนการที่เรียกว่า การทำนาย หรือ การอนุมาน

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

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

เอกสารนี้กล่าวถึงความท้าทายเหล่านี้สำหรับระดับที่แตกต่างกันของความละเอียดของการดำเนินงานทางวิศวกรรมคุณลักษณะ: การรวมระดับอินสแตนซ์, เต็มรูปแบบและการรวมหน้าต่างเวลา เอกสารนี้ยังอธิบายถึงตัวเลือกและสถานการณ์เพื่อทำการแปลงข้อมูลสำหรับ ML บน Google Cloud

เอกสารนี้ยังให้ภาพรวมของ การแปลง TensorFlow ( tf.Transform ) ซึ่งเป็นไลบรารีสำหรับ tensorflow ที่ให้คุณกำหนดทั้งการแปลงข้อมูลระดับอินสแตนซ์และเต็มรูปแบบผ่านการประมวลผลข้อมูลล่วงหน้า ท่อเหล่านี้ดำเนินการด้วย Apache Beam และพวกเขาสร้างสิ่งประดิษฐ์ที่ให้คุณใช้การแปลงแบบเดียวกันในระหว่างการทำนายเช่นเดียวกับเมื่อมีการเสิร์ฟแบบจำลอง

ข้อมูลการประมวลผลล่วงหน้าสำหรับ ML

ส่วนนี้แนะนำการดำเนินการประมวลผลข้อมูลล่วงหน้าและขั้นตอนของความพร้อมข้อมูล นอกจากนี้ยังกล่าวถึงประเภทของการดำเนินการก่อนการประมวลผลและความละเอียด

วิศวกรรมข้อมูลเมื่อเทียบกับวิศวกรรมคุณลักษณะ

การประมวลผลข้อมูลล่วงหน้าสำหรับ ML เกี่ยวข้องกับทั้งวิศวกรรมข้อมูลและวิศวกรรมคุณลักษณะ วิศวกรรมข้อมูลเป็นกระบวนการแปลง ข้อมูลดิบ เป็น ข้อมูลที่เตรียมไว้ วิศวกรรมคุณลักษณะจากนั้นปรับแต่งข้อมูลที่เตรียมไว้เพื่อสร้างคุณสมบัติที่คาดหวังโดยรุ่น ML ข้อกำหนดเหล่านี้มีความหมายต่อไปนี้:

ข้อมูลดิบ (หรือเพียงแค่ ข้อมูล )

ข้อมูลในรูปแบบต้นทางโดยไม่ต้องเตรียมการก่อนหน้านี้สำหรับ ML ในบริบทนี้ข้อมูลอาจอยู่ในรูปแบบดิบ (ในทะเลสาบข้อมูล) หรือในรูปแบบการแปลง (ในคลังข้อมูล) การแปลงข้อมูลที่อยู่ในคลังข้อมูลอาจถูกแปลงจากรูปแบบดิบดั้งเดิมเพื่อใช้สำหรับการวิเคราะห์ อย่างไรก็ตามในบริบทนี้ ข้อมูลดิบ หมายความว่าข้อมูลยังไม่ได้เตรียมไว้สำหรับงาน ML ของคุณโดยเฉพาะ ข้อมูลก็ถือว่าเป็นข้อมูลดิบหากส่งมาจากระบบสตรีมมิ่งที่เรียกโมเดล ML ในที่สุดสำหรับการคาดการณ์

ข้อมูลที่เตรียมไว้

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

คุณสมบัติทางวิศวกรรม

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

แผนภาพต่อไปนี้รูปที่ 1 แสดงขั้นตอนที่เกี่ยวข้องกับการเตรียมข้อมูลที่ประมวลผลล่วงหน้า:

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

การดำเนินการประมวลผลล่วงหน้า

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

สำหรับข้อมูลที่มีโครงสร้างการดำเนินการประมวลผลข้อมูลล่วงหน้ารวมถึงสิ่งต่อไปนี้:

• การทำความสะอาดข้อมูล: การลบหรือแก้ไขระเบียนที่มีค่าเสียหายหรือไม่ถูกต้องจากข้อมูลดิบและลบระเบียนที่ขาดคอลัมน์จำนวนมาก
• อินสแตนซ์การเลือกและการแบ่งพาร์ติชัน: การเลือกจุดข้อมูลจากชุดข้อมูลอินพุตเพื่อสร้าง การฝึกอบรมการประเมินผล (การตรวจสอบความถูกต้อง) และชุดทดสอบ กระบวนการนี้รวมถึงเทคนิคสำหรับการสุ่มตัวอย่างแบบสุ่มที่ทำซ้ำคลาสชนกลุ่มน้อยการสุ่มตัวอย่างและการแบ่งชั้นแบ่งชั้น
• การปรับแต่งคุณสมบัติ: การปรับปรุงคุณภาพของคุณสมบัติสำหรับ ML ซึ่งรวมถึงการปรับขนาดและการทำให้ค่าตัวเลขเป็นมาตรฐานการเพิ่มค่าที่ขาดหายไปการตัดค่าผิดปกติและการปรับค่าที่มีการแจกแจงแบบเบ้
• การแปลงคุณลักษณะ: การแปลงคุณสมบัติตัวเลขเป็นคุณสมบัติเชิงหมวดหมู่ (ผ่าน การทำให้เป็นที่เก็บเงิน ) และการแปลงคุณสมบัติหมวดหมู่เป็นตัวแทนตัวเลข (ผ่านการเข้ารหัสร้อนหนึ่งครั้ง การเรียนรู้ด้วยการนับ บางรุ่นทำงานได้เฉพาะกับคุณสมบัติเชิงตัวเลขหรือหมวดหมู่ในขณะที่บางรุ่นสามารถจัดการคุณสมบัติแบบผสมได้ แม้ว่ารุ่นที่จัดการทั้งสองประเภทพวกเขาจะได้รับประโยชน์จากการเป็นตัวแทนที่แตกต่างกัน (ตัวเลขและหมวดหมู่) ของคุณลักษณะเดียวกัน
• การแยกฟีเจอร์: การลดจำนวนคุณสมบัติโดยการสร้างมิติที่ต่ำกว่าการแสดงข้อมูลที่ทรงพลังยิ่งขึ้นโดยใช้เทคนิคเช่น PCA , การสกัด แบบฝัง และ การแฮช
• การเลือกคุณลักษณะ: การเลือกชุดย่อยของคุณสมบัติอินพุตสำหรับการฝึกอบรมโมเดลและไม่สนใจสิ่งที่ไม่เกี่ยวข้องหรือซ้ำซ้อนโดยใช้ วิธีการกรองหรือ wrapper การเลือกคุณลักษณะยังสามารถเกี่ยวข้องกับคุณสมบัติการลดลงหากคุณสมบัติหายไปจำนวนมาก
• การก่อสร้างคุณสมบัติ: การสร้างคุณสมบัติใหม่โดยใช้เทคนิคทั่วไปเช่น การขยายพหุนาม (โดยใช้ฟังก์ชั่นทางคณิตศาสตร์แบบ univariate) หรือ การข้ามคุณสมบัติ (เพื่อจับการโต้ตอบคุณสมบัติ) นอกจากนี้ยังสามารถสร้างคุณสมบัติโดยใช้ตรรกะทางธุรกิจจากโดเมนของเคสการใช้ ML

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

• สำหรับเอกสารข้อความ: stemming และ lemmatization , การคำนวณ TF-IDF และการสกัด N-Gram , การค้นหาแบบฝัง
• สำหรับรูปภาพ: การตัดการปรับขนาดการปลูกพืชเบลอเกาส์และตัวกรองนกขมิ้น
• สำหรับข้อมูลทุกประเภท (รวมถึงข้อความและรูปภาพ): การถ่ายโอนการเรียนรู้ ซึ่งถือว่าเลเยอร์ทั้งหมด แต่สุดท้ายของรูปแบบที่ผ่านการฝึกอบรมอย่างเต็มที่เป็นขั้นตอนวิศวกรรมคุณลักษณะ

การประมวลผลล่วงหน้า

ส่วนนี้กล่าวถึงความละเอียดของประเภทของการแปลงข้อมูล มันแสดงให้เห็นว่าทำไมมุมมองนี้จึงมีความสำคัญเมื่อเตรียมจุดข้อมูลใหม่สำหรับการทำนายโดยใช้การแปลงที่ใช้กับข้อมูลการฝึกอบรม

การประมวลผลล่วงหน้าและการเปลี่ยนแปลงสามารถจัดหมวดหมู่ได้ดังนี้ตามการดำเนินการที่ละเอียด:

• การเปลี่ยนแปลงระดับอินสแตนซ์ระหว่างการฝึกอบรมและการทำนาย สิ่งเหล่านี้เป็นการแปลงที่ตรงไปตรงมาซึ่งจำเป็นต้องมีค่าเฉพาะจากอินสแตนซ์เดียวกันสำหรับการแปลง ตัวอย่างเช่นการแปลงระดับอินสแตนซ์อาจรวมถึงการตัดค่าของคุณลักษณะไปยังเกณฑ์บางอย่างการขยายคุณสมบัติอื่น polynomially การคูณสองคุณสมบัติหรือเปรียบเทียบสองคุณสมบัติเพื่อสร้างธงบูลีน

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

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

  ตัวอย่างเช่นในการทำให้คุณลักษณะตัวเลขเป็นปกติสำหรับการฝึกอบรมคุณคำนวณค่าเฉลี่ย (μ) และค่าเบี่ยงเบนมาตรฐาน (σ) ทั่วทั้งข้อมูลการฝึกอบรม การคำนวณนี้เรียกว่าการดำเนินการ เต็มรูปแบบ (หรือ วิเคราะห์ ) เมื่อคุณให้บริการแบบจำลองสำหรับการทำนายค่าของจุดข้อมูลใหม่จะถูกทำให้เป็นมาตรฐานเพื่อหลีกเลี่ยงการฝึกอบรมการให้บริการ ดังนั้นค่าμและσที่คำนวณระหว่างการฝึกอบรมจึงใช้เพื่อปรับค่าคุณสมบัติซึ่งเป็นการดำเนินการ ระดับอินสแตนซ์ ที่ง่ายต่อไปนี้:

  $$ value_{scaled} = (value_{raw} - \mu) \div \sigma $$

  การแปลงเต็มรูปแบบรวมถึงสิ่งต่อไปนี้:

  • Minmax ปรับสเกลคุณสมบัติตัวเลขโดยใช้ MIN และ MAX คำนวณจากชุดข้อมูลการฝึกอบรม
  • การปรับสเกลมาตรฐาน (การทำให้เป็นมาตรฐานคะแนน Z) โดยใช้μและσคำนวณบนชุดข้อมูลการฝึกอบรม
  • การเพิ่มคุณสมบัติเชิงตัวเลขโดยใช้ Quantiles
  • การใส่ค่าที่ขาดหายไปโดยใช้ค่ามัธยฐาน (คุณสมบัติเชิงตัวเลข) หรือโหมด (คุณสมบัติหมวดหมู่)
  • การแปลงสตริง (ค่าเล็กน้อย) เป็นจำนวนเต็ม (ดัชนี) โดยการแยกค่าที่แตกต่างทั้งหมด (คำศัพท์) ของคุณลักษณะหมวดหมู่อินพุต
  • การนับการเกิดขึ้นของคำ (ค่าคุณลักษณะ) ในเอกสารทั้งหมด (อินสแตนซ์) เพื่อคำนวณ TF-IDF
  • การคำนวณ PCA ของคุณสมบัติอินพุตเพื่อฉายข้อมูลลงในพื้นที่มิติที่ต่ำกว่า (พร้อมคุณสมบัติที่ขึ้นกับเชิงเส้น)

  คุณควรใช้เฉพาะข้อมูลการฝึกอบรมเพื่อคำนวณสถิติเช่นμ, σ, min และ Max หากคุณเพิ่มข้อมูลการทดสอบและการประเมินผลสำหรับการดำเนินการเหล่านี้คุณกำลัง รั่วไหลข้อมูล จากข้อมูลการประเมินและทดสอบเพื่อฝึกอบรมแบบจำลอง การทำเช่นนั้นมีผลต่อความน่าเชื่อถือของผลการทดสอบและการประเมินผล เพื่อให้แน่ใจว่าคุณใช้การแปลงที่สอดคล้องกับชุดข้อมูลทั้งหมดคุณใช้สถิติเดียวกับที่คำนวณจากข้อมูลการฝึกอบรมเพื่อแปลงข้อมูลการทดสอบและการประเมินผล

• การรวมทางประวัติศาสตร์ระหว่างการฝึกอบรมและการทำนาย สิ่งนี้เกี่ยวข้องกับการสร้างการรวมธุรกิจการสืบทอดและการตั้งค่าสถานะเป็นสัญญาณอินพุตไปยังงานการทำนาย - ตัวอย่างเช่นการสร้าง ตัวชี้วัดความถี่และตัวชี้วัดทางการเงิน (RFM) สำหรับลูกค้าในการสร้างแบบจำลองความชอบ คุณสมบัติประเภทนี้สามารถคำนวณได้ล่วงหน้าและจัดเก็บไว้ในร้านค้าคุณลักษณะที่จะใช้ในระหว่างการฝึกอบรมแบบจำลองการให้คะแนนแบบแบตช์และการทำนายออนไลน์ นอกจากนี้คุณยังสามารถดำเนินการวิศวกรรมคุณสมบัติเพิ่มเติม (ตัวอย่างเช่นการเปลี่ยนแปลงและการปรับแต่ง) ไปยังการรวมตัวเหล่านี้ก่อนการฝึกอบรมและการทำนาย

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

  แม่นยำยิ่งขึ้นเมื่อคุณเตรียมข้อมูลการฝึกอบรมหากค่ารวมไม่ได้อยู่ในข้อมูลดิบค่าจะถูกสร้างขึ้นในช่วงขั้นตอนวิศวกรรมข้อมูล ข้อมูลดิบมักจะถูกเก็บไว้ในฐานข้อมูลที่มีรูปแบบของ (entity, timestamp, value) ในตัวอย่างก่อน entity เป็นตัวระบุกลุ่มเส้นทางสำหรับเส้นทางแท็กซี่และตัวระบุชิ้นส่วนเครื่องยนต์สำหรับความล้มเหลวของเครื่องยนต์ คุณสามารถใช้การดำเนินการ windowing เพื่อคำนวณ (entity, time_index, aggregated_value_over_time_window) และใช้คุณสมบัติการรวมเป็นอินพุตสำหรับการฝึกอบรมแบบจำลองของคุณ

  เมื่อแบบจำลองสำหรับการทำนายแบบเรียลไทม์ (ออนไลน์) แบบจำลองคาดว่าจะมีคุณสมบัติที่ได้จากค่ารวมเป็นอินพุต ดังนั้นคุณสามารถใช้เทคโนโลยีการประมวลผลสตรีมเช่น Apache Beam เพื่อคำนวณการรวมตัวจากจุดข้อมูลแบบเรียลไทม์ที่สตรีมเข้าสู่ระบบของคุณ เทคโนโลยีการประมวลผลแบบสตรีมรวมข้อมูลเรียลไทม์ตามหน้าต่างเวลาเมื่อจุดข้อมูลใหม่มาถึง นอกจากนี้คุณยังสามารถดำเนินการวิศวกรรมคุณสมบัติเพิ่มเติม (ตัวอย่างเช่นการเปลี่ยนแปลงและการปรับแต่ง) ไปยังการรวมตัวเหล่านี้ก่อนการฝึกอบรมและการทำนาย

ML Pipeline บน Google Cloud

ส่วนนี้กล่าวถึงองค์ประกอบหลักของท่อส่งข้อมูลแบบ end-to-end ทั่วไปเพื่อฝึกอบรมและให้บริการรุ่น Tensorflow ML บน Google Cloud โดยใช้บริการที่มีการจัดการ นอกจากนี้ยังกล่าวถึงตำแหน่งที่คุณสามารถใช้หมวดหมู่ที่แตกต่างกันของการดำเนินการประมวลผลข้อมูลล่วงหน้าและความท้าทายทั่วไปที่คุณอาจเผชิญเมื่อคุณใช้การแปลงดังกล่าว ส่วน งาน TF.Transform แสดงให้เห็นว่าห้องสมุด TensorFlow Transform ช่วยในการจัดการกับความท้าทายเหล่านี้อย่างไร

สถาปัตยกรรมระดับสูง

แผนภาพต่อไปนี้รูปที่ 2 แสดงสถาปัตยกรรมระดับสูงของไปป์ไลน์ ML ทั่วไปสำหรับการฝึกอบรมและการให้บริการรุ่นเทนเซอร์โฟลว์ ป้ายกำกับ A, B และ C ในแผนภาพอ้างถึงสถานที่ต่าง ๆ ในท่อที่สามารถประมวลผลข้อมูลล่วงหน้าได้ รายละเอียดเกี่ยวกับขั้นตอนเหล่านี้มีอยู่ในส่วนต่อไปนี้

ท่อประกอบด้วยขั้นตอนต่อไปนี้:

1. หลังจากนำเข้าข้อมูลดิบข้อมูลตารางจะถูกเก็บไว้ใน BigQuery และข้อมูลอื่น ๆ เช่นรูปภาพเสียงและวิดีโอจะถูกเก็บไว้ในที่เก็บข้อมูลบนคลาวด์ ส่วนที่สองของซีรี่ส์นี้ใช้ข้อมูลแบบตารางที่เก็บไว้ใน BigQuery เป็นตัวอย่าง
2. วิศวกรรมข้อมูล (การเตรียมการ) และวิศวกรรมคุณลักษณะจะดำเนินการในระดับโดยใช้ DataFlow การดำเนินการนี้สร้างการฝึกอบรมการประเมินผลและชุดทดสอบ ML พร้อมที่เก็บไว้ในที่เก็บข้อมูลบนคลาวด์ ตามหลักการแล้วชุดข้อมูลเหล่านี้จะถูกเก็บไว้เป็นไฟล์ TFRECORD ซึ่งเป็นรูปแบบที่ดีที่สุดสำหรับการคำนวณ TensorFlow
3. แพ็คเกจเทนเซอร์เทน เซอร์โมเดลถูกส่งไปยังการฝึกอบรม Vertex AI ซึ่งใช้ข้อมูลที่ประมวลผลล่วงหน้าจากขั้นตอนก่อนหน้าเพื่อฝึกอบรมโมเดล ผลลัพธ์ของขั้นตอนนี้คือ TensorFlow ที่ได้รับการฝึกฝน มาจากโมเดล ที่ส่งออกไปยังที่เก็บข้อมูลบนคลาวด์
4. โมเดล TensorFlow ที่ผ่านการฝึกอบรมจะถูกนำไปใช้กับการทำนาย Vertex AI เป็นบริการที่มี REST API เพื่อให้สามารถใช้สำหรับการคาดการณ์ออนไลน์ รุ่นเดียวกันนี้ยังสามารถใช้สำหรับงานทำนายชุด
5. หลังจากที่โมเดลถูกปรับใช้เป็น REST API แอพไคลเอนต์และระบบภายในสามารถเรียกใช้ API ได้โดยส่งคำขอด้วยจุดข้อมูลบางจุดและรับคำตอบจากแบบจำลองด้วยการคาดการณ์
6. สำหรับการเตรียมการและการทำให้ไปป์ไลน์นี้โดยอัตโนมัติคุณสามารถใช้ Vertex AI Pipelines เป็นตัวกำหนดตารางเวลาเพื่อเรียกใช้การเตรียมข้อมูลการฝึกอบรมแบบจำลองและขั้นตอนการปรับใช้แบบจำลอง

คุณยังสามารถใช้ ร้านค้าคุณสมบัติ Vertex AI เพื่อจัดเก็บคุณสมบัติการป้อนข้อมูลเพื่อทำการคาดการณ์ ตัวอย่างเช่นคุณสามารถสร้างคุณสมบัติทางวิศวกรรมได้จากข้อมูลดิบล่าสุดและจัดเก็บไว้ในร้านค้าคุณสมบัติ Vertex AI แอปไคลเอนต์ดึงคุณสมบัติอินพุตที่ต้องการจากร้านค้าคุณสมบัติ Vertex AI และส่งไปยังโมเดลเพื่อรับการคาดการณ์

สถานที่ทำล่วงหน้า

ในรูปที่ 2 ฉลาก A, B และ C แสดงให้เห็นว่าการดำเนินการประมวลผลข้อมูลล่วงหน้าสามารถเกิดขึ้นได้ใน BigQuery, DataFlow หรือ TensorFlow ส่วนต่อไปนี้อธิบายว่าตัวเลือกเหล่านี้ทำงานอย่างไร

ตัวเลือก A: BigQuery

โดยทั่วไปแล้วลอจิกจะถูกนำไปใช้ใน BigQuery สำหรับการดำเนินการต่อไปนี้:

• การสุ่มตัวอย่าง: สุ่มเลือกชุดย่อยจากข้อมูล
• การกรอง: การลบอินสแตนซ์ที่ไม่เกี่ยวข้องหรือไม่ถูกต้อง
• การแบ่งพาร์ติชัน: การแยกข้อมูลเพื่อสร้างการฝึกอบรมการประเมินผลและชุดทดสอบ

สคริปต์ SQL BigQuery สามารถใช้เป็นแบบสอบถามแหล่งข้อมูลสำหรับการประมวลผลข้อมูลล่วงหน้า DataFlow ซึ่งเป็นขั้นตอนการประมวลผลข้อมูลในรูปที่ 2 ตัวอย่างเช่นหากใช้ระบบในแคนาดาและคลังข้อมูลมีธุรกรรมจากทั่วโลก รับข้อมูลการฝึกอบรมแบบแคนาดาเท่านั้นทำได้ดีที่สุดใน BigQuery วิศวกรรมคุณสมบัติใน BigQuery นั้นง่ายและปรับขนาดได้และรองรับการใช้งานการแปลงคุณสมบัติระดับอินสแตนซ์และการรวมคุณสมบัติทางประวัติศาสตร์

อย่างไรก็ตามเราขอแนะนำให้คุณใช้ BigQuery สำหรับวิศวกรรมคุณลักษณะเฉพาะในกรณีที่คุณใช้โมเดลของคุณสำหรับการทำนายแบทช์ (การให้คะแนน) หรือหากคุณสมบัตินั้นถูกคำนวณล่วงหน้าใน BigQuery แต่เก็บไว้ในร้านขายคุณสมบัติ Vertex AI ที่จะใช้ในระหว่างการทำนายออนไลน์ หากคุณวางแผนที่จะปรับใช้แบบจำลองสำหรับการคาดการณ์ออนไลน์และหากคุณไม่มีคุณสมบัติทางวิศวกรรมในร้านค้าคุณลักษณะออนไลน์คุณต้องทำซ้ำการดำเนินการประมวลผลล่วงหน้า SQL เพื่อแปลงจุดข้อมูลดิบที่ระบบอื่นสร้างขึ้น กล่าวอีกนัยหนึ่งคุณต้องใช้ตรรกะสองครั้ง: ครั้งเดียวใน SQL เพื่อประมวลผลข้อมูลการฝึกอบรมล่วงหน้าใน BigQuery และครั้งที่สองในตรรกะของแอพที่ใช้แบบจำลองเพื่อประมวลผลข้อมูลออนไลน์ล่วงหน้าสำหรับการทำนาย

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

หากคุณใช้แบบจำลองของคุณสำหรับการทำนายแบตช์เท่านั้น (ตัวอย่างเช่นการใช้ การทำนายชุด Vertex AI) และหากข้อมูลการให้คะแนนของคุณมาจาก BigQuery คุณสามารถใช้การดำเนินการล่วงหน้าเหล่านี้ซึ่งเป็นส่วนหนึ่งของสคริปต์ SQL BigQuery ในกรณีนี้คุณสามารถใช้สคริปต์ SQL ที่ประมวลผลล่วงหน้าเดียวกันเพื่อเตรียมข้อมูลการฝึกอบรมและการให้คะแนน

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

ตัวเลือก B: DataFlow

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

DataFlow สามารถทำการแปลงระดับอินสแตนซ์และการแปลงคุณลักษณะการรวมตัวแบบเรียลไทม์และเรียลไทม์ โดยเฉพาะอย่างยิ่งหากรุ่น ML ของคุณคาดหวังว่าคุณลักษณะอินพุตเช่น total_number_of_clicks_last_90sec ฟังก์ชั่น Windowing Apache Beam สามารถคำนวณคุณสมบัติเหล่านี้ได้ตามการรวมค่าของหน้าต่างเวลาของข้อมูลเหตุการณ์แบบเรียลไทม์ (ตัวอย่างเช่นคลิกเหตุการณ์) ในการอภิปรายก่อนหน้านี้เกี่ยวกับ ความละเอียดของการเปลี่ยนแปลง สิ่งนี้เรียกว่า "การรวมทางประวัติศาสตร์ในระหว่างการฝึกอบรม แต่การรวมตัวแบบเรียลไทม์ในระหว่างการทำนาย"

แผนภาพต่อไปนี้รูปที่ 3 แสดงบทบาทของ dataflow ในการประมวลผลข้อมูลสตรีมสำหรับการคาดการณ์แบบเรียลไทม์

ดังที่แสดงในรูปที่ 3 ในระหว่างการประมวลผลเหตุการณ์ที่เรียกว่า จุดข้อมูล จะถูกนำเข้าสู่ Pub/Sub DataFlow ใช้จุดข้อมูลเหล่านี้คำนวณคุณสมบัติตามการรวมเมื่อเวลาผ่านไปจากนั้นเรียกใช้ API ML MODE ที่ปรับใช้สำหรับการคาดการณ์ การคาดการณ์จะถูกส่งไปยังผับ/คิวย่อยขาออก จาก Pub/Sub การคาดการณ์สามารถใช้งานได้โดยระบบดาวน์สตรีมเช่นการตรวจสอบหรือควบคุมหรือสามารถผลักดันกลับ (ตัวอย่างเช่นการแจ้งเตือน) ไปยังไคลเอนต์ที่ร้องขอดั้งเดิม การทำนายยังสามารถเก็บไว้ในที่เก็บข้อมูลที่มีความถี่ต่ำเช่น Cloud BigTable สำหรับการดึงข้อมูลแบบเรียลไทม์ Cloud BigTable ยังสามารถใช้ในการสะสมและจัดเก็บการรวมตัวแบบเรียลไทม์เหล่านี้เพื่อให้สามารถค้นหาได้เมื่อจำเป็นสำหรับการทำนาย

การใช้งานลำแสง Apache เดียวกันสามารถใช้กับข้อมูลการฝึกอบรมแบบแบตช์ที่มาจากที่เก็บข้อมูลออฟไลน์เช่น BigQuery และข้อมูลเรียลไทม์ของสตรีมสำหรับการทำนายออนไลน์

ในสถาปัตยกรรมทั่วไปอื่น ๆ เช่นสถาปัตยกรรมที่แสดงในรูปที่ 2 แอปไคลเอนต์เรียก API โมเดลที่ปรับใช้โดยตรงสำหรับการคาดการณ์ออนไลน์ ในกรณีดังกล่าวหากการดำเนินการประมวลผลล่วงหน้าถูกนำไปใช้ใน DataFlow เพื่อเตรียมข้อมูลการฝึกอบรมการดำเนินการจะไม่ถูกนำไปใช้กับข้อมูลการทำนายที่ไปยังโมเดลโดยตรง ดังนั้นการเปลี่ยนแปลงเช่นนี้ควรรวมอยู่ในแบบจำลองระหว่างการทำนายการคาดการณ์ออนไลน์

DataFlow สามารถใช้เพื่อทำการแปลงเต็มรูปแบบผ่านการคำนวณสถิติที่ต้องการในระดับ อย่างไรก็ตามสถิติเหล่านี้จำเป็นต้องจัดเก็บไว้ที่ไหนสักแห่งที่จะใช้ในระหว่างการทำนายเพื่อแปลงจุดข้อมูลการทำนาย ด้วยการใช้ไลบรารี TensorFlow Transform ( tf.Transform ) คุณสามารถฝังสถิติเหล่านี้โดยตรงในแบบจำลองแทนที่จะจัดเก็บไว้ที่อื่น วิธีการนี้มีการอธิบายในภายหลังว่า TF.Transform ทำงานอย่างไร

ตัวเลือก C: tensorflow

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

• การใช้ตรรกะการแปลงระดับอินสแตนซ์ทั้งหมดในฟังก์ชั่น input_fn และในฟังก์ชัน serving_fn ฟังก์ชั่น input_fn เตรียมชุดข้อมูลโดยใช้ tf.data.Dataset API สำหรับการฝึกอบรมแบบจำลอง ฟังก์ชั่นการ serving_fn ได้รับและเตรียมข้อมูลสำหรับการทำนาย
• การวางรหัสการแปลงโดยตรงในโมเดล tensorflow ของคุณโดยใช้ เลเยอร์การประมวลผลล่วงหน้าของ Keras หรือ สร้างเลเยอร์ที่กำหนดเอง

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

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

ความท้าทายในการประมวลผลล่วงหน้า

ต่อไปนี้เป็นความท้าทายหลักของการใช้งานการประมวลผลข้อมูลล่วงหน้า:

• การฝึกอบรมการเสิร์ฟ การฝึกอบรมการเสแสร้ง หมายถึงความแตกต่างระหว่างประสิทธิภาพ (ประสิทธิภาพการทำนาย) ระหว่างการฝึกอบรมและระหว่างการให้บริการ ความเบ้นี้อาจเกิดจากความแตกต่างระหว่างวิธีที่คุณจัดการข้อมูลในการฝึกอบรมและท่อที่ให้บริการ ตัวอย่างเช่นหากโมเดลของคุณได้รับการฝึกฝนเกี่ยวกับคุณสมบัติการแปลงลอกเลียนแบบลอการิทึม แต่นำเสนอด้วยคุณสมบัติดิบระหว่างการให้บริการเอาต์พุตการทำนายอาจไม่ถูกต้อง

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

• การเปลี่ยนแปลงแบบเต็มผ่าน You can't implement full-pass transformations such as scaling and normalization transformations in your TensorFlow model. In full-pass transformations, some statistics (for example, max and min values to scale numeric features) must be computed on the training data beforehand, as described in Option B: Dataflow . The values then have to be stored somewhere to be used during model serving for prediction to transform the new raw data points as instance-level transformations, which avoids training-serving skew. You can use the TensorFlow Transform ( tf.Transform ) library to directly embed the statistics in your TensorFlow model. This approach is explained later in How tf.Transform works .

• Preparing the data up front for better training efficiency . Implementing instance-level transformations as part of the model can degrade the efficiency of the training process. This degradation occurs because the same transformations are repeatedly applied to the same training data on each epoch. Imagine that you have raw training data with 1,000 features, and you apply a mix of instance-level transformations to generate 10,000 features. If you implement these transformations as part of your model, and if you then feed the model the raw training data, these 10,000 operations are applied N times on each instance, where N is the number of epochs. In addition, if you're using accelerators (GPUs or TPUs), they sit idle while the CPU performs those transformations, which isn't an efficient use of your costly accelerators.

  Ideally, the training data is transformed before training, using the technique described under Option B: Dataflow , where the 10,000 transformation operations are applied only once on each training instance. The transformed training data is then presented to the model. No further transformations are applied, and the accelerators are busy all of the time. In addition, using Dataflow helps you to preprocess large amounts of data at scale, using a fully managed service.

  Preparing the training data up front can improve training efficiency. However, implementing the transformation logic outside of the model (the approaches described in Option A: BigQuery or Option B: Dataflow ) doesn't resolve the issue of training-serving skew. Unless you store the engineered feature in the feature store to be used for both training and prediction, the transformation logic must be implemented somewhere to be applied on new data points coming for prediction, because the model interface expects transformed data. The TensorFlow Transform ( tf.Transform ) library can help you to address this issue, as described in the following section.

How tf.Transform works

The tf.Transform library is useful for transformations that require a full pass. The output of the tf.Transform library is exported as a TensorFlow graph that represents the instance-level transformation logic and the statistics computed from full-pass transformations, to be used for training and serving. Using the same graph for both training and serving can prevent skew, because the same transformations are applied in both stages. In addition, the tf.Transform library can run at scale in a batch processing pipeline on Dataflow to prepare the training data up front and improve training efficiency.

The following diagram, figure 4, shows how the tf.Transform library preprocesses and transforms data for training and prediction. The process is described in the following sections.

Transform training and evaluation data

You preprocess the raw training data using the transformation implemented in the tf.Transform Apache Beam APIs, and run it at scale on Dataflow. The preprocessing occurs in the following phases:

• Analyze phase: During the analyze phase, the required statistics (like means, variances, and quantiles) for stateful transformations are computed on the training data with full-pass operations. This phase produces a set of transformation artifacts, including the transform_fn graph. The transform_fn graph is a TensorFlow graph that has the transformation logic as instance-level operations. It includes the statistics computed in the analyze phase as constants.
• Transform phase: During the transform phase, the transform_fn graph is applied to the raw training data, where the computed statistics are used to process the data records (for example, to scale numerical columns) in an instance-level fashion.

A two-phase approach like this addresses the preprocessing challenge of performing full-pass transformations.

When the evaluation data is preprocessed, only instance-level operations are applied, using the logic in the transform_fn graph and the statistics computed from the analyze phase in the training data. In other words, you don't analyze the evaluation data in a full-pass fashion to compute new statistics, such as μ and σ, to normalize numeric features in evaluation data. Instead, you use the computed statistics from the training data to transform the evaluation data in an instance-level fashion.

The transformed training and evaluation data are prepared at scale using Dataflow, before they are used to train the model. This batch data-preparation process addresses the preprocessing challenge of preparing the data up front to improve training efficiency. As shown in figure 4, the model internal interface expects transformed features.

Attach transformations to the exported model

As noted, the transform_fn graph that's produced by the tf.Transform pipeline is stored as an exported TensorFlow graph. The exported graph consists of the transformation logic as instance-level operations, and all of the statistics computed in the full-pass transformations as graph constants. When the trained model is exported for serving, the transform_fn graph is attached to the SavedModel as part of its serving_fn function.

While it's serving the model for prediction, the model serving interface expects data points in the raw format (that is, before any transformations). However, the model internal interface expects the data in the transformed format.

The transform_fn graph, which is now part of the model, applies all the preprocessing logic on the incoming data point. It uses the stored constants (like μ and σ to normalize the numeric features) in the instance-level operation during prediction. Therefore, the transform_fn graph converts the raw data point into the transformed format. The transformed format is what is expected by the model internal interface in order to produce prediction, as shown in figure 4.

This mechanism resolves the preprocessing challenge of the training-serving skew, because the same logic (implementation) that is used to transform the training and evaluation data is applied to transform the new data points during prediction serving.

Preprocessing options summary

The following table summarizes the data preprocessing options that this document discussed. In the table, "N/A" stands for "not applicable."

^* With TensorFlow, transformations like crossing, embedding, and one-hot encoding should be performed declaratively as feature_columns columns.

What's next

• To implement a tf.Transform pipeline and run it using Dataflow, read part two of this series, Data preprocessing for ML using TensorFlow Transform .
• Take the Coursera specialization on ML with TensorFlow on Google Cloud .
• Learn about best practices for ML engineering in Rules of ML .
• For more reference architectures, diagrams, and best practices, explore the TFX Cloud Solutions .

This document is the first in a two-part series that explores the topic of data engineering and feature engineering for machine learning (ML), with a focus on supervised learning tasks. This first part discusses the best practices for preprocessing data in an ML pipeline on Google Cloud. The document focuses on using TensorFlow and the open source TensorFlow Transform ( tf.Transform ) library to prepare data, train the model, and serve the model for prediction. This document highlights the challenges of preprocessing data for ML, and it describes the options and scenarios for performing data transformation on Google Cloud effectively.

This document assumes that you're familiar with BigQuery , Dataflow , Vertex AI , and the TensorFlow Keras API.

The second document, Data preprocessing for ML with Google Cloud , provides a step-by-step tutorial for how to implement a tf.Transform pipeline.

การแนะนำ

ML helps you automatically find complex and potentially useful patterns in data. These patterns are condensed in an ML model that can then be used on new data points—a process called making predictions or performing inference .

Building an ML model is a multistep process. Each step presents its own technical and conceptual challenges. This two-part series focuses on supervised learning tasks and the process of selecting, transforming, and augmenting the source data to create powerful predictive signals to the target variable. These operations combine domain knowledge with data science techniques. The operations are the essence of feature engineering .

The size of training datasets for real-world ML models can easily be equal to or greater than one terabyte (TB). Therefore, you need large-scale data processing frameworks in order to process these datasets efficiently and distributedly. When you use an ML model to make predictions, you have to apply the same transformations that you used for the training data on the new data points. By applying the same transformations, you present the live dataset to the ML model the way that the model expects.

This document discusses these challenges for different levels of granularity of feature engineering operations: instance-level, full-pass, and time-window aggregations. This document also describes the options and scenarios to perform data transformation for ML on Google Cloud.

This document also provides an overview of TensorFlow Transform ( tf.Transform ), a library for TensorFlow that lets you define both instance-level and full-pass data transformation through data preprocessing pipelines. These pipelines are executed with Apache Beam , and they create artifacts that let you apply the same transformations during prediction as when the model is served.

Preprocessing data for ML

This section introduces data preprocessing operations and stages of data readiness. It also discusses the types of the preprocessing operations and their granularity.

Data engineering compared to feature engineering

Preprocessing the data for ML involves both data engineering and feature engineering. Data engineering is the process of converting raw data into prepared data . Feature engineering then tunes the prepared data to create the features that are expected by the ML model. These terms have the following meanings:

Raw data (or just data )

The data in its source form, without any prior preparation for ML. In this context, the data might be in its raw form (in a data lake) or in a transformed form (in a data warehouse). Transformed data that's in a data warehouse might have been converted from its original raw form to be used for analytics. However, in this context, raw data means that the data hasn't been prepared specifically for your ML task. Data is also considered raw data if it's sent from streaming systems that eventually call ML models for predictions.

Prepared data

The dataset in the form ready for your ML task: data sources have been parsed, joined, and put into a tabular form. Prepared data is aggregated and summarized to the right granularity—for example, each row in the dataset represents a unique customer, and each column represents summary information for the customer, like the total spent in the last six weeks. In a prepared data table, irrelevant columns have been dropped, and invalid records have been filtered out. For supervised learning tasks, the target feature is present.

Engineered features

The dataset with the tuned features that are expected by the model—that is, features that are created by performing certain ML-specific operations on the columns in the prepared dataset, and creating new features for your model during training and prediction, as described later in Preprocessing operations . Examples of these operations include scaling numerical columns to a value between 0 and 1, clipping values, and one-hot-encoding categorical features.

The following diagram, figure 1, shows the steps that are involved in preparing preprocessed data:

In practice, data from the same source is often at different stages of readiness. For example, a field from a table in your data warehouse might be used directly as an engineered feature. At the same time, another field in the same table might need to go through transformations before it becomes an engineered feature. Similarly, data engineering and feature engineering operations might be combined in the same data preprocessing step.

Preprocessing operations

Data preprocessing includes several operations. Each operation is designed to help ML build better predictive models. The details of these preprocessing operations are outside the scope of this document, but some operations are briefly described in this section.

For structured data, data preprocessing operations include the following:

• Data cleansing: removing or correcting records that have corrupted or invalid values from raw data, and removing records that are missing a large number of columns.
• Instances selection and partitioning: selecting data points from the input dataset to create training, evaluation (validation), and test sets . This process includes techniques for repeatable random sampling, minority classes oversampling, and stratified partitioning.
• Feature tuning: improving the quality of a feature for ML, which includes scaling and normalizing numeric values, imputing missing values, clipping outliers, and adjusting values that have skewed distributions.
• Feature transformation: converting a numeric feature to a categorical feature (through bucketization ), and converting categorical features to a numeric representation (through one-hot encoding, learning with counts , sparse feature embeddings, etc.). Some models work only with numeric or categorical features, while others can handle mixed type features. Even when models handle both types, they can benefit from different representations (numeric and categorical) of the same feature.
• Feature extraction: reducing the number of features by creating lower-dimension, more powerful data representations using techniques such as PCA , embedding extraction, and hashing .
• Feature selection: selecting a subset of the input features for training the model, and ignoring the irrelevant or redundant ones, using filter or wrapper methods . Feature selection can also involve simply dropping features if the features are missing a large number of values.
• Feature construction: creating new features by using typical techniques, such as polynomial expansion (by using univariate mathematical functions) or feature crossing (to capture feature interactions). Features can also be constructed by using business logic from the domain of the ML use case.

When you work with unstructured data (for example, images, audio, or text documents), deep learning replaces domain-knowledge-based feature engineering by folding it into the model architecture. A convolutional layer is an automatic feature preprocessor. Constructing the right model architecture requires some empirical knowledge of the data. In addition, some amount of preprocessing is needed, such as the following:

• For text documents: stemming and lemmatization , TF-IDF calculation, and n-gram extraction, embedding lookup.
• For images: clipping, resizing, cropping, Gaussian blur, and canary filters.
• For all types of data (including text and images): transfer learning , which treats all-but-last layers of the fully trained model as a feature engineering step.

Preprocessing granularity

This section discusses the granularity of types of data transformations. It shows why this perspective is critical when preparing new data points for predictions using transformations that are applied on training data.

Preprocessing and transformation operations can be categorized as follows, based on operation granularity:

• Instance-level transformations during training and prediction . These are straightforward transformations, where only values from the same instance are needed for the transformation. For example, instance-level transformations might include clipping the value of a feature to some threshold, polynomially expanding another feature, multiplying two features, or comparing two features to create a Boolean flag.

  These transformations must be applied identically during training and prediction, because the model will be trained on the transformed features, not on the raw input values. If the data isn't transformed identically, then the model behaves poorly because it is presented with data that has a distribution of values that it wasn't trained with. For more information, see the discussion of training-serving skew in the Preprocessing challenges section.

• Full-pass transformations during training, but instance-level transformations during prediction . In this scenario, transformations are stateful, because they use some precomputed statistics to perform the transformation. During training, you analyze the whole body of training data to compute quantities such as minimum, maximum, mean, and variance for transforming training data, evaluation data, and new data at prediction time.

  For example, to normalize a numeric feature for training, you compute its mean (μ) and its standard deviation (σ) across the whole of the training data. This computation is called a full-pass (or analyze ) operation. When you serve the model for prediction, the value of a new data point is normalized to avoid training-serving skew. Therefore, μ and σ values that are computed during training are used to adjust the feature value, which is the following simple instance-level operation:

  $$ value_{scaled} = (value_{raw} - \mu) \div \sigma $$

  Full-pass transformations include the following:

  • MinMax scaling numerical features using min and max computed from the training dataset.
  • Standard scaling (z-score normalization) numerical features using μ and σ computed on the training dataset.
  • Bucketizing numerical features using quantiles.
  • Imputing missing values using the median (numerical features) or the mode (categorical features).
  • Converting strings (nominal values) to integers (indexes) by extracting all the distinct values (vocabulary) of an input categorical feature.
  • Counting the occurrence of a term (feature value) in all the documents (instances) to calculate for TF-IDF.
  • Computing the PCA of the input features to project the data into a lower dimensional space (with linearly dependent features).

  You should use only the training data to compute statistics like μ, σ, min , and max . If you add the test and evaluation data for these operations, you are leaking information from the evaluation and test data to train the model. Doing so affects the reliability of the test and evaluation results. To ensure that you apply a consistent transformation to all datasets, you use the same statistics computed from the training data to transform the test and evaluation data.

• Historical aggregations during training and prediction . This involves creating business aggregations, derivations, and flags as input signals to the prediction task—for example, creating recency, frequency, and monetary (RFM) metrics for customers to build propensity models. These types of features can be precomputed and stored in a feature store to be used during model training, batch scoring, and online prediction serving. You can also perform additional feature engineering (for example, transformation and tuning) to these aggregations before training and prediction.

• Historical aggregations during training, but real-time aggregations during prediction . This approach involves creating a feature by summarizing real-time values over time. In this approach, the instances to be aggregated are defined through temporal window clauses. For example, you can use this approach if you want to train a model that estimates the taxi trip time based on the traffic metrics for the route in the last 5 minutes, in the last 10 minutes, in the last 30 minutes, and at other intervals. You can also use this approach to predict the failure of an engine part based on the moving average of temperature and vibration values computed over the last 3 minutes. Although these aggregations can be prepared offline for training, they are computed in real time from a data stream during serving.

  More precisely, when you prepare training data, if the aggregated value isn't in the raw data, the value is created during the data engineering phase. The raw data is usually stored in a database with a format of (entity, timestamp, value) . In the previous examples, entity is the route segment identifier for the taxi routes and the engine part identifier for the engine failure. You can use windowing operations to compute (entity, time_index, aggregated_value_over_time_window) and use the aggregation features as an input for your model training.

  When the model for real-time (online) prediction is served, the model expects features derived from the aggregated values as an input. Therefore, you can use a stream-processing technology like Apache Beam to compute the aggregations from the real-time data points streamed into your system. Stream-processing technology aggregates real-time data based on time windows as new data points arrive. You can also perform additional feature engineering (for example, transformation and tuning) to these aggregations before training and prediction.

ML pipeline on Google Cloud

This section discusses the core components of a typical end-to-end pipeline to train and serve TensorFlow ML models on Google Cloud using managed services. It also discusses where you can implement different categories of the data preprocessing operations, and common challenges that you might face when you implement such transformations. The How tf.Transform works section shows how the TensorFlow Transform library helps to address these challenges.

High-level architecture

The following diagram, figure 2, shows a high-level architecture of a typical ML pipeline for training and serving TensorFlow models. The labels A, B, and C in the diagram refer to the different places in the pipeline where data preprocessing can take place. Details about these steps are provided in the following section.

The pipeline consists of the following steps:

1. After raw data is imported, tabular data is stored in BigQuery, and other data like images, audio, and video, is stored in Cloud Storage. The second part of this series uses tabular data stored in BigQuery as an example.
2. Data engineering (preparation) and feature engineering are executed at scale using Dataflow. This execution produces ML-ready training, evaluation, and test sets that are stored in Cloud Storage. Ideally, these datasets are stored as TFRecord files, which is the optimized format for TensorFlow computations.
3. A TensorFlow model trainer package is submitted to Vertex AI Training, which uses the preprocessed data from the previous steps to train the model. The output of this step is a trained TensorFlow SavedModel that is exported to Cloud Storage.
4. The trained TensorFlow model is deployed to Vertex AI Prediction as a service that has a REST API so that it can be used for online predictions. The same model can also be used for batch prediction jobs.
5. After the model is deployed as a REST API, client apps and internal systems can invoke the API by sending requests with some data points, and receiving responses from the model with predictions.
6. For orchestrating and automating this pipeline, you can use Vertex AI Pipelines as a scheduler to invoke the data preparation, model training, and model deployment steps.

You can also use Vertex AI Feature Store to store input features to make predictions. For example, you can periodically create engineered features from the latest raw data and store them in Vertex AI Feature Store. Client apps fetch the required input features from Vertex AI Feature Store and send them to the model to receive predictions.

Where to do preprocessing

In figure 2, the labels A, B, and C show that data preprocessing operations can take place in BigQuery, Dataflow, or TensorFlow. The following sections describe how each of these options work.

Option A: BigQuery

Typically, logic is implemented in BigQuery for the following operations:

• Sampling: randomly selecting a subset from the data.
• Filtering: removing irrelevant or invalid instances.
• Partitioning: splitting the data to produce training, evaluation, and test sets.

BigQuery SQL scripts can be used as a source query for the Dataflow preprocessing pipeline, which is the data processing step in figure 2. For example, if a system is used in Canada, and the data warehouse has transactions from around the world, filtering to get Canada-only training data is best done in BigQuery. Feature engineering in BigQuery is simple and scalable, and supports implementing instance-level and historical aggregations feature transformations.

However, we recommend that you use BigQuery for feature engineering only if you use your model for batch prediction (scoring), or if the features are precomputed in BigQuery, but stored in Vertex AI Feature Store to be used during online prediction. If you plan to deploy the model for online predictions, and if you don't have the engineered feature in an online feature store, you have to replicate the SQL preprocessing operations to transform the raw data points that other systems generate. In other words, you need to implement the logic twice: one time in SQL to preprocess training data in BigQuery, and a second time in the logic of the app that consumes the model to preprocess online data points for prediction.

For example, if your client app is written in Java, you need to reimplement the logic in Java. This can introduce errors due to implementation discrepancies, as described in the training-serving skew section of Preprocessing challenges later in this document. It's also extra overhead to maintain two different implementations. Whenever you change the logic in SQL to preprocess the training data, you need to change the Java implementation accordingly to preprocess data at serving time.

If you are using your model only for batch prediction (for example, using Vertex AI batch prediction ), and if your data for scoring is sourced from BigQuery, you can implement these preprocessing operations as part of the BigQuery SQL script. In that case, you can use the same preprocessing SQL script to prepare both training and scoring data.

Full-pass stateful transformations aren't suitable for implementation in BigQuery. If you use BigQuery for full-pass transformations, you need auxiliary tables to store quantities needed by stateful transformations, such as means and variances to scale numerical features. Further, implementation of full-pass transformations using SQL on BigQuery creates increased complexity in the SQL scripts, and creates intricate dependency between training and the scoring SQL scripts.

Option B: Dataflow

As shown in figure 2, you can implement computationally expensive preprocessing operations in Apache Beam, and run them at scale using Dataflow. Dataflow is a fully managed autoscaling service for batch and stream data processing. When you use Dataflow, you can also use external specialized libraries for data processing, unlike BigQuery.

Dataflow can perform instance-level transformations, and historical and real-time aggregation feature transformations. In particular, if your ML models expect an input feature like total_number_of_clicks_last_90sec , Apache Beam windowing functions can compute these features based on aggregating the values of time windows of real-time (streaming) events data (for example, click events). In the earlier discussion of granularity of transformations , this was referred to as "Historical aggregations during training, but real-time aggregations during prediction."

The following diagram, figure 3, shows the role of Dataflow in processing stream data for near real-time predictions.

As shown in figure 3, during processing, events called data points are ingested into Pub/Sub . Dataflow consumes these data points, computes features based on aggregates over time, and then calls the deployed ML model API for predictions. Predictions are then sent to an outbound Pub/Sub queue. From Pub/Sub, predictions can be consumed by downstream systems like monitoring or control, or they can be pushed back (for example, as notifications) to the original requesting client. Predictions can also be stored in a low-latency data store like Cloud Bigtable for real-time fetching. Cloud Bigtable can also be used to accumulate and store these real-time aggregations so they can be looked up when needed for prediction.

The same Apache Beam implementation can be used to batch-process training data that comes from an offline datastore like BigQuery and stream-process real-time data for serving online predictions.

In other typical architectures, such as the architecture shown in figure 2, the client app directly calls the deployed model API for online predictions. In that case, if preprocessing operations are implemented in Dataflow to prepare the training data, the operations aren't applied to the prediction data that goes directly to the model. Therefore, transformations like these should be integrated in the model during serving for online predictions.

Dataflow can be used to perform full-pass transformation, by computing the required statistics at scale. However, these statistics need to be stored somewhere to be used during prediction to transform prediction data points. By using the TensorFlow Transform ( tf.Transform ) library, you can directly embed these statistics in the model instead of storing them elsewhere. This approach is explained later in How tf.Transform works .

Option C: TensorFlow

As shown in figure 2, you can implement data preprocessing and transformation operations in the TensorFlow model itself. As shown in the figure, the preprocessing that you implement for training the TensorFlow model becomes an integral part of the model when the model is exported and deployed for predictions. Transformations in the TensorFlow model can be accomplished in one of the following ways:

• Implementing all of the instance-level transformation logic in the input_fn function and in the serving_fn function. The input_fn function prepares a dataset using the tf.data.Dataset API for training a model. The serving_fn function receives and prepares the data for predictions.
• Putting the transformation code directly in your TensorFlow model by using Keras preprocessing layers or creating custom layers .

The transformation logic code in the serving_fn function defines the serving interface of your SavedModel for online prediction. If you implement the same transformations that were used for preparing training data in the transformation logic code of the serving_fn function, it ensures that the same transformations are applied to new prediction data points when they're served.

However, because the TensorFlow model processes each data point independently or in a small batch, you can't calculate aggregations from all data points. As a result, full-pass transformations can't be implemented in your TensorFlow model.

Preprocessing challenges

The following are the primary challenges of implementing data preprocessing:

• Training-serving skew . Training-serving skew refers to a difference between effectiveness (predictive performance) during training and during serving. This skew can be caused by a discrepancy between how you handle data in the training and the serving pipelines. For example, if your model is trained on a logarithmically transformed feature, but it's presented with the raw feature during serving, the prediction output might not be accurate.

  If the transformations become part of the model itself, it can be straightforward to handle instance-level transformations, as described earlier in Option C: TensorFlow . In that case, the model serving interface (the serving_fn function) expects raw data, while the model internally transforms this data before computing the output. The transformations are the same as those that were applied on the raw training and prediction data points.

• Full-pass transformations . You can't implement full-pass transformations such as scaling and normalization transformations in your TensorFlow model. In full-pass transformations, some statistics (for example, max and min values to scale numeric features) must be computed on the training data beforehand, as described in Option B: Dataflow . The values then have to be stored somewhere to be used during model serving for prediction to transform the new raw data points as instance-level transformations, which avoids training-serving skew. You can use the TensorFlow Transform ( tf.Transform ) library to directly embed the statistics in your TensorFlow model. This approach is explained later in How tf.Transform works .

• Preparing the data up front for better training efficiency . Implementing instance-level transformations as part of the model can degrade the efficiency of the training process. This degradation occurs because the same transformations are repeatedly applied to the same training data on each epoch. Imagine that you have raw training data with 1,000 features, and you apply a mix of instance-level transformations to generate 10,000 features. If you implement these transformations as part of your model, and if you then feed the model the raw training data, these 10,000 operations are applied N times on each instance, where N is the number of epochs. In addition, if you're using accelerators (GPUs or TPUs), they sit idle while the CPU performs those transformations, which isn't an efficient use of your costly accelerators.

  Ideally, the training data is transformed before training, using the technique described under Option B: Dataflow , where the 10,000 transformation operations are applied only once on each training instance. The transformed training data is then presented to the model. No further transformations are applied, and the accelerators are busy all of the time. In addition, using Dataflow helps you to preprocess large amounts of data at scale, using a fully managed service.

  Preparing the training data up front can improve training efficiency. However, implementing the transformation logic outside of the model (the approaches described in Option A: BigQuery or Option B: Dataflow ) doesn't resolve the issue of training-serving skew. Unless you store the engineered feature in the feature store to be used for both training and prediction, the transformation logic must be implemented somewhere to be applied on new data points coming for prediction, because the model interface expects transformed data. The TensorFlow Transform ( tf.Transform ) library can help you to address this issue, as described in the following section.

How tf.Transform works

The tf.Transform library is useful for transformations that require a full pass. The output of the tf.Transform library is exported as a TensorFlow graph that represents the instance-level transformation logic and the statistics computed from full-pass transformations, to be used for training and serving. Using the same graph for both training and serving can prevent skew, because the same transformations are applied in both stages. In addition, the tf.Transform library can run at scale in a batch processing pipeline on Dataflow to prepare the training data up front and improve training efficiency.

The following diagram, figure 4, shows how the tf.Transform library preprocesses and transforms data for training and prediction. The process is described in the following sections.

Transform training and evaluation data

You preprocess the raw training data using the transformation implemented in the tf.Transform Apache Beam APIs, and run it at scale on Dataflow. The preprocessing occurs in the following phases:

• Analyze phase: During the analyze phase, the required statistics (like means, variances, and quantiles) for stateful transformations are computed on the training data with full-pass operations. This phase produces a set of transformation artifacts, including the transform_fn graph. The transform_fn graph is a TensorFlow graph that has the transformation logic as instance-level operations. It includes the statistics computed in the analyze phase as constants.
• Transform phase: During the transform phase, the transform_fn graph is applied to the raw training data, where the computed statistics are used to process the data records (for example, to scale numerical columns) in an instance-level fashion.

A two-phase approach like this addresses the preprocessing challenge of performing full-pass transformations.

When the evaluation data is preprocessed, only instance-level operations are applied, using the logic in the transform_fn graph and the statistics computed from the analyze phase in the training data. In other words, you don't analyze the evaluation data in a full-pass fashion to compute new statistics, such as μ and σ, to normalize numeric features in evaluation data. Instead, you use the computed statistics from the training data to transform the evaluation data in an instance-level fashion.

The transformed training and evaluation data are prepared at scale using Dataflow, before they are used to train the model. This batch data-preparation process addresses the preprocessing challenge of preparing the data up front to improve training efficiency. As shown in figure 4, the model internal interface expects transformed features.

Attach transformations to the exported model

As noted, the transform_fn graph that's produced by the tf.Transform pipeline is stored as an exported TensorFlow graph. The exported graph consists of the transformation logic as instance-level operations, and all of the statistics computed in the full-pass transformations as graph constants. When the trained model is exported for serving, the transform_fn graph is attached to the SavedModel as part of its serving_fn function.

While it's serving the model for prediction, the model serving interface expects data points in the raw format (that is, before any transformations). However, the model internal interface expects the data in the transformed format.

The transform_fn graph, which is now part of the model, applies all the preprocessing logic on the incoming data point. It uses the stored constants (like μ and σ to normalize the numeric features) in the instance-level operation during prediction. Therefore, the transform_fn graph converts the raw data point into the transformed format. The transformed format is what is expected by the model internal interface in order to produce prediction, as shown in figure 4.

This mechanism resolves the preprocessing challenge of the training-serving skew, because the same logic (implementation) that is used to transform the training and evaluation data is applied to transform the new data points during prediction serving.

Preprocessing options summary

The following table summarizes the data preprocessing options that this document discussed. In the table, "N/A" stands for "not applicable."

^* With TensorFlow, transformations like crossing, embedding, and one-hot encoding should be performed declaratively as feature_columns columns.

What's next

• To implement a tf.Transform pipeline and run it using Dataflow, read part two of this series, Data preprocessing for ML using TensorFlow Transform .
• Take the Coursera specialization on ML with TensorFlow on Google Cloud .
• Learn about best practices for ML engineering in Rules of ML .
• For more reference architectures, diagrams, and best practices, explore the TFX Cloud Solutions .