TensorFlow Decision Forests ( TF-DF ) adalah kumpulan algoritma Decision Forest ( DF ) yang tersedia di TensorFlow. Cara kerja Decision Forest berbeda dengan Neural Networks ( NN ): DF umumnya tidak dilatih dengan backpropagation, atau dalam mini-batch. Oleh karena itu, pipeline TF-DF memiliki beberapa perbedaan dari pipeline TensorFlow lainnya.
Dokumen ini adalah daftar perbedaan tersebut, dan panduan untuk memperbarui pipeline TF untuk menggunakan TF-DF
Dokumen ini mengasumsikan bahwa Anda sudah familiar dengan colab pemula .
Kumpulan Data dan Fitur
Kumpulan data validasi
Berbeda dengan paradigma pelatihan Jaringan Neural standar, model TF-DF tidak memerlukan set data validasi untuk memantau overfitting, atau menghentikan pelatihan lebih awal. Jika Anda sudah memiliki pemisahan pelatihan/validasi/pengujian, dan Anda menggunakan validasi untuk salah satu alasan tersebut, aman untuk melatih TF-DF Anda pada pelatihan+validasi (kecuali pemisahan validasi juga digunakan untuk hal lain, seperti penyetelan hyperparameter).
- model.fit(train_ds, validation_data=val_ds)
+ model.fit(train_ds.concatenate(val_ds))
# Or just don't create a validation dataset
Dasar Pemikiran: Kerangka kerja TF-DF terdiri dari beberapa algoritma. Beberapa dari mereka tidak menggunakan dataset validasi (misalnya Random Forest) sementara beberapa lainnya menggunakan (misalnya Gradient Boosted Trees). Algoritma yang melakukannya mungkin mendapat manfaat dari jenis dan ukuran kumpulan data validasi yang berbeda. Oleh karena itu, jika diperlukan dataset validasi, maka dataset tersebut akan diekstraksi secara otomatis dari dataset pelatihan.
I/O kumpulan data
Berlatih tepat untuk 1 periode
# 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)
Dasar Pemikiran: Pengguna jaringan neural sering kali melatih model untuk N langkah (yang mungkin melibatkan perulangan pada kumpulan data > 1 kali), karena sifat SGD . TF-DF berlatih dengan membaca seluruh kumpulan data dan kemudian menjalankan pelatihan di akhir. Diperlukan 1 epoch untuk membaca kumpulan data lengkap, dan langkah tambahan apa pun akan mengakibatkan I/O data yang tidak diperlukan, serta pelatihan yang lebih lambat.
Jangan mengacak kumpulan data
Kumpulan data tidak perlu diacak (kecuali input_fn hanya membaca sampel kumpulan data).
- train_ds = train_ds.shuffle(5)
- model.fit(train_ds)
+ model.fit(train_ds)
Dasar Pemikiran: TF-DF mengacak akses ke data secara internal setelah membaca kumpulan data lengkap ke dalam memori. Algoritma TF-DF bersifat deterministik (jika pengguna tidak mengubah seed secara acak). Mengaktifkan pengacakan hanya akan membuat algoritme menjadi non-deterministik. Pengacakan masuk akal jika kumpulan data masukan diurutkan dan input_fn hanya akan membaca sampelnya (sampel harus acak). Namun, hal ini akan membuat prosedur pelatihan menjadi non-deterministik.
Jangan sesuaikan ukuran batch
Ukuran batch tidak akan mempengaruhi kualitas model
- 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)
Alasan: Karena TF-DF selalu dilatih pada kumpulan data lengkap setelah dibaca, kualitas model tidak akan bervariasi berdasarkan ukuran batch (tidak seperti algoritme pelatihan batch mini seperti SGD yang parameternya seperti kecepatan pemelajaran perlu disesuaikan secara bersamaan). Oleh karena itu, ini harus dihapus dari sapuan hyperparameter. Ukuran batch hanya akan berdampak pada kecepatan I/O kumpulan data.
Kumpulan Data Besar
Tidak seperti jaringan saraf, yang dapat mengulang kumpulan kecil kumpulan data besar tanpa batas, hutan keputusan memerlukan kumpulan data terbatas yang sesuai dengan memori untuk prosedur pelatihannya. Ukuran kumpulan data memiliki implikasi kinerja dan memori.
Ada keuntungan yang semakin berkurang jika ukuran kumpulan data ditingkatkan, dan algoritme DF mungkin memerlukan lebih sedikit contoh untuk konvergensi dibandingkan model NN besar. Daripada menskalakan jumlah langkah pelatihan (seperti pada NN), Anda dapat mencoba menskalakan jumlah data untuk melihat di mana trade-off komputasi masuk akal. Oleh karena itu, merupakan ide bagus untuk mencoba pelatihan terlebih dahulu pada sebagian kecil kumpulan data.
Solusi alternatifnya adalah dengan menggunakan pelatihan terdistribusi . Pelatihan terdistribusi adalah cara terbaik untuk meningkatkan ukuran kumpulan data jika tersedia beberapa mesin. Meskipun semua algoritma terdistribusi tersedia untuk mendistribusikan komputasi, tidak semuanya mampu mendistribusikan penggunaan RAM. Periksa dokumentasi untuk lebih jelasnya.
Berapa banyak contoh yang digunakan
Ini harus sesuai dengan memori pada mesin tempat model dilatih :
Perhatikan bahwa ini tidak sama dengan ukuran contoh pada disk.
Sebagai aturan praktis, satu nilai numerik atau kategorikal menggunakan memori 4 byte. Jadi, kumpulan data dengan 100 fitur dan 25 juta contoh akan memakan ~10 GB (= 100 * 25 *10^6 * 4 byte) memori.
Fitur kumpulan kategoris (misalnya teks yang diberi token) memerlukan lebih banyak memori (4 byte per token + 12 byte per fitur).
Pertimbangkan anggaran waktu pelatihan Anda
Meskipun umumnya lebih cepat daripada NN untuk kumpulan data yang lebih kecil (misalnya <100 ribu contoh), algoritme pelatihan DF tidak menskalakan secara linear dengan ukuran kumpulan data; sebaliknya, ~O(features x num_examples x log(num_examples)) dalam banyak kasus.
Waktu pelatihan bergantung pada hyper-parameter. Parameter yang paling berpengaruh adalah: (1) jumlah pohon (
num_trees), (2) contoh laju pengambilan sampel (subsampleuntuk GBT), dan (3) laju pengambilan sampel atribut (num_candidate_attributes_ratio)Fitur kumpulan kategorikal lebih mahal dibandingkan fitur lainnya. Biaya dikontrol oleh parameter
categorical_set_split_greedy_sampling.Fitur Sparse Oblique (dinonaktifkan secara default) memberikan hasil yang baik tetapi mahal untuk dihitung.
Aturan praktis untuk meningkatkan skala data
Kami menyarankan untuk memulai dengan sebagian kecil data (<10 ribu contoh), yang memungkinkan Anda melatih model TF-DF dalam hitungan detik atau beberapa menit dalam banyak kasus. Kemudian Anda dapat meningkatkan data pada tingkat yang tetap (misalnya 40% lebih banyak setiap kali), berhenti ketika kinerja set validasi tidak meningkat atau set data tidak lagi muat di memori.
Normalisasi Fitur/Pemrosesan Awal
Jangan mengubah data dengan kolom fitur
Model TF-DF tidak memerlukan penyediaan semantik dan transformasi fitur secara eksplisit. Secara default, semua fitur dalam kumpulan data (selain label) akan terdeteksi dan digunakan oleh model. Semantik fitur akan terdeteksi secara otomatis, dan dapat diganti secara manual jika diperlukan.
# 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()
Anda juga dapat menentukan subkumpulan fitur masukan:
+ features = [
+ tfdf.keras.FeatureUsage(name="feature_1"),
+ tfdf.keras.FeatureUsage(name="feature_2")
+ ]
+ model = tfdf.keras.GradientBoostedTreesModel(features=features, exclude_non_specified_features=True)
Jika perlu, Anda dapat memaksakan semantik suatu fitur.
+ forced_features = [
+ tfdf.keras.FeatureUsage(name="feature_1", semantic=tfdf.keras.FeatureSemantic.CATEGORICAL),
+ ]
+ model = tfdf.keras.GradientBoostedTreesModel(features=features)
Dasar Pemikiran: Meskipun model tertentu (seperti Jaringan Neural) memerlukan lapisan masukan standar (misalnya pemetaan dari berbagai jenis fitur → penyematan), model TF-DF dapat menggunakan fitur kategorikal dan numerik secara asli, serta mendeteksi jenis fitur semantik secara otomatis berdasarkan data.
Jangan memproses fitur terlebih dahulu
Algoritma pohon keputusan tidak mendapatkan keuntungan dari beberapa pra-pemrosesan fitur klasik yang digunakan untuk Jaringan Syaraf Tiruan. Di bawah ini, beberapa strategi pemrosesan fitur yang lebih umum dicantumkan secara eksplisit, namun titik awal yang aman adalah menghapus semua pra-pemrosesan yang dirancang untuk membantu pelatihan jaringan saraf.
Jangan normalkan fitur numerik
- def zscore(value):
- return (value-mean) / sd
- feature_columns = [tf.feature_column.numeric_column("feature_1",normalizer_fn=zscore)]
Rasional: Algoritme hutan keputusan secara asli mendukung fitur numerik yang tidak dinormalisasi, karena algoritma pemisahan tidak melakukan transformasi numerik apa pun pada masukan. Beberapa jenis normalisasi (misalnya normalisasi zscore) tidak akan membantu stabilitas numerik dari prosedur pelatihan, dan beberapa jenis (misalnya kliping outlier) dapat merusak ekspresi model akhir.
Jangan mengkodekan fitur kategoris (misalnya hashing, one-hot, atau embedding)
- 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)]
Dasar Pemikiran: TF-DF memiliki dukungan asli untuk fitur kategoris, dan akan memperlakukan item kosakata yang “diubah” hanya sebagai item lain dalam kosakata internalnya (yang dapat dikonfigurasi melalui hyperparameter model). Beberapa transformasi (seperti hashing) bisa merugikan. Penyematan tidak didukung kecuali jika sudah dilatih sebelumnya, karena model Decision Forest tidak dapat dibedakan (lihat colab perantara ). Perhatikan bahwa strategi kosakata khusus domain (misalnya penghapusan stopword, normalisasi teks) mungkin masih berguna.
Cara menangani fitur teks
TF-DF mendukung fitur kumpulan kategori secara asli. Oleh karena itu, kantong n-gram yang diberi token dapat dikonsumsi secara asli.
Alternatifnya, teks juga dapat dikonsumsi melalui penyematan terlatih .
Kumpulan kategorikal adalah sampel yang efisien pada kumpulan data kecil, tetapi mahal untuk dilatih pada kumpulan data besar. Menggabungkan kumpulan kategori dan penyematan terlatih seringkali dapat memberikan hasil yang lebih baik dibandingkan jika keduanya digunakan sendiri.
Jangan ganti fitur yang hilang dengan nilai ajaib
Dasar Pemikiran: TF-DF memiliki dukungan asli untuk nilai-nilai yang hilang. Tidak seperti jaringan saraf, yang dapat menyebarkan NaN ke gradien jika ada NaN di masukan, TF-DF akan berlatih secara optimal jika algoritme melihat perbedaan antara nilai yang hilang dan nilai sentinel.
- feature_columns = [
- tf.feature_column.numeric_column("feature_1", default_value=0),
- tf.feature_column.numeric_column("feature_1_is_missing"),
- ]
Menangani Gambar dan Rangkaian Waktu
Tidak ada algoritme standar untuk menggunakan fitur gambar atau deret waktu di Decision Forests, sehingga diperlukan kerja ekstra untuk menggunakannya.
Dasar Pemikiran: Konvolusi, LSTM, perhatian, dan algoritme pemrosesan urutan lainnya adalah arsitektur khusus jaringan saraf.
Fitur-fitur ini dapat ditangani dengan menggunakan strategi berikut:
Rekayasa Fitur
Gambar: Menggunakan gambar dengan Random Forest pernah populer di beberapa titik (mis
Microsoft Kinect , tetapi saat ini, jaringan saraf adalah yang tercanggih.
Deret waktu: [ Statistik bergerak ] dapat bekerja dengan sangat baik untuk data deret waktu yang memiliki contoh yang relatif sedikit (misalnya tanda-tanda vital dalam domain medis).
Modul penyematan: Modul penyematan jaringan saraf dapat menyediakan fitur yang kaya untuk algoritme hutan keputusan. Colab perantara menunjukkan cara menggabungkan penyematan tf-hub dan model TF-DF.
Saluran Pelatihan
Jangan gunakan akselerator perangkat keras misalnya GPU, TPU
Pelatihan TF-DF (belum) mendukung akselerator perangkat keras. Semua pelatihan dan inferensi dilakukan pada CPU (terkadang menggunakan SIMD).
Perhatikan bahwa inferensi TF-DF pada CPU (terutama saat disajikan menggunakan pustaka Yggdrasil C++) bisa sangat cepat (sub-mikrodetik per contoh per inti cpu).
Jangan gunakan kait pos pemeriksaan atau di tengah latihan
TF-DF (saat ini) tidak mendukung pos pemeriksaan model, artinya sebagian besar hook yang mengharapkan model dapat digunakan sebelum pelatihan selesai tidak didukung. Model ini hanya akan tersedia setelah melatih jumlah pohon yang diminta (atau berhenti lebih awal).
Kait keras yang mengandalkan langkah pelatihan juga tidak akan berfungsi – karena sifat pelatihan TF-DF, model dilatih pada akhir epoch pertama, dan akan konstan setelah epoch tersebut. Langkah ini hanya sesuai dengan I/O kumpulan data.
Model determinisme
Algoritma pelatihan TF-DF bersifat deterministik, yaitu pelatihan dua kali pada dataset yang sama akan menghasilkan model yang sama persis. Hal ini berbeda dengan jaringan neural yang dilatih dengan TensorFlow. Untuk mempertahankan determinisme ini, pengguna harus memastikan bahwa pembacaan kumpulan data juga bersifat deterministik.
Konfigurasi Pelatihan
Tentukan tugas (misalnya klasifikasi, peringkat) alih-alih kerugian (misalnya biner lintas entropi)
- 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'])
Dasar Pemikiran : Tidak semua algoritma pembelajaran TF-DF menggunakan loss. Bagi mereka yang melakukannya, kerugian secara otomatis terdeteksi dari tugas dan dicetak dalam ringkasan model. Anda juga dapat menggantinya dengan parameter hiper kerugian.
Hyper-parameter stabil secara semantik
Semua hyper-parameter memiliki nilai default. Nilai-nilai tersebut adalah kandidat pertama yang masuk akal untuk dicoba. Nilai hyper-parameter default dijamin tidak akan pernah berubah. Karena alasan ini, peningkatan hyper-parameter atau algoritme baru dinonaktifkan secara default.
Pengguna yang ingin menggunakan algoritme terbaru, namun tidak ingin mengoptimalkan hyper-parameternya sendiri dapat menggunakan "templat hyper-parameter" yang disediakan oleh TF-DF. Templat hyperparameter baru akan dirilis dengan pembaruan pada paket.
# 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()
Proses debug model
Bagian ini menyajikan beberapa cara Anda dapat melihat/men-debug/menafsirkan model. Colab pemula berisi contoh end-to-end.
Ringkasan model sederhana
# Text description of the model, training logs, feature importances, etc.
model.summary()
Log Pelatihan dan Tensorboard
# List of metrics
logs = model.make_inspector().training_logs()
print(logs)
Atau menggunakan TensorBoard:
% load_ext
tensorboard
model.make_inspector().export_to_tensorboard("/tmp/tensorboard_logs")
% tensorboard - -logdir
"/tmp/tensorboard_logs"
Pentingnya fitur
model.make_inspector().variable_importances()
Merencanakan pepohonan
tfdf.model_plotter.plot_model_in_colab(model, tree_idx=0)
Akses struktur pohon
tree = model.make_inspector().extract_tree(tree_idx=0)
print(tree)
(Lihat colab tingkat lanjut )
Jangan gunakan strategi distribusi TensorFlow
TF-DF belum mendukung strategi distribusi TF. Penyiapan multi-pekerja akan diabaikan, dan pelatihan hanya akan dilakukan pada manajer.
- with tf.distribute.MirroredStrategy():
- model = ...
+ model = ....
Model Susun
Model TF-DF tidak melakukan propagasi mundur terhadap gradien. Akibatnya, NN tersebut tidak dapat disusun dengan model NN kecuali NN tersebut sudah dilatih.
Bermigrasi dari tf.estimator.BoostedTrees {Classifier/Regressor/Estimator}
Meskipun terdengar serupa, pohon yang dikuatkan TF-DF dan Estimator adalah algoritma yang berbeda. TF-DF mengimplementasikan makalah klasik Random Forest dan Gradient Boosted Machine (menggunakan Pohon) . tf.estimator.BoostedTreesEstimator adalah perkiraan algoritma Gradient Boosted Trees dengan prosedur pelatihan mini-batch yang dijelaskan dalam makalah ini
Beberapa hyper-parameter memiliki semantik serupa (misalnya num_trees), namun memiliki implikasi kualitas yang berbeda. Jika Anda menyetel hyperparameter di tf.estimator.BoostedTreesEstimator, Anda perlu menyetel ulang hyperparameter dalam TF-DF untuk mendapatkan hasil optimal.
Untuk pengguna Yggdrasil
Yggdrasil Decision Forest adalah pelatihan inti dan perpustakaan inferensi yang digunakan oleh TF-DF. Konfigurasi dan model pelatihan bersifat kompatibel silang (yaitu model yang dilatih dengan TF-DF dapat digunakan dengan inferensi Yggdrasil).
Namun, beberapa algoritma Yggdrasil belum (belum) tersedia di TF-DF.
- Gradient Boosted Tree dengan pengambilan sampel shard.