การโยกย้ายจากโครงข่ายประสาทเทียม

TensorFlow Decision Forests ( TF-DF ) คือชุดของอัลกอริทึม Decision Forest ( DF ) ที่มีอยู่ใน TensorFlow Decision Forests ทำงานแตกต่างจาก Neural Networks ( NN ): โดยทั่วไปแล้ว DF จะไม่ฝึกแบบ backpropagation หรือแบบมินิแบทช์ ดังนั้นไปป์ไลน์ TF-DF จึงมีความแตกต่างเล็กน้อยจากไปป์ไลน์ TensorFlow อื่นๆ

เอกสารนี้คือรายการความแตกต่างเหล่านั้น และเป็นแนวทางในการอัปเดตไปป์ไลน์ TF เพื่อใช้ TF-DF

เอกสารนี้จะถือว่ามีความคุ้นเคยกับ colab มือใหม่

ชุดข้อมูลและคุณสมบัติ

ชุดข้อมูลการตรวจสอบ

ต่างจากกระบวนทัศน์การฝึกอบรม Neural Network มาตรฐาน โมเดล TF-DF ไม่จำเป็นต้องมีชุดข้อมูลการตรวจสอบเพื่อตรวจสอบการติดตั้งมากเกินไปหรือหยุดการฝึกตั้งแต่เนิ่นๆ หากคุณมีการแยกรถไฟ/การตรวจสอบความถูกต้อง/การทดสอบอยู่แล้ว และคุณใช้การตรวจสอบความถูกต้องด้วยเหตุผลข้อใดข้อหนึ่งดังกล่าว การฝึก TF-DF ของคุณบนการตรวจสอบรถไฟ+การตรวจสอบความถูกต้องนั้นปลอดภัย (เว้นแต่จะใช้การแยกการตรวจสอบความถูกต้องเพื่ออย่างอื่นด้วย เช่น การปรับไฮเปอร์พารามิเตอร์) 

- model.fit(train_ds, validation_data=val_ds)

+ model.fit(train_ds.concatenate(val_ds))

# Or just don't create a validation dataset

เหตุผล: กรอบงาน TF-DF ประกอบด้วยอัลกอริธึมหลายตัว บางส่วนไม่ได้ใช้ชุดข้อมูลการตรวจสอบ (เช่น Random Forest) ในขณะที่บางชุดใช้ (เช่น Gradient Boosted Trees) อัลกอริทึมที่อาจได้รับประโยชน์จากชุดข้อมูลการตรวจสอบประเภทและขนาดที่แตกต่างกัน ดังนั้น หากจำเป็นต้องมีชุดข้อมูลการตรวจสอบความถูกต้อง ชุดข้อมูลนั้นจะถูกแยกออกจากชุดข้อมูลการฝึกอบรมโดยอัตโนมัติ

ชุดข้อมูล I/O

ฝึกฝนมา 1 ยุคพอดี 

# Number of epochs in Keras
- model.fit(train_ds, num_epochs=5)

# Number of epochs in the dataset
- train_ds = train_ds.repeat(5)
- model.fit(train_ds)

+ model.fit(train_ds)

เหตุผล: ผู้ใช้โครงข่ายประสาทเทียมมักจะฝึกแบบจำลองสำหรับขั้นตอน N (ซึ่งอาจเกี่ยวข้องกับการวนซ้ำชุดข้อมูล > 1 ครั้ง) เนื่องจากลักษณะของ SGD TF-DF ฝึกฝนโดยการอ่านชุดข้อมูลทั้งหมด จากนั้นจึงดำเนินการฝึกอบรมในตอนท้าย จำเป็นต้องใช้ 1 epoch เพื่ออ่านชุดข้อมูลทั้งหมด และขั้นตอนเพิ่มเติมใดๆ จะส่งผลให้มี I/O ข้อมูลที่ไม่จำเป็น รวมถึงการฝึกอบรมที่ช้าลง

อย่าสับเปลี่ยนชุดข้อมูล

ชุดข้อมูลไม่จำเป็นต้องสับเปลี่ยน (เว้นแต่ว่า input_fn จะอ่านเฉพาะตัวอย่างของชุดข้อมูล) 

- train_ds = train_ds.shuffle(5)
- model.fit(train_ds)

+ model.fit(train_ds)

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

อย่าปรับขนาดแบทช์

ขนาดแบทช์จะไม่ส่งผลต่อคุณภาพของโมเดล 

- train_ds = train_ds.batch(hyper_parameter_batch_size())
- model.fit(train_ds)

# The batch size does not matter.
+ train_ds = train_ds.batch(64)
+ model.fit(train_ds)

