ดาวน์โหลด chronon - ดาวน์โหลดซอร์สโค้ด chronon

chronon : แพลตฟอร์มข้อมูลสำหรับ AI/ML

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

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

ข้อมูลเพิ่มเติมเกี่ยวกับ chronon สามารถพบได้ที่ chronon .ai

คุณสมบัติของแพลตฟอร์ม

การให้บริการออนไลน์

chronon เสนอ API สำหรับการดึงข้อมูลแบบเรียลไทม์ซึ่งส่งคืนค่าล่าสุดสำหรับคุณสมบัติของคุณ รองรับ:

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

โฆษณาทดแทน

ผู้ปฏิบัติงาน ML มักต้องการมุมมองในอดีตของค่าคุณลักษณะสำหรับการฝึกโมเดลและการประเมินผล โฆษณาทดแทนของ chronon คือ:

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

ความสามารถในการสังเกต การติดตาม และคุณภาพของข้อมูล

chronon ให้การมองเห็นเป็น:

ความใหม่ของข้อมูล - ตรวจสอบให้แน่ใจว่าค่าออนไลน์ได้รับการอัปเดตแบบเรียลไทม์
ความสอดคล้องทางออนไลน์/ออฟไลน์ - ตรวจสอบให้แน่ใจว่าข้อมูลทดแทนสำหรับการฝึกโมเดลและการประเมินสอดคล้องกับสิ่งที่สังเกตพบในการให้บริการออนไลน์

การแปลงที่ซับซ้อนและการรวมหน้าต่าง

chronon รองรับประเภทการรวมหลายประเภท สำหรับรายการทั้งหมด โปรดดูเอกสารที่นี่

การรวมกลุ่มเหล่านี้ทั้งหมดสามารถกำหนดค่าให้คำนวณผ่านขนาดหน้าต่างที่กำหนดเองได้

เริ่มต้นอย่างรวดเร็ว

ส่วนนี้จะอธิบายขั้นตอนต่างๆ ในการสร้างชุดข้อมูลการฝึกด้วย chronon โดยใช้ชุดข้อมูลดิบพื้นฐานที่ประดิษฐ์ขึ้นมา

รวมถึง:

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

ไม่รวมถึง:

เจาะลึกแนวคิดและคำศัพท์ต่างๆ ใน chronon โปรดดูเอกสารประกอบเบื้องต้น
รันงานสตรีมมิ่ง

ความต้องการ

นักเทียบท่า

ตั้งค่า

ในการเริ่มต้นใช้งาน chronon สิ่งที่คุณต้องทำคือดาวน์โหลดไฟล์ docker-compose.yml และรันในเครื่อง:

curl -o docker-compose.yml https://chronon.ai/docker-compose.yml
docker-compose up

เมื่อคุณเห็นข้อมูลบางส่วนที่พิมพ์โดย only showing top 20 rows คุณก็พร้อมที่จะดำเนินการตามบทช่วยสอนแล้ว

การแนะนำ

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

แหล่งข้อมูลดิบ

ข้อมูลดิบที่ประดิษฐ์ขึ้นจะรวมอยู่ในไดเร็กทอรีข้อมูล ประกอบด้วยสี่ตาราง:

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

เริ่มเซสชันเชลล์ในคอนเทนเนอร์ Docker

ในหน้าต่างเทอร์มินัลใหม่ ให้รัน:

docker-compose exec main bash

นี่จะเป็นการเปิดเชลล์ภายในคอนเทนเนอร์นักเทียบท่า chronon

การพัฒนา chronon

เมื่อขั้นตอนการตั้งค่าเสร็จสมบูรณ์แล้ว เราก็สามารถเริ่มสร้างและทดสอบออบเจ็กต์ chronon ต่างๆ เพื่อกำหนดการแปลงและการรวมกลุ่ม และสร้างข้อมูลได้

ขั้นตอนที่ 1 - กำหนดคุณสมบัติบางอย่าง

