तंत्रिका नेटवर्क से पलायन

टेन्सरफ्लो डिसीजन फॉरेस्ट ( टीएफ-डीएफ ) टेन्सरफ्लो में उपलब्ध डिसीजन फॉरेस्ट ( डीएफ ) एल्गोरिदम का एक संग्रह है। डिसीजन फ़ॉरेस्ट न्यूरल नेटवर्क्स ( एनएन ) की तुलना में अलग तरह से काम करते हैं: डीएफ आमतौर पर बैकप्रोपेगेशन या मिनी-बैचों में प्रशिक्षण नहीं देते हैं। इसलिए, TF-DF पाइपलाइनों में अन्य TensorFlow पाइपलाइनों से कुछ अंतर हैं।

यह दस्तावेज़ उन अंतरों की एक सूची है, और TF-DF का उपयोग करने के लिए TF पाइपलाइनों को अद्यतन करने के लिए एक मार्गदर्शिका है

यह दस्तावेज़ शुरुआती कोलाब से परिचित होने का अनुमान लगाता है।

डेटासेट और सुविधाएँ

सत्यापन डेटासेट

मानक न्यूरल नेटवर्क प्रशिक्षण प्रतिमान के विपरीत, टीएफ-डीएफ मॉडल को ओवरफिटिंग की निगरानी करने या प्रशिक्षण को जल्दी रोकने के लिए सत्यापन डेटासेट की आवश्यकता नहीं होती है। यदि आपके पास पहले से ही एक ट्रेन/सत्यापन/परीक्षण विभाजन है, और आप उन कारणों में से एक के लिए सत्यापन का उपयोग कर रहे हैं, तो अपने टीएफ-डीएफ को ट्रेन+सत्यापन पर प्रशिक्षित करना सुरक्षित है (जब तक कि सत्यापन विभाजन का उपयोग किसी और चीज़ के लिए भी नहीं किया जाता है, जैसे हाइपरपैरामीटर ट्यूनिंग)।

- model.fit(train_ds, validation_data=val_ds)

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

# Or just don't create a validation dataset

तर्क: टीएफ-डीएफ ढांचा कई एल्गोरिदम से बना है। उनमें से कुछ सत्यापन डेटासेट का उपयोग नहीं करते हैं (उदाहरण के लिए रैंडम फ़ॉरेस्ट) जबकि कुछ अन्य करते हैं (उदाहरण के लिए ग्रेडिएंट बूस्टेड ट्रीज़)। ऐसा करने वाले एल्गोरिदम सत्यापन डेटासेट के विभिन्न प्रकारों और आकार से लाभान्वित हो सकते हैं। इसलिए, यदि सत्यापन डेटासेट की आवश्यकता है, तो इसे प्रशिक्षण डेटासेट से स्वचालित रूप से निकाला जाएगा।

डेटासेट 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)

तर्क: एसजीडी की प्रकृति के कारण, तंत्रिका नेटवर्क के उपयोगकर्ता अक्सर एन चरणों के लिए एक मॉडल को प्रशिक्षित करते हैं (जिसमें डेटासेट पर 1 बार लूपिंग शामिल हो सकती है)। टीएफ-डीएफ पूरे डेटासेट को पढ़कर और फिर अंत में प्रशिक्षण चलाकर प्रशिक्षण देता है। संपूर्ण डेटासेट को पढ़ने के लिए 1 युग की आवश्यकता होती है, और किसी भी अतिरिक्त कदम के परिणामस्वरूप अनावश्यक डेटा I/O, साथ ही धीमा प्रशिक्षण होगा।

डेटासेट में फेरबदल न करें

डेटासेट को फेरबदल करने की आवश्यकता नहीं है (जब तक कि इनपुट_एफएन डेटासेट का केवल एक नमूना नहीं पढ़ रहा हो)।

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

+ model.fit(train_ds)

तर्क: टीएफ-डीएफ पूरे डेटासेट को मेमोरी में पढ़ने के बाद आंतरिक रूप से डेटा तक पहुंच में फेरबदल करता है। टीएफ-डीएफ एल्गोरिदम नियतात्मक हैं (यदि उपयोगकर्ता यादृच्छिक बीज नहीं बदलता है)। फेरबदल को सक्षम करने से एल्गोरिदम केवल गैर-नियतात्मक हो जाएगा। यदि इनपुट डेटासेट का ऑर्डर दिया गया है और इनपुट_एफएन केवल इसका एक नमूना पढ़ने जा रहा है (नमूना यादृच्छिक होना चाहिए) तो शफ़ल करना समझ में आता है। हालाँकि, इससे प्रशिक्षण प्रक्रिया गैर-नियतात्मक हो जाएगी।