เหตุผล: เนื่องจาก TF-DF จะได้รับการฝึกชุดข้อมูลแบบเต็มเสมอหลังจากที่อ่าน คุณภาพของแบบจำลองจะไม่แตกต่างกันไปตามขนาดแบตช์ (ต่างจากอัลกอริธึมการฝึกมินิแบตช์ เช่น SGD ที่จำเป็นต้องปรับพารามิเตอร์ เช่น อัตราการเรียนรู้ร่วมกัน) ดังนั้นจึงควรลบออกจากการกวาดไฮเปอร์พารามิเตอร์ ขนาดแบตช์จะส่งผลต่อความเร็วของชุดข้อมูล I/O เท่านั้น

ชุดข้อมูลขนาดใหญ่

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

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

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

ใช้ได้กี่ตัวอย่าง.

มันควรจะพอดีกับหน่วยความจำบนเครื่องที่โมเดลกำลังฝึก :

  • โปรดทราบว่านี่ไม่เหมือนกับขนาดของตัวอย่างบนดิสก์

  • ตามกฎทั่วไป ค่าตัวเลขหรือหมวดหมู่หนึ่งค่าจะใช้หน่วยความจำ 4 ไบต์ ดังนั้น ชุดข้อมูลที่มีคุณสมบัติ 100 รายการและตัวอย่าง 25 ล้านตัวอย่างจะใช้หน่วยความจำ ~10GB (= 100 * 25 *10^6 * 4 ไบต์)

  • คุณลักษณะที่กำหนดตามหมวดหมู่ (เช่น ข้อความโทเค็น) ใช้หน่วยความจำมากขึ้น (4 ไบต์ต่อโทเค็น + 12 ไบต์ต่อคุณลักษณะ)

พิจารณางบประมาณเวลาการฝึกอบรมของคุณ

  • แม้ว่าโดยทั่วไปจะเร็วกว่า NN สำหรับชุดข้อมูลขนาดเล็ก (เช่น <100,000 ตัวอย่าง) อัลกอริธึมการฝึกอบรม DF จะไม่ปรับขนาดเชิงเส้นตรงกับขนาดชุดข้อมูล ค่อนข้าง ~O(features x num_examples x log(num_examples)) ในกรณีส่วนใหญ่

  • เวลาการฝึกอบรมขึ้นอยู่กับไฮเปอร์พารามิเตอร์ พารามิเตอร์ที่มีผลกระทบมากที่สุดคือ: (1) จำนวนทรี ( num_trees ) (2) อัตราการสุ่มตัวอย่าง ( subsample สำหรับ GBT) และ (3) อัตราการสุ่มตัวอย่างแอตทริบิวต์ ( num_candidate_attributes_ratio )

  • คุณสมบัติที่กำหนดตามหมวดหมู่มีราคาแพงกว่าคุณสมบัติอื่นๆ ต้นทุนถูกควบคุมโดยพารามิเตอร์ categorical_set_split_greedy_sampling

  • คุณสมบัติ Sparse Oblique (ปิดใช้งานโดยค่าเริ่มต้น) ให้ผลลัพธ์ที่ดี แต่มีราคาแพงในการคำนวณ

กฎง่ายๆ ในการขยายขนาดข้อมูล

เราขอแนะนำให้เริ่มต้นด้วยข้อมูลส่วนเล็กๆ (<10,000 ตัวอย่าง) ซึ่งจะช่วยให้คุณฝึกโมเดล TF-DF ได้ในไม่กี่วินาทีหรือไม่กี่นาทีในกรณีส่วนใหญ่ จากนั้นคุณสามารถเพิ่มข้อมูลในอัตราคงที่ (เช่น เพิ่มขึ้น 40% ในแต่ละครั้ง) หยุดเมื่อประสิทธิภาพของชุดการตรวจสอบไม่ปรับปรุงหรือชุดข้อมูลไม่พอดีกับหน่วยความจำอีกต่อไป

คุณสมบัติการทำให้เป็นมาตรฐาน / การประมวลผลล่วงหน้า

อย่าแปลงข้อมูลด้วยคอลัมน์ฟีเจอร์

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

# Estimator code
- feature_columns = [
-   tf.feature_column.numeric_column(feature_1),
-   tf.feature_column.categorical_column_with_vocabulary_list(feature_2, ['First', 'Second', 'Third'])
-   ]
- model = tf.estimator.LinearClassifier(feature_columns=feature_columnes)

# Use all the available features. Detect the type automatically.
+ model = tfdf.keras.GradientBoostedTreesModel()