เริ่มจากชุดคุณสมบัติสามชุดที่สร้างขึ้นจากแหล่งอินพุตดิบของเรา

หมายเหตุ: คำจำกัดความของ Python เหล่านี้มีอยู่แล้วในอิมเมจ chronon ของคุณ ไม่มีอะไรให้คุณดำเนินการจนกว่าจะถึงขั้นตอนที่ 3 - การทดแทนข้อมูล เมื่อคุณจะเรียกใช้การคำนวณสำหรับคำจำกัดความเหล่านี้

ชุดคุณลักษณะ 1: ซื้อคุณลักษณะข้อมูล

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

เนื่องจากคุณลักษณะนี้สร้างขึ้นจากแหล่งที่มาที่มีทั้งตารางและหัวข้อ จึงสามารถคำนวณคุณลักษณะต่างๆ ได้ทั้งแบบแบตช์และการสตรีม

 source = Source (
    events = EventSource (
        table = "data.purchases" , # This points to the log table with historical purchase events
        topic = None , # Streaming is not currently part of quickstart, but this would be where you define the topic for realtime events
        query = Query (
            selects = select ( "user_id" , "purchase_price" ), # Select the fields we care about
            time_column = "ts" ) # The event time
    ))

window_sizes = [ Window ( length = day , timeUnit = TimeUnit . DAYS ) for day in [ 3 , 14 , 30 ]] # Define some window sizes to use below

v1 = GroupBy (
    sources = [ source ],
    keys = [ "user_id" ], # We are aggregating by user
    aggregations = [ Aggregation (
            input_column = "purchase_price" ,
            operation = Operation . SUM ,
            windows = window_sizes
        ), # The sum of purchases prices in various windows
        Aggregation (
            input_column = "purchase_price" ,
            operation = Operation . COUNT ,
            windows = window_sizes
        ), # The count of purchases in various windows
        Aggregation (
            input_column = "purchase_price" ,
            operation = Operation . AVERAGE ,
            windows = window_sizes
        ) # The average purchases by user in various windows
    ],
)

ดูไฟล์โค้ดทั้งหมดได้ที่นี่: ซื้อ GroupBy นี่ยังอยู่ในอิมเมจนักเทียบท่าของคุณด้วย เราจะดำเนินการคำนวณสำหรับมันและ GroupBys อื่นๆ ในขั้นตอนที่ 3 - การทดแทนข้อมูล

ชุดคุณลักษณะ 2: ส่งกลับคุณลักษณะข้อมูล

เราทำการรวมชุดที่คล้ายกันกับข้อมูลการส่งคืนใน GroupBy ที่ส่งคืน โค้ดไม่ได้รวมอยู่ที่นี่เนื่องจากมีลักษณะคล้ายกับตัวอย่างข้างต้น

ชุดคุณลักษณะ 3: คุณลักษณะข้อมูลผู้ใช้

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

 source = Source (
    entities = EntitySource (
        snapshotTable = "data.users" , # This points to a table that contains daily snapshots of the entire product catalog
        query = Query (
            selects = select ( "user_id" , "account_created_ds" , "email_verified" ), # Select the fields we care about
        )
    ))

v1 = GroupBy (
    sources = [ source ],
    keys = [ "user_id" ], # Primary key is the same as the primary key for the source table
    aggregations = None # In this case, there are no aggregations or windows to define
)

นำมาจากผู้ใช้ GroupBy

ขั้นตอนที่ 2 - เข้าร่วมคุณสมบัติร่วมกัน

ต่อไป เราต้องการคุณสมบัติที่เรากำหนดไว้ก่อนหน้านี้ทดแทนในตารางเดียวสำหรับการฝึกโมเดล ซึ่งสามารถทำได้โดยใช้ Join API

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

Join คือ API ที่ขับเคลื่อนคุณลักษณะการทดแทนข้อมูลสำหรับการฝึกอบรม โดยจะทำหน้าที่ดังต่อไปนี้เป็นหลัก:

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