बैच का आकार समायोजित न करें

बैच का आकार मॉडल की गुणवत्ता को प्रभावित नहीं करेगा

- 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)

तर्क: चूंकि टीएफ-डीएफ को हमेशा पढ़ने के बाद पूर्ण डेटासेट पर प्रशिक्षित किया जाता है, इसलिए मॉडल की गुणवत्ता बैच आकार के आधार पर भिन्न नहीं होगी (एसजीडी जैसे मिनी-बैच प्रशिक्षण एल्गोरिदम के विपरीत जहां सीखने की दर जैसे मापदंडों को संयुक्त रूप से ट्यून करने की आवश्यकता होती है)। इस प्रकार इसे हाइपरपैरामीटर स्वीप्स से हटा दिया जाना चाहिए। बैच आकार का केवल डेटासेट I/O की गति पर प्रभाव पड़ेगा।

बड़े डेटासेट

तंत्रिका नेटवर्क के विपरीत, जो एक बड़े डेटासेट के मिनी-बैचों पर असीमित रूप से लूप कर सकता है, निर्णय वनों को एक सीमित डेटासेट की आवश्यकता होती है जो उनकी प्रशिक्षण प्रक्रियाओं के लिए मेमोरी में फिट बैठता है। डेटासेट के आकार का प्रदर्शन और मेमोरी पर प्रभाव पड़ता है।

डेटासेट के आकार को बढ़ाने के लिए कम रिटर्न हैं, और डीएफ एल्गोरिदम को बड़े एनएन मॉडल की तुलना में अभिसरण के लिए यकीनन कम उदाहरणों की आवश्यकता होती है। प्रशिक्षण चरणों की संख्या को स्केल करने के बजाय (जैसा कि एनएन में), आप यह देखने के लिए डेटा की मात्रा को स्केल करने का प्रयास कर सकते हैं कि गणना ट्रेडऑफ़ कहाँ समझ में आता है। इसलिए, पहले डेटासेट के (छोटे) उपसमूह पर प्रशिक्षण का प्रयास करना एक अच्छा विचार है।

वैकल्पिक समाधान वितरित प्रशिक्षण का उपयोग करना है। यदि एकाधिक मशीनें उपलब्ध हैं तो वितरित प्रशिक्षण डेटासेट का आकार बढ़ाने का एक शानदार तरीका है। जबकि सभी वितरित एल्गोरिदम गणना को वितरित करने के लिए उपलब्ध हैं, उनमें से सभी रैम उपयोग को वितरित करने में सक्षम नहीं हैं। अधिक विवरण के लिए दस्तावेज़ की जाँच करें.

कितने उदाहरणों का उपयोग करना है

इसे उस मशीन की मेमोरी में फिट होना चाहिए जिस पर मॉडल प्रशिक्षण ले रहा है :

• ध्यान दें कि यह डिस्क पर उदाहरणों के आकार के समान नहीं है।

• सामान्य नियम के अनुसार एक संख्यात्मक या श्रेणीबद्ध मान मेमोरी के 4 बाइट्स का उपयोग करता है। तो, 100 सुविधाओं और 25 मिलियन उदाहरणों वाला एक डेटासेट ~10GB (= 100 * 25 *10^6 * 4 बाइट्स) मेमोरी लेगा।

• श्रेणीबद्ध-सेट सुविधाएँ (जैसे टोकनयुक्त पाठ) अधिक मेमोरी लेती हैं (प्रति टोकन 4 बाइट्स + प्रति फीचर 12 बाइट्स)।

अपने प्रशिक्षण समय बजट पर विचार करें

• जबकि आम तौर पर छोटे डेटासेट (उदाहरण के लिए <100k उदाहरण) के लिए एनएन से तेज़, डीएफ प्रशिक्षण एल्गोरिदम डेटासेट आकार के साथ रैखिक रूप से स्केल नहीं करते हैं; बल्कि, अधिकांश मामलों में ~O(विशेषताएँ x num_examples x log(num_examples))।

• प्रशिक्षण का समय हाइपर-मापदंडों पर निर्भर करता है। सबसे प्रभावशाली पैरामीटर हैं: (1) पेड़ों की संख्या ( num_trees ), (2) उदाहरण नमूना दर (GBT के लिए subsample ), और (3) विशेषता नमूना दर ( num_candidate_attributes_ratio )

• श्रेणीबद्ध-सेट सुविधाएँ अन्य सुविधाओं की तुलना में अधिक महंगी हैं। लागत को categorical_set_split_greedy_sampling पैरामीटर द्वारा नियंत्रित किया जाता है।