คุณยังสามารถระบุชุดย่อยของคุณสมบัติอินพุตได้:

+ features = [
+   tfdf.keras.FeatureUsage(name="feature_1"),
+   tfdf.keras.FeatureUsage(name="feature_2")
+   ]
+ model = tfdf.keras.GradientBoostedTreesModel(features=features, exclude_non_specified_features=True)

หากจำเป็น คุณสามารถบังคับใช้ความหมายของคุณลักษณะได้

+ forced_features = [
+   tfdf.keras.FeatureUsage(name="feature_1", semantic=tfdf.keras.FeatureSemantic.CATEGORICAL),
+   ]
+ model = tfdf.keras.GradientBoostedTreesModel(features=features)

เหตุผล: แม้ว่าบางรุ่น (เช่น Neural Networks) จำเป็นต้องมีเลเยอร์อินพุตที่เป็นมาตรฐาน (เช่น การแมปจากประเภทคุณสมบัติที่แตกต่างกัน → การฝัง) โมเดล TF-DF สามารถใช้คุณสมบัติเชิงหมวดหมู่และตัวเลขได้โดยตรง เช่นเดียวกับการตรวจจับประเภทความหมายของคุณสมบัติโดยอัตโนมัติ ขึ้นอยู่กับข้อมูล

อย่าประมวลผลคุณสมบัติล่วงหน้า

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

อย่าทำให้คุณสมบัติตัวเลขเป็นมาตรฐาน

- def zscore(value):
-   return (value-mean) / sd

- feature_columns = [tf.feature_column.numeric_column("feature_1",normalizer_fn=zscore)]

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

อย่าเข้ารหัสคุณลักษณะที่เป็นหมวดหมู่ (เช่น การแฮช อย่างเดียว หรือการฝัง) 

- integerized_column = tf.feature_column.categorical_column_with_hash_bucket("feature_1",hash_bucket_size=100)
- feature_columns = [tf.feature_column.indicator_column(integerized_column)]

- integerized_column = tf.feature_column.categorical_column_with_vocabulary_list('feature_1', ['bob', 'george', 'wanda'])
- feature_columns = [tf.feature_column.indicator_column(integerized_column)]

เหตุผล: TF-DF มีการสนับสนุนคุณสมบัติตามหมวดหมู่อยู่แล้ว และจะถือว่ารายการคำศัพท์ที่ "เปลี่ยนรูปแบบ" เป็นเพียงรายการอื่นในคำศัพท์ภายใน (ซึ่งสามารถกำหนดค่าได้ผ่านพารามิเตอร์โมเดลไฮเปอร์พารามิเตอร์) การแปลงบางอย่าง (เช่น การแฮช) อาจทำให้สูญเสียได้ ไม่รองรับการฝังเว้นแต่จะได้รับการฝึกอบรมล่วงหน้า เนื่องจากโมเดล Decision Forest ไม่สามารถสร้างความแตกต่างได้ (ดู Colab ระดับกลาง ) โปรดทราบว่ากลยุทธ์คำศัพท์เฉพาะโดเมน (เช่น การลบคำหยุด การทำให้ข้อความเป็นมาตรฐาน) อาจยังมีประโยชน์อยู่

วิธีจัดการกับคุณสมบัติข้อความ

TF-DF รองรับ คุณสมบัติที่กำหนดตามหมวดหมู่ โดยกำเนิด ดังนั้นจึงสามารถบริโภคถุงโทเคน n-gram ได้

หรืออีกทางหนึ่ง คุณสามารถใช้ข้อความผ่าน การฝังที่ได้รับการฝึกล่วงหน้า ได้

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

อย่าแทนที่คุณสมบัติที่ขาดหายไปด้วยค่าเวทย์มนตร์

เหตุผล: TF-DF มีการสนับสนุนดั้งเดิมสำหรับค่าที่หายไป ซึ่งแตกต่างจากโครงข่ายประสาทเทียมซึ่งอาจเผยแพร่ NaN ไปยังการไล่ระดับสีหากมี NaN ในอินพุต TF-DF จะฝึกอย่างเหมาะสมที่สุดหากอัลกอริทึมเห็นความแตกต่างระหว่างค่าที่หายไปและค่าแมวมอง 

- feature_columns = [
- tf.feature_column.numeric_column("feature_1", default_value=0),
- tf.feature_column.numeric_column("feature_1_is_missing"),
- ]

การจัดการภาพและอนุกรมเวลา

ไม่มีอัลกอริธึมมาตรฐานสำหรับการใช้คุณสมบัติรูปภาพหรืออนุกรมเวลาใน Decision Forests ดังนั้นจึงจำเป็นต้องมีการทำงานเพิ่มเติมบางอย่างเพื่อใช้งาน