นี่คือลักษณะการเข้าร่วมของเรา:

 source = Source (
    events = EventSource (
        table = "data.checkouts" , 
        query = Query (
            selects = select ( "user_id" ), # The primary key used to join various GroupBys together
            time_column = "ts" ,
            ) # The event time used to compute feature values as-of
    ))

v1 = Join (  
    left = source ,
    right_parts = [ JoinPart ( group_by = group_by ) for group_by in [ purchases_v1 , refunds_v1 , users ]] # Include the three GroupBys
)

นำมาจาก training_set เข้าร่วม

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

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

ขั้นตอนที่ 3 - การเติมข้อมูล

เมื่อกำหนด join แล้ว เราจะคอมไพล์โดยใช้คำสั่งนี้:

compile.py --conf=joins/quickstart/training_set.py

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

run.py --conf production/joins/quickstart/training_set.v1

ผลลัพธ์ของการทดแทนจะมีคอลัมน์ user_id และ ts จากแหล่งที่มาด้านซ้าย รวมถึงคอลัมน์คุณลักษณะ 11 คอลัมน์จาก GroupBys 3 คอลัมน์ที่เราสร้างขึ้น

ค่าฟีเจอร์จะถูกคำนวณสำหรับแต่ละ user_id และ ts ทางด้านซ้าย พร้อมรับประกันความแม่นยำชั่วคราว ตัวอย่างเช่น หากแถวใดแถวหนึ่งทางด้านซ้ายคือ user_id = 123 และ ts = 2023-10-01 10:11:23.195 คุณลักษณะ purchase_price_avg_30d จะถูกคำนวณสำหรับผู้ใช้รายนั้นโดยมีกรอบเวลา 30 วันที่แน่นอนซึ่งสิ้นสุดในวันที่ การประทับเวลานั้น

ตอนนี้คุณสามารถสืบค้นข้อมูลที่ทดแทนได้โดยใช้เชลล์ spark sql:

spark-sql

แล้ว:

spark - sql > SELECT user_id, quickstart_returns_v1_refund_amt_sum_30d, quickstart_purchases_v1_purchase_price_sum_14d, quickstart_users_v1_email_verified from default . quickstart_training_set_v1 limit 100 ;

โปรดทราบว่านี่จะเลือกเพียงไม่กี่คอลัมน์เท่านั้น คุณยังสามารถเรียกใช้ select * from default.quickstart_training_set_v1 limit 100 เพื่อดูคอลัมน์ทั้งหมดได้ อย่างไรก็ตาม โปรดทราบว่าตารางค่อนข้างกว้างและผลลัพธ์อาจอ่านได้ไม่มากนักบนหน้าจอของคุณ

หากต้องการออกจากเชลล์ sql คุณสามารถเรียกใช้:

spark-sql > quit ;

กระแสออนไลน์

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

กำลังอัพโหลดข้อมูล

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

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

อัปโหลดการซื้อ GroupBy:

run.py --mode upload --conf production/group_bys/quickstart/purchases.v1 --ds  2023-12-01

spark-submit --class ai. chronon .quickstart.online.Spark2MongoLoader --master local[ * ] /srv/onlineImpl/target/scala-2.12/mongo-online-impl-assembly-0.1.0-SNAPSHOT.jar default.quickstart_purchases_v1_upload mongodb://admin:admin@mongodb:27017/ ? authSource=admin

อัปโหลดการส่งคืน GroupBy:

run.py --mode upload --conf production/group_bys/quickstart/returns.v1 --ds  2023-12-01

spark-submit --class ai. chronon .quickstart.online.Spark2MongoLoader --master local[ * ] /srv/onlineImpl/target/scala-2.12/mongo-online-impl-assembly-0.1.0-SNAPSHOT.jar default.quickstart_returns_v1_upload mongodb://admin:admin@mongodb:27017/ ? authSource=admin

อัปโหลดข้อมูลเมตาเข้าร่วม