• स्पार्स ओब्लिक सुविधाएँ (डिफ़ॉल्ट रूप से अक्षम) अच्छे परिणाम देती हैं लेकिन गणना करना महंगा है।

डेटा स्केलिंग के लिए सामान्य नियम

हमारा सुझाव है कि डेटा के एक छोटे टुकड़े (<10k उदाहरण) से शुरुआत करें, जिससे आपको ज्यादातर मामलों में सेकंड या कुछ मिनटों में टीएफ-डीएफ मॉडल को प्रशिक्षित करने की अनुमति मिलनी चाहिए। फिर आप डेटा को एक निश्चित दर पर बढ़ा सकते हैं (उदाहरण के लिए हर बार 40% अधिक), जब सत्यापन सेट के प्रदर्शन में सुधार नहीं होता है या डेटासेट मेमोरी में फिट नहीं होता है तो रुक जाता है।

फ़ीचर सामान्यीकरण / प्रीप्रोसेसिंग

फ़ीचर कॉलम के साथ डेटा को रूपांतरित न करें

टीएफ-डीएफ मॉडल को स्पष्ट रूप से फीचर शब्दार्थ और परिवर्तन प्रदान करने की आवश्यकता नहीं है। डिफ़ॉल्ट रूप से, डेटासेट में सभी सुविधाओं (लेबल के अलावा) का पता लगाया जाएगा और मॉडल द्वारा उपयोग किया जाएगा। फ़ीचर सेमेन्टिक्स का स्वतः पता लगाया जाएगा, और यदि आवश्यक हो तो इसे मैन्युअल रूप से ओवरराइड किया जा सकता है।

# 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)

तर्क: जबकि कुछ मॉडलों (जैसे न्यूरल नेटवर्क) को एक मानकीकृत इनपुट परत की आवश्यकता होती है (उदाहरण के लिए विभिन्न फीचर प्रकारों से मैपिंग → एम्बेडिंग), टीएफ-डीएफ मॉडल मूल रूप से श्रेणीबद्ध और संख्यात्मक सुविधाओं का उपभोग कर सकते हैं, साथ ही सुविधाओं के सिमेंटिक प्रकारों का स्वत: पता लगा सकते हैं। डेटा के आधार पर.

सुविधाओं को पहले से प्रोसेस न करें

निर्णय वृक्ष एल्गोरिदम न्यूरल नेटवर्क के लिए उपयोग किए जाने वाले कुछ शास्त्रीय फीचर प्रीप्रोसेसिंग से लाभ नहीं उठाते हैं। नीचे, कुछ अधिक सामान्य फीचर प्रोसेसिंग रणनीतियों को स्पष्ट रूप से सूचीबद्ध किया गया है, लेकिन एक सुरक्षित प्रारंभिक बिंदु उन सभी प्री-प्रोसेसिंग को हटाना है जो तंत्रिका नेटवर्क प्रशिक्षण में सहायता के लिए डिज़ाइन किए गए थे।

संख्यात्मक विशेषताओं को सामान्य न करें

- 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)]

तर्क: टीएफ-डीएफ के पास श्रेणीबद्ध विशेषताओं के लिए मूल समर्थन है, और यह "रूपांतरित" शब्दावली आइटम को अपनी आंतरिक शब्दावली में सिर्फ एक अन्य आइटम के रूप में मानेगा (जिसे मॉडल हाइपरपैरामीटर के माध्यम से कॉन्फ़िगर किया जा सकता है)। कुछ परिवर्तन (जैसे हैशिंग) हानिप्रद हो सकते हैं। एंबेडिंग का समर्थन तब तक नहीं किया जाता जब तक कि वे पूर्व-प्रशिक्षित न हों, क्योंकि डिसीजन फ़ॉरेस्ट मॉडल अलग-अलग नहीं होते हैं ( इंटरमीडिएट कोलाब देखें)। ध्यान दें कि डोमेन-विशिष्ट शब्दावली रणनीतियाँ (जैसे स्टॉपवर्ड हटाना, पाठ सामान्यीकरण) अभी भी सहायक हो सकती हैं।

टेक्स्ट सुविधाओं को कैसे संभालें

टीएफ-डीएफ मूल रूप से श्रेणीबद्ध-सेट सुविधाओं का समर्थन करता है। इसलिए, टोकनयुक्त एन-ग्राम के बैग का स्थानीय रूप से उपभोग किया जा सकता है।

वैकल्पिक रूप से, पाठ को पूर्व-प्रशिक्षित एम्बेडिंग के माध्यम से भी उपभोग किया जा सकता है।