เหตุผล: Convolution, LSTM, ความสนใจและอัลกอริธึมการประมวลผลลำดับอื่น ๆ เป็นสถาปัตยกรรมเฉพาะของโครงข่ายประสาทเทียม

คุณสามารถจัดการคุณสมบัติเหล่านี้ได้โดยใช้กลยุทธ์ต่อไปนี้:

  • วิศวกรรมคุณสมบัติ

    • รูปภาพ: การใช้รูปภาพกับ Random Forest ได้รับความนิยมในบางจุด (เช่น

      Microsoft Kinect แต่ในปัจจุบัน โครงข่ายประสาทเทียมมีความล้ำสมัย

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

    • การฝังโมดูล: โมดูลการฝังโครงข่ายประสาทเทียมสามารถให้คุณสมบัติที่หลากหลายสำหรับอัลกอริทึมฟอเรสต์การตัดสินใจ Colab ระดับกลาง จะแสดงวิธีรวมการฝัง tf-hub และโมเดล TF-DF

ไปป์ไลน์การฝึกอบรม

อย่าใช้ตัวเร่งฮาร์ดแวร์เช่น GPU, TPU

การฝึกอบรม TF-DF ยังไม่รองรับตัวเร่งฮาร์ดแวร์ การฝึกอบรมและการอนุมานทั้งหมดเสร็จสิ้นบน CPU (บางครั้งใช้ SIMD)

โปรดทราบว่าการอนุมาน TF-DF บน CPU (โดยเฉพาะอย่างยิ่งเมื่อให้บริการโดยใช้ไลบรารี Yggdrasil C++) สามารถทำได้อย่างรวดเร็วอย่างน่าประหลาดใจ (ต่ำกว่าไมโครวินาทีต่อตัวอย่างต่อคอร์ cpu)

อย่าใช้จุดตรวจหรือตะขอระหว่างการฝึก

TF-DF ไม่ (ปัจจุบัน) รองรับจุดตรวจสอบโมเดล ซึ่งหมายความว่า hooks ที่คาดหวังว่าโมเดลจะใช้งานได้ก่อนการฝึกจะเสร็จสิ้นนั้นส่วนใหญ่ไม่รองรับ โมเดลจะพร้อมใช้งานหลังจากฝึกต้นไม้ตามจำนวนที่ต้องการแล้วเท่านั้น (หรือหยุดก่อนเวลา)

Keras hooks ที่อาศัยขั้นตอนการฝึกอบรมจะไม่ทำงานเช่นกัน เนื่องจากลักษณะของการฝึกอบรม TF-DF ซึ่งเป็นโมเดลรถไฟในตอนท้ายของยุคแรก และจะคงที่หลังจากยุคนั้น ขั้นตอนนี้สอดคล้องกับชุดข้อมูล I/O เท่านั้น

การกำหนดแบบจำลอง

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

การกำหนดค่าการฝึกอบรม

ระบุงาน (เช่น การจำแนกประเภท การจัดอันดับ) แทนการสูญเสีย (เช่น ไบนารีข้ามเอนโทรปี) 

- model = tf_keras.Sequential()
- model.add(Dense(64, activation=relu))
- model.add(Dense(1)) # One output for binary classification

- model.compile(loss=tf_keras.losses.BinaryCrossentropy(from_logits=True),
-               optimizer='adam',
-               metrics=['accuracy'])

# The loss is automatically determined from the task.
+ model = tfdf.keras.GradientBoostedTreesModel(task=tf_keras.Task.CLASSIFICATION)

# Optional if you want to report the accuracy.
+ model.compile(metrics=['accuracy'])

เหตุผล: อัลกอริธึมการเรียนรู้ TF-DF บางตัวไม่ได้ใช้การสูญเสีย สำหรับผู้ที่ทำเช่นนั้น ระบบจะตรวจพบการสูญเสียจากงานโดยอัตโนมัติและพิมพ์ลงในสรุปโมเดล คุณยังสามารถแทนที่มันด้วยไฮเปอร์พารามิเตอร์ที่สูญเสียได้

ไฮเปอร์พารามิเตอร์มีความเสถียรทางความหมาย

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

ผู้ใช้ที่ต้องการใช้อัลกอริธึมล่าสุด แต่ไม่ต้องการเพิ่มประสิทธิภาพไฮเปอร์พารามิเตอร์ด้วยตนเอง สามารถใช้ "เทมเพลตไฮเปอร์พารามิเตอร์" ที่ TF-DF จัดเตรียมไว้ให้ เทมเพลตไฮเปอร์พารามิเตอร์ใหม่จะออกมาพร้อมกับการอัปเดตแพ็คเกจ 

# Model with default hyper-parameters.
model = tfdf.keras.GradientBoostedTreesModel()

# List the hyper-parameters (with default value) and hyper-parameters templates of the GBT learning algorithm (in colab)
?tfdf.keras.GradientBoostedTreesModel

# Use a hyper-parameter template.
model = tfdf.keras.GradientBoostedTreesModel(hp_template="winner_1")

# Change one of the hyper-parameters.
model = tfdf.keras.GradientBoostedTreesModel(num_trees=500)

# List all the learning algorithms available
tfdf.keras.get_all_models()

การดีบักโมเดล

ส่วนนี้นำเสนอวิธีการบางอย่างที่คุณสามารถดู/แก้ไขจุดบกพร่อง/ตีความโมเดลได้ Colab สำหรับผู้เริ่มต้น มีตัวอย่างตั้งแต่ต้นจนจบ

สรุปโมเดลอย่างง่าย 

# Text description of the model, training logs, feature importances, etc.
model.summary()

บันทึกการฝึกอบรมและเทนเซอร์บอร์ด

# List of metrics
logs = model.make_inspector().training_logs()
print(logs)

หรือใช้ TensorBoard: 

% load_ext
tensorboard
model.make_inspector().export_to_tensorboard("/tmp/tensorboard_logs")
% tensorboard - -logdir
"/tmp/tensorboard_logs"

ความสำคัญของคุณสมบัติ 

model.make_inspector().variable_importances()

การวางแผนต้นไม้ 

tfdf.model_plotter.plot_model_in_colab(model, tree_idx=0)

เข้าถึงโครงสร้างต้นไม้

tree = model.make_inspector().extract_tree(tree_idx=0)
print(tree)

(ดู colab ขั้นสูง )

อย่าใช้กลยุทธ์การกระจาย TensorFlow

TF-DF ยังไม่รองรับกลยุทธ์การกระจาย TF การตั้งค่าผู้ปฏิบัติงานหลายคนจะถูกละเว้น และการฝึกอบรมจะเกิดขึ้นกับผู้จัดการเท่านั้น 

- with tf.distribute.MirroredStrategy():
-    model = ...

+ model = ....

ซ้อนโมเดล

โมเดล TF-DF จะไม่เผยแพร่การไล่ระดับสีแบบย้อนกลับ ด้วยเหตุนี้ จึงไม่สามารถประกอบโมเดล NN เข้าด้วยกันได้ เว้นแต่ NN จะได้รับการฝึกอบรมแล้ว

การย้ายข้อมูลจาก tf.estimator.BoostedTrees {Classifier/Regressor/Estimator}

แม้จะฟังดูคล้ายกัน แต่แผนผังที่เพิ่มประสิทธิภาพของ TF-DF และ Estimator นั้นเป็นอัลกอริธึมที่แตกต่างกัน TF-DF ใช้เอกสาร Random Forest และ Gradient Boosted Machine แบบคลาสสิก (โดยใช้ Trees) tf.estimator.BoostedTreesEstimator เป็นอัลกอริธึม Gradient Boosted Trees โดยประมาณ พร้อมด้วยขั้นตอนการฝึกอบรมแบบกลุ่มย่อยที่อธิบายไว้ใน เอกสารนี้

ไฮเปอร์พารามิเตอร์บางตัวมีความหมายคล้ายกัน (เช่น num_trees) แต่มีความหมายด้านคุณภาพที่แตกต่างกัน หากคุณปรับไฮเปอร์พารามิเตอร์บน tf.estimator.BoostedTreesEstimator คุณจะต้องปรับแต่งไฮเปอร์พารามิเตอร์ภายใน TF-DF อีกครั้งเพื่อให้ได้ผลลัพธ์ที่ดีที่สุด

สำหรับผู้ใช้อิกดราซิล

Yggdrasil Decision Forest เป็นห้องสมุดการฝึกอบรมและการอนุมานหลักที่ใช้โดย TF-DF การกำหนดค่าและโมเดลการฝึกอบรมสามารถใช้งานร่วมกันได้ (เช่น โมเดลที่ได้รับการฝึกด้วย TF-DF สามารถใช้กับการอนุมาน Yggdrasil)

อย่างไรก็ตาม อัลกอริธึม Yggdrasil บางตัวยังไม่มีใน TF-DF

  • ต้นไม้ที่มีการไล่ระดับสีที่มีการสุ่มตัวอย่างแบบแบ่งส่วน