หากเราต้องการใช้ FetchJoin api แทนที่จะเป็น FetchGroupby เราก็จำเป็นต้องอัปโหลดข้อมูลเมตาการรวมด้วย:

run.py --mode metadata-upload --conf production/joins/quickstart/training_set.v2

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

กำลังดึงข้อมูล

ด้วยการกำหนดเอนทิตีข้างต้น ตอนนี้คุณสามารถดึงข้อมูลเวกเตอร์คุณลักษณะได้อย่างง่ายดายด้วยการเรียก API แบบง่ายๆ

กำลังดึงข้อมูลเข้าร่วม:

run.py --mode fetch --type join --name quickstart/training_set.v2 -k ' {"user_id":"5"} '

คุณยังสามารถดึงข้อมูล GroupBy เดียวได้ (ซึ่งไม่จำเป็นต้องดำเนินการขั้นตอนการอัปโหลดข้อมูลเมตาเข้าร่วมก่อนหน้านี้):

run.py --mode fetch --type group-by --name quickstart/purchases.v1 -k ' {"user_id":"5"} '

สำหรับการใช้งานจริง ไคลเอ็นต์ Java มักจะถูกฝังลงในบริการโดยตรง

 Map < String , String > keyMap = new HashMap <>();
keyMap . put ( "user_id" , "123" );
Fetcher . fetch_join ( new Request ( "quickstart/training_set_v1" , keyMap ))

การตอบสนองตัวอย่าง

 > '{"purchase_price_avg_3d":14.3241, "purchase_price_avg_14d":11.89352, ...}'

หมายเหตุ: โค้ด Java นี้ไม่สามารถรันได้ใน Docker env แต่เป็นเพียงตัวอย่างเท่านั้น

บันทึกการดึงข้อมูลและวัดความสอดคล้องทางออนไลน์/ออฟไลน์

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

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

chronon ไม่เพียงแต่รับประกันความแม่นยำชั่วคราวเท่านั้น แต่ยังเสนอวิธีการวัดอีกด้วย

ไปป์ไลน์การวัดเริ่มต้นด้วยบันทึกของคำขอดึงข้อมูลออนไลน์ บันทึกเหล่านี้ประกอบด้วยคีย์หลักและการประทับเวลาของคำขอ พร้อมด้วยค่าคุณลักษณะที่ดึงข้อมูล จากนั้น chronon จะส่งคีย์และการประทับเวลาไปยัง Join backfill ทางด้านซ้าย โดยขอให้ Compute Engine ทดแทนค่าฟีเจอร์ จากนั้นจะเปรียบเทียบค่าที่ทดแทนกับค่าที่ดึงมาจริงเพื่อวัดความสอดคล้องกัน

ขั้นตอนที่ 1: การดึงข้อมูลบันทึก

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

run.py --mode fetch --type join --name quickstart/training_set.v2 -k '{"user_id":"5"}'

สองสามครั้งเพื่อสร้างการดึงข้อมูลบางส่วน

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

spark-submit --class ai. chronon .quickstart.online.MongoLoggingDumper --master local[ * ] /srv/onlineImpl/target/scala-2.12/mongo-online-impl-assembly-0.1.0-SNAPSHOT.jar default. chronon _log_table mongodb://admin:admin@mongodb:27017/ ? authSource=admin
compile.py --conf group_bys/quickstart/schema.py
run.py --mode backfill --conf production/group_bys/quickstart/schema.v1
run.py --mode log-flattener --conf production/joins/quickstart/training_set.v2 --log-table default. chronon _log_table --schema-table default.quickstart_schema_v1

ซึ่งจะสร้างตาราง default.quickstart_training_set_v2_logged ซึ่งประกอบด้วยผลลัพธ์ของคำขอดึงข้อมูลแต่ละรายการที่คุณสร้างไว้ก่อนหน้านี้ พร้อมด้วยการประทับเวลาที่คุณสร้างและ user ที่คุณร้องขอ