श्रेणीबद्ध-सेट छोटे डेटासेट पर नमूना कुशल होते हैं, लेकिन बड़े डेटासेट पर प्रशिक्षित करना महंगा होता है। श्रेणीबद्ध-सेट और पूर्व-प्रशिक्षित एम्बेडिंग का संयोजन अक्सर अकेले उपयोग किए जाने की तुलना में बेहतर परिणाम दे सकता है।

लुप्त सुविधाओं को जादुई मूल्यों से न बदलें

तर्क: टीएफ-डीएफ के पास लापता मूल्यों के लिए मूल समर्थन है। तंत्रिका नेटवर्क के विपरीत, जो इनपुट में 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"),
- ]

छवियाँ और समय श्रृंखला को संभालना

डिसीज़न फ़ॉरेस्ट में छवि या समय श्रृंखला सुविधाओं का उपभोग करने के लिए कोई मानक एल्गोरिदम नहीं है, इसलिए उनका उपयोग करने के लिए कुछ अतिरिक्त काम की आवश्यकता होती है।

तर्क: कन्वोल्यूशन, एलएसटीएम, ध्यान और अन्य अनुक्रम प्रसंस्करण एल्गोरिदम तंत्रिका नेटवर्क विशिष्ट आर्किटेक्चर हैं।

निम्नलिखित रणनीतियों का उपयोग करके इन सुविधाओं को संभालना संभव है:

• फ़ीचर इंजीनियरिंग

  • छवियाँ: रैंडम फ़ॉरेस्ट के साथ छवि का उपयोग करना किसी समय लोकप्रिय था (उदाहरण के लिए)।

    Microsoft Kinect , लेकिन आज, तंत्रिका जाल अत्याधुनिक हैं।

  • समय श्रृंखला: [ चलते आँकड़े ] समय श्रृंखला डेटा के लिए आश्चर्यजनक रूप से अच्छी तरह से काम कर सकते हैं जिसमें अपेक्षाकृत कम उदाहरण हैं (उदाहरण के लिए चिकित्सा क्षेत्र में महत्वपूर्ण संकेत)।

  • एंबेडिंग मॉड्यूल: तंत्रिका नेटवर्क एंबेडिंग मॉड्यूल निर्णय वन एल्गोरिथ्म के लिए समृद्ध सुविधाएँ प्रदान कर सकते हैं। मध्यवर्ती कोलाब दिखाता है कि टीएफ-हब एम्बेडिंग और टीएफ-डीएफ मॉडल को कैसे संयोजित किया जाए।

प्रशिक्षण पाइपलाइन

जीपीयू, टीपीयू जैसे हार्डवेयर एक्सेलेरेटर का उपयोग न करें

टीएफ-डीएफ प्रशिक्षण (अभी तक) हार्डवेयर त्वरक का समर्थन नहीं करता है। सारा प्रशिक्षण और अनुमान सीपीयू पर किया जाता है (कभी-कभी SIMD का उपयोग करके)।

ध्यान दें कि सीपीयू पर टीएफ-डीएफ अनुमान (विशेष रूप से जब Yggdrasil C++ पुस्तकालयों का उपयोग करके परोसा जाता है) आश्चर्यजनक रूप से तेज़ हो सकता है (प्रति सीपीयू कोर प्रति उदाहरण उप-माइक्रोसेकंड)।

चेकपॉइंटिंग या मध्य-प्रशिक्षण हुक का उपयोग न करें

टीएफ-डीएफ (वर्तमान में) मॉडल चेकपॉइंटिंग का समर्थन नहीं करता है, जिसका अर्थ है कि प्रशिक्षण पूरा होने से पहले मॉडल के उपयोग योग्य होने की उम्मीद करने वाले हुक काफी हद तक असमर्थित हैं। मॉडल केवल तभी उपलब्ध होगा जब यह अनुरोधित संख्या में पेड़ों को प्रशिक्षित करेगा (या जल्दी रुक जाएगा)।

प्रशिक्षण चरण पर निर्भर केरस हुक भी काम नहीं करेंगे - टीएफ-डीएफ प्रशिक्षण की प्रकृति के कारण, मॉडल पहले युग के अंत में प्रशिक्षित होता है, और उस युग के बाद स्थिर रहेगा। चरण केवल डेटासेट I/O से मेल खाता है।

मॉडल नियतिवाद

टीएफ-डीएफ प्रशिक्षण एल्गोरिदम नियतात्मक है, यानी एक ही डेटासेट पर दो बार प्रशिक्षण बिल्कुल वही मॉडल देगा। यह 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 शिक्षण एल्गोरिदम हानि का उपयोग नहीं करते हैं। जो लोग ऐसा करते हैं, उनके लिए कार्य से हानि का स्वचालित रूप से पता लगाया जाता है और मॉडल सारांश में मुद्रित किया जाता है। आप इसे हानि हाइपर-पैरामीटर के साथ ओवरराइड भी कर सकते हैं।