หมายเหตุ: เมื่อคุณเรียกใช้คำสั่งข้างต้น คำสั่งจะสร้างและ "ปิด" พาร์ติชันบันทึก ซึ่งหมายความว่าหากคุณดึงข้อมูลเพิ่มเติมในวันเดียวกัน (เวลา UTC) พาร์ติชันจะไม่ถูกผนวก หากคุณต้องการย้อนกลับและสร้างคำขอเพิ่มเติมสำหรับความสอดคล้องทางออนไลน์/ออฟไลน์ คุณสามารถวางตารางได้ (เรียกใช้ DROP TABLE default.quickstart_training_set_v2_logged ในเชลล์ spark-sql ) ก่อนที่จะรันคำสั่งข้างต้นอีกครั้ง

ตอนนี้คุณสามารถคำนวณเมตริกความสอดคล้องด้วยคำสั่งนี้:

run.py --mode consistency-metrics-compute --conf production/joins/quickstart/training_set.v2

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

มันสร้างตารางเอาต์พุตสองตาราง:

default.quickstart_training_set_v2_consistency : ตารางที่มนุษย์สามารถอ่านได้ซึ่งคุณสามารถสืบค้นเพื่อดูผลลัพธ์ของการตรวจสอบความสอดคล้องกัน
1. คุณสามารถป้อนเชลล์ sql ได้โดยการเรียกใช้ spark-sql จากเซสชัน bash ของนักเทียบท่า จากนั้นจึงสืบค้นตาราง
2. โปรดทราบว่ามีหลายคอลัมน์ (หลายเมตริกต่อคุณลักษณะ) ดังนั้นคุณอาจต้องการเรียกใช้ DESC default.quickstart_training_set_v2_consistency ก่อน จากนั้นเลือกคอลัมน์สองสามคอลัมน์ที่คุณต้องการสืบค้น
default.quickstart_training_set_v2_consistency_upload : รายการไบต์ KV ที่อัปโหลดไปยังร้านค้า KV ออนไลน์ ที่สามารถใช้เพื่อขับเคลื่อนโฟลว์การตรวจสอบคุณภาพข้อมูลออนไลน์ ไม่ได้ตั้งใจให้มนุษย์อ่านได้

บทสรุป

การใช้ chronon สำหรับงานวิศวกรรมฟีเจอร์ของคุณช่วยลดความยุ่งยากและปรับปรุงเวิร์กโฟลว์ ML ของคุณได้หลายวิธี:

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

หากต้องการดูรายละเอียดเพิ่มเติมเกี่ยวกับประโยชน์ของการใช้ chronon โปรดดูประโยชน์ของเอกสารประกอบ chronon

ประโยชน์ของ chronon เหนือวิธีอื่นๆ

chronon มอบคุณค่าสูงสุดแก่ผู้ปฏิบัติงานด้าน AI/ML ที่กำลังพยายามสร้างโมเดล "ออนไลน์" ที่ให้บริการคำขอแบบเรียลไทม์ ตรงข้ามกับเวิร์กโฟลว์แบบแบตช์

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

โดยทั่วไป เราสังเกตว่าผู้ปฏิบัติงาน ML ใช้วิธีใดวิธีหนึ่งจากสองวิธี:

แนวทางการบันทึกและรอ

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

ข้อดี:

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

จุดด้อย:

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

แนวทางออฟไลน์-ออนไลน์จำลอง

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

ข้อดี:

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

จุดด้อย:

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

แนวทาง chronon

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

มีส่วนร่วม

เรายินดีรับการมีส่วนร่วมในโครงการ chronon ! โปรดอ่านการมีส่วนร่วมเพื่อดูรายละเอียด

สนับสนุน

ใช้ตัวติดตามปัญหา GitHub เพื่อรายงานจุดบกพร่องหรือคำขอคุณสมบัติ เข้าร่วมพื้นที่ทำงาน Slack ของชุมชนของเราเพื่อรับการสนทนา เคล็ดลับ และการสนับสนุน

ขยาย