हाइपर-पैरामीटर शब्दार्थ की दृष्टि से स्थिर हैं

सभी हाइपर-पैरामीटर में डिफ़ॉल्ट मान होते हैं। वे मूल्य प्रयास करने वाले पहले उम्मीदवारों के लिए उचित हैं। डिफ़ॉल्ट हाइपर-पैरामीटर मान कभी नहीं बदलने की गारंटी है। इस कारण से, नए हाइपर-पैरामीटर या एल्गोरिदम सुधार डिफ़ॉल्ट रूप से अक्षम हैं।

जो उपयोगकर्ता नवीनतम एल्गोरिदम का उपयोग करना चाहते हैं, लेकिन जो स्वयं हाइपर-पैरामीटर को अनुकूलित नहीं करना चाहते हैं, वे टीएफ-डीएफ द्वारा प्रदान किए गए "हाइपर-पैरामीटर टेम्पलेट्स" का उपयोग कर सकते हैं। पैकेज में अपडेट के साथ नए हाइपरपैरामीटर टेम्प्लेट जारी किए जाएंगे।

# 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()

मॉडल डिबगिंग

यह अनुभाग कुछ ऐसे तरीके प्रस्तुत करता है जिनसे आप मॉडल को देख/डिबग/व्याख्या कर सकते हैं। शुरुआती कोलाब में शुरू से अंत तक का उदाहरण होता है।

सरल मॉडल सारांश

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

प्रशिक्षण लॉग और टेंसरबोर्ड

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

या टेंसरबोर्ड का उपयोग करना:

% 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)

( उन्नत कोलाब देखें)

TensorFlow वितरण रणनीतियों का उपयोग न करें

टीएफ-डीएफ अभी तक टीएफ वितरण रणनीतियों का समर्थन नहीं करता है। बहु-कार्यकर्ता सेटअप को नजरअंदाज कर दिया जाएगा, और प्रशिक्षण केवल प्रबंधक पर होगा।

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

+ model = ....

स्टैकिंग मॉडल

टीएफ-डीएफ मॉडल ग्रेडिएंट्स को बैकप्रोपेगेट नहीं करते हैं। परिणामस्वरूप, उन्हें एनएन मॉडल के साथ तब तक नहीं बनाया जा सकता जब तक कि एनएन पहले से ही प्रशिक्षित न हों।

tf.estimator.BoostedTrees {Classifier/Regressor/Estimator} से माइग्रेट हो रहा है

समान लगने के बावजूद, टीएफ-डीएफ और एस्टिमेटर बूस्टेड ट्री अलग-अलग एल्गोरिदम हैं। टीएफ-डीएफ क्लासिकल रैंडम फॉरेस्ट और ग्रेडिएंट बूस्टेड मशीन (पेड़ों का उपयोग करके) पेपर्स को लागू करता है। tf.estimator.BoostedTreesEstimator इस पेपर में वर्णित एक मिनी-बैच प्रशिक्षण प्रक्रिया के साथ एक अनुमानित ग्रेडिएंट बूस्टेड ट्रीज़ एल्गोरिदम है।

कुछ हाइपर-पैरामीटरों के शब्दार्थ समान होते हैं (उदाहरण के लिए num_trees), लेकिन उनके अलग-अलग गुणवत्ता वाले निहितार्थ होते हैं। यदि आपने अपने tf.estimator.BoostedTreesEstimator पर हाइपरपैरामीटर को ट्यून किया है, तो आपको इष्टतम परिणाम प्राप्त करने के लिए TF-DF के भीतर अपने हाइपरपैरामीटर को फिर से ट्यून करना होगा।

Yggdrasil उपयोगकर्ताओं के लिए

Yggdrasil डिसीजन फ़ॉरेस्ट TF-DF द्वारा उपयोग किया जाने वाला मुख्य प्रशिक्षण और अनुमान पुस्तकालय है। प्रशिक्षण विन्यास और मॉडल क्रॉस-संगत हैं (यानी TF-DF के साथ प्रशिक्षित मॉडल का उपयोग Yggdrasil अनुमान के साथ किया जा सकता है)।

हालाँकि, कुछ Yggdrasil एल्गोरिदम TF-DF में (अभी तक) उपलब्ध नहीं हैं।

• शार्ड सैंपलिंग के साथ ग्रैडिएंट बूस्टेड ट्री।