TensorFlow के साथ रैखिक प्रतिगमन ट्यूटोरियल [उदाहरण]

रैखिक प्रतिगमन क्या है?

Linear Regression Slope सांख्यिकी में दो चरों के बीच संबंधों को मॉडलिंग करने का एक तरीका है। यह मॉडलिंग एक स्केलर प्रतिक्रिया और एक या अधिक व्याख्यात्मक चरों के बीच की जाती है। एक व्याख्यात्मक चर के साथ संबंध को सरल रेखीय प्रतिगमन कहा जाता है और एक से अधिक व्याख्यात्मक चरों के लिए, इसे बहु रैखिक प्रतिगमन कहा जाता है।

TensorFlow कम्प्यूटेशन पर पूरा नियंत्रण रखने के लिए उपकरण प्रदान करता है। यह निम्न-स्तरीय API के साथ किया जाता है। इसके अलावा, TensorFlow कई API की एक विशाल सरणी से सुसज्जित है, जो कई कार्य करने के लिए है यंत्र अधिगम एल्गोरिदम। यह उच्च-स्तरीय API है। TensorFlow इन्हें अनुमानक कहता है

• निम्न-स्तरीय API: शुरुआत से ही मॉडल का आर्किटेक्चर और ऑप्टिमाइजेशन तैयार करना। शुरुआती लोगों के लिए यह जटिल है
• उच्च स्तरीय एपीआई: एल्गोरिथ्म को परिभाषित करें। यह आसान है। TensorFlow एक टूलबॉक्स प्रदान करता है जिसे कहा जाता है क़ीमत लगानेवाला निर्माण करना, प्रशिक्षण देना, मूल्यांकन करना और भविष्यवाणी करना।

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

बोस्टन डेटासेट डाउनलोड करें

रैखिक प्रतिगमन मॉडल को कैसे प्रशिक्षित करें

मॉडल को प्रशिक्षित करने से पहले, आइए देखें कि रैखिक प्रतिगमन क्या है।

कल्पना करें कि आपके पास दो चर हैं, x और y और आपका कार्य का मान ज्ञात करके का मान पूर्वानुमान करना है। यदि आप डेटा प्लॉट करते हैं, तो आप अपने स्वतंत्र चर, x और अपने आश्रित चर y के बीच एक सकारात्मक संबंध देख सकते हैं।

आप देख सकते हैं कि यदि x=1,y तो लगभग 6 के बराबर होगा और यदि x=2,y तो लगभग 8.5 के बराबर होगा।

यह बहुत सटीक विधि नहीं है और इसमें त्रुटि होने की संभावना रहती है, विशेषकर सैकड़ों-हजारों बिंदुओं वाले डेटासेट के मामले में।

एक रेखीय प्रतिगमन का मूल्यांकन एक समीकरण द्वारा किया जाता है। चर y को एक या कई सहचरों द्वारा समझाया जाता है। आपके उदाहरण में, केवल एक आश्रित चर है। यदि आपको यह समीकरण लिखना है, तो यह होगा:

साथ में:

• पूर्वाग्रह है। यानी यदि x=0, y=
• x से संबंधित भार है
• मॉडल का अवशिष्ट या त्रुटि है। इसमें वह शामिल है जो मॉडल डेटा से नहीं सीख सकता

कल्पना कीजिए कि आप मॉडल फिट करते हैं और आपको निम्नलिखित समाधान मिलता है:

• = 3.8
• = 2.78

आप उन संख्याओं को समीकरण में प्रतिस्थापित कर सकते हैं और यह बन जाता है:

y= 3.8 + 2.78x

अब आपके पास y के मान ज्ञात करने का एक बेहतर तरीका है। यानी, आप x को किसी भी मान से बदल सकते हैं जिससे आप y का पूर्वानुमान लगा सकें। नीचे दी गई छवि में, हमने समीकरण में x को डेटासेट के सभी मानों से बदल दिया है और परिणाम को प्लॉट किया है।

लाल रेखा फिट किए गए मान को दर्शाती है, अर्थात x के प्रत्येक मान के लिए y का मान। y का अनुमान लगाने के लिए आपको x का मान देखने की आवश्यकता नहीं है, प्रत्येक x के लिए कोई न कोई मान लाल रेखा से संबंधित होता है। आप 2 से अधिक x के मानों के लिए भी अनुमान लगा सकते हैं!

यदि आप रैखिक प्रतिगमन को अधिक सहचरों तक विस्तारित करना चाहते हैं, तो आप मॉडल में अधिक चर जोड़कर ऐसा कर सकते हैं। पारंपरिक विश्लेषण और रैखिक प्रतिगमन के बीच अंतर यह है कि रैखिक प्रतिगमन यह देखता है कि y प्रत्येक चर x के लिए स्वतंत्र रूप से कैसे प्रतिक्रिया करेगा।

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

पारंपरिक विश्लेषण बिक्री का पूर्वानुमान लगाने की कोशिश करेगा, मान लीजिए कि प्रत्येक चर के लिए औसत की गणना की जाती है और विभिन्न परिदृश्यों के लिए बिक्री का अनुमान लगाने की कोशिश की जाती है। इससे खराब पूर्वानुमान निकलेंगे और विश्लेषण चुने गए परिदृश्य तक ही सीमित रहेगा।

यदि आप रैखिक प्रतिगमन का उपयोग करते हैं, तो आप यह समीकरण लिख सकते हैं:

एल्गोरिथ्म भार के लिए सर्वोत्तम समाधान ढूंढेगा; इसका अर्थ है कि यह लागत (फिट की गई रेखा और डेटा बिंदुओं के बीच का अंतर) को न्यूनतम करने का प्रयास करेगा।

एल्गोरिदम कैसे काम करता है

एल्गोरिथ्म प्रत्येक के लिए एक यादृच्छिक संख्या का चयन करेगा और और x के मान को प्रतिस्थापित करके y का पूर्वानुमानित मान प्राप्त करें। यदि डेटासेट में 100 अवलोकन हैं, तो एल्गोरिथ्म 100 पूर्वानुमानित मानों की गणना करता है।

हम त्रुटि की गणना कर सकते हैं, नोट किया गया मॉडल का, जो कि पूर्वानुमानित मूल्य और वास्तविक मूल्य के बीच का अंतर है। सकारात्मक त्रुटि का अर्थ है कि मॉडल y की भविष्यवाणी को कम करके आंकता है, और नकारात्मक त्रुटि का अर्थ है कि मॉडल y की भविष्यवाणी को अधिक करके आंकता है।

आपका लक्ष्य त्रुटि के वर्ग को न्यूनतम करना है। एल्गोरिथ्म वर्ग त्रुटि के माध्य की गणना करता है। इस चरण को त्रुटि का न्यूनतमीकरण कहा जाता है। रैखिक प्रतिगमन के लिए माध्य वर्ग त्रुटि, जिसे MSE भी कहा जाता है। गणितीय रूप से, यह है:

कहाँ:

• क्या वज़न इतना है पूर्वानुमानित मूल्य को संदर्भित करता है
• y वास्तविक मान है
• m प्रेक्षणों की संख्या है

ध्यान दें कि इसका मतलब है कि यह मैट्रिसेस के ट्रांसपोज़ का उपयोग करता है। माध्य का गणितीय संकेतन है।

लक्ष्य सर्वोत्तम खोजना है जो एमएसई को न्यूनतम करता है

यदि औसत त्रुटि बड़ी है, तो इसका मतलब है कि मॉडल खराब प्रदर्शन करता है और भार ठीक से नहीं चुना गया है। भार को सही करने के लिए, आपको एक अनुकूलक का उपयोग करने की आवश्यकता है। पारंपरिक अनुकूलक को कहा जाता है ढतला हुआ वंश.

ग्रेडिएंट डिसेंट व्युत्पन्न लेता है और भार घटाता या बढ़ाता है। यदि व्युत्पन्न सकारात्मक है, तो भार कम हो जाता है। यदि व्युत्पन्न नकारात्मक है, तो भार बढ़ जाता है। मॉडल भार को अपडेट करेगा और त्रुटि की पुनः गणना करेगा। यह प्रक्रिया तब तक दोहराई जाती है जब तक कि त्रुटि में कोई बदलाव न हो। प्रत्येक प्रक्रिया को एक कहा जाता है यात्राइसके अलावा, ग्रेडिएंट को सीखने की दर से गुणा किया जाता है। यह सीखने की गति को दर्शाता है।

यदि सीखने की दर बहुत कम है, तो एल्गोरिथ्म को अभिसरित होने में बहुत लंबा समय लगेगा (यानी बहुत सारे पुनरावृत्तियों की आवश्यकता होगी)। यदि सीखने की दर बहुत अधिक है, तो एल्गोरिथ्म कभी भी अभिसरित नहीं हो सकता है।

आप ऊपर दिए गए चित्र में देख सकते हैं कि, भार के लिए एक स्थिर मान प्राप्त करने के लिए मॉडल इस प्रक्रिया को लगभग 20 बार दोहराता है, जिससे सबसे कम त्रुटि प्राप्त होती है।

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

आपको पहला समीकरण याद है

अंतिम भार 3.8 और 2.78 हैं। नीचे दिया गया वीडियो आपको दिखाता है कि ग्रेडिएंट डिसेंट किस तरह से इस भार को खोजने के लिए लॉस फ़ंक्शन को ऑप्टिमाइज़ करता है

TensorFlow के साथ रैखिक प्रतिगमन को कैसे प्रशिक्षित करें

अब जब आपको इस बात की बेहतर समझ हो गई है कि हुड के पीछे क्या हो रहा है, तो आप TensorFlow का उपयोग करके अपने पहले रैखिक प्रतिगमन को प्रशिक्षित करने के लिए TensorFlow द्वारा प्रदान किए गए अनुमानक API का उपयोग करने के लिए तैयार हैं।

आप बोस्टन डेटासेट का उपयोग करेंगे, जिसमें निम्नलिखित चर शामिल हैं

अपराधी	शहर के अनुसार प्रति व्यक्ति अपराध दर
zn	25,000 वर्ग फुट से अधिक क्षेत्रफल वाले आवासीय भूमि का अनुपात
इंडस	प्रति शहर गैर-खुदरा व्यापार एकड़ का अनुपात।
NOx	नाइट्रिक ऑक्साइड सांद्रता
rm	प्रति आवास कमरों की औसत संख्या
उम्र	1940 से पहले निर्मित स्वामित्व वाली इकाइयों का अनुपात
जिले	बोस्टन के पांच रोजगार केंद्रों की भारित दूरियां
कर	प्रति डॉलर 10,000 पूर्ण-मूल्य संपत्ति-कर दर
अनुपात	शहर के अनुसार छात्र-शिक्षक अनुपात
मेडव	मालिक द्वारा अधिगृहित घरों का औसत मूल्य हजार डॉलर में

आप तीन अलग-अलग डेटासेट बनाएंगे:

डाटासेट	उद्देश्य	आकार
प्रशिक्षण	मॉडल को प्रशिक्षित करें और भार प्राप्त करें	400, 10
मूल्यांकन	अदृश्य डेटा पर मॉडल के प्रदर्शन का मूल्यांकन करें	100, 10
भविष्यवाणी करना	नए डेटा पर घर के मूल्य का अनुमान लगाने के लिए मॉडल का उपयोग करें	6, 10

इसका उद्देश्य डेटासेट की विशेषताओं का उपयोग करके मकान के मूल्य का अनुमान लगाना है।

ट्यूटोरियल के दूसरे भाग के दौरान, आप सीखेंगे कि डेटा आयात करने के लिए तीन अलग-अलग तरीकों से TensorFlow का उपयोग कैसे करें:

• पांडा के साथ
• - ऊँचा होना
• केवल TF

ध्यान रखें कि, सभी विकल्प समान परिणाम प्रदान करें.

आप सीखेंगे कि TensorFlow रैखिक प्रतिगमन मॉडल बनाने, प्रशिक्षित करने और मूल्यांकन करने के लिए उच्च-स्तरीय API का उपयोग कैसे करें। यदि आप निम्न-स्तरीय API का उपयोग कर रहे थे, तो आपको हाथ से परिभाषित करना होगा:

• लॉस फंकशन
• अनुकूलन: ग्रेडिएंट अवरोहण
• मैट्रिसेस गुणन
• ग्राफ और टेंसर

यह शुरुआती लोगों के लिए अधिक थकाऊ और जटिल है।

पांडा

मॉडल को प्रशिक्षित करने के लिए आपको आवश्यक लाइब्रेरीज़ आयात करने की आवश्यकता है।

import pandas as pd
from sklearn import datasets
import tensorflow as tf
import itertools

चरण 1) डेटा आयात करें पांडा.

आप कॉलम नाम परिभाषित करते हैं और इसे COLUMNS में संग्रहीत करते हैं। डेटा आयात करने के लिए आप pd.read_csv() का उपयोग कर सकते हैं।

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
           "dis", "tax", "ptratio", "medv"]

प्रशिक्षण_सेट = pd.read_csv(“E:/boston_train.csv”, skipinitialspace=True,skiprows=1, नाम=COLUMNS)

test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=True,skiprows=1, नाम=COLUMNS)

भविष्यवाणी_सेट = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=सत्य,skiprows=1, नाम=COLUMNS)

आप डेटा का आकार प्रिंट कर सकते हैं.

print(training_set.shape, test_set.shape, prediction_set.shape)

उत्पादन

(400, 10) (100, 10) (6, 10)

ध्यान दें कि लेबल, यानी आपका y, डेटासेट में शामिल है। इसलिए आपको दो अन्य सूचियाँ परिभाषित करने की आवश्यकता है। एक में केवल विशेषताएँ शामिल हैं और दूसरी में केवल लेबल का नाम है। ये दो सूचियाँ आपके अनुमानक को बताएंगी कि डेटासेट में कौन सी विशेषताएँ हैं और कौन सा कॉलम नाम लेबल है

यह नीचे दिए गए कोड के साथ किया जाता है।

FEATURES = ["crim", "zn", "indus", "nox", "rm",				
                 "age", "dis", "tax", "ptratio"]
LABEL = "medv"

चरण 2) डेटा परिवर्तित करें

आपको संख्यात्मक चर को उचित प्रारूप में परिवर्तित करने की आवश्यकता है। Tensorflow निरंतर चर को परिवर्तित करने के लिए एक विधि प्रदान करता है: tf.feature_column.numeric_column()।

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

ध्यान रखें कि आप इसका उपयोग करेंगे Python लिस्ट कॉम्प्रिहेंशन के साथ लिस्ट फीचर्स का उपयोग करके फीचर_कॉल्स नामक नई लिस्ट बनाएं। यह आपको tf.feature_column.numeric_column() को नौ बार लिखने से बचाता है। लिस्ट कॉम्प्रिहेंशन नई लिस्ट बनाने का एक तेज़ और साफ़ तरीका है

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]

चरण 3) अनुमानक को परिभाषित करें

इस चरण में, आपको अनुमानक को परिभाषित करना होगा। TensorFlow वर्तमान में 6 पूर्व-निर्मित अनुमानक प्रदान करता है, जिसमें वर्गीकरण कार्य के लिए 3 और TensorFlow प्रतिगमन कार्य के लिए 3 शामिल हैं:

• प्रतिगामी
  • डीएनएनरिग्रेसर
  • रैखिक रिग्रेसर
  • DNNLineaCombinedRegressor
• वर्गीकृत
  • डीएनएनक्लासिफायर
  • रैखिकवर्गीकरणकर्ता
  • DNNLineaCombinedClassifier

इस ट्यूटोरियल में, आप लीनियर रिग्रेसर का उपयोग करेंगे। इस फ़ंक्शन तक पहुँचने के लिए, आपको tf.estimator का उपयोग करना होगा।

फ़ंक्शन को दो तर्कों की आवश्यकता है:

• feature_columns: मॉडल में शामिल करने के लिए चर शामिल हैं
• मॉडल_निर्देशिका: ग्राफ को संग्रहीत करने, मॉडल पैरामीटर आदि को सहेजने का पथ

Tensorflow अपने आप ही आपकी वर्किंग डायरेक्टरी में train नाम की एक फ़ाइल बना देगा। Tensorboard तक पहुँचने के लिए आपको इस पथ का उपयोग करना होगा जैसा कि नीचे दिए गए TensorFlow रिग्रेशन उदाहरण में दिखाया गया है।

estimator = tf.estimator.LinearRegressor(    
        feature_columns=feature_cols,   
        model_dir="train")

उत्पादन

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

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

उदाहरण के लिए, यदि आपके डेटा में 100 अवलोकन हैं और आप 10 का बैच आकार परिभाषित करते हैं, तो इसका मतलब है कि मॉडल प्रत्येक पुनरावृत्ति (10*10) के लिए 10 अवलोकन देखेगा।

जब मॉडल सारा डेटा देख लेता है, तो वह एक कार्य पूरा कर लेता है युग. एक युग यह निर्धारित करता है कि आप मॉडल को कितनी बार डेटा दिखाना चाहते हैं। इस चरण को कोई नहीं पर सेट करना बेहतर है और मॉडल को कई बार पुनरावृत्ति करने देना चाहिए।

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

TensorFlow इन दो चरणों को आसान बनाता है। जब डेटा पाइपलाइन में जाता है, तो उसे पता होता है कि उसे कितने अवलोकनों की आवश्यकता है (बैच) और क्या उसे डेटा को शफ़ल करना है।

Tensorflow को मॉडल को कैसे फीड करना है, यह बताने के लिए आप pandas_input_fn का उपयोग कर सकते हैं। इस ऑब्जेक्ट को 5 पैरामीटर की आवश्यकता है:

• x: फ़ीचर डेटा
• y: लेबल डेटा
• बैच_साइज़: बैच. डिफ़ॉल्ट रूप से 128
• num_epoch: युगों की संख्या, डिफ़ॉल्ट रूप से 1
• शफ़ल: डेटा को शफ़ल करें या न करें। डिफ़ॉल्ट रूप से, कोई नहीं

आपको मॉडल को कई बार फीड करने की आवश्यकता है इसलिए आप इस प्रक्रिया को दोहराने के लिए एक फ़ंक्शन परिभाषित करते हैं। यह सब फ़ंक्शन get_input_fn है।

def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):    
         return tf.estimator.inputs.pandas_input_fn(       
         x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),       
         y = pd.Series(data_set[LABEL].values),       
         batch_size=n_batch,          
         num_epochs=num_epochs,       
         shuffle=shuffle)

किसी मॉडल के प्रदर्शन का मूल्यांकन करने की सामान्य विधि यह है:

• मॉडल को प्रशिक्षित करें
• मॉडल का मूल्यांकन किसी भिन्न डेटासेट में करें
• भविष्यवाणी करना

टेन्सरफ्लो अनुमानक इन तीन चरणों को आसानी से पूरा करने के लिए तीन अलग-अलग फ़ंक्शन प्रदान करता है।

चरण 4): मॉडल को प्रशिक्षित करें

आप मॉडल का मूल्यांकन करने के लिए एस्टीमेटर ट्रेन का उपयोग कर सकते हैं। ट्रेन एस्टीमेटर को input_fn और कई चरणों की आवश्यकता होती है। आप मॉडल को फीड करने के लिए ऊपर बनाए गए फ़ंक्शन का उपयोग कर सकते हैं। फिर, आप मॉडल को 1000 बार पुनरावृति करने का निर्देश देते हैं। ध्यान दें कि, आप युगों की संख्या निर्दिष्ट नहीं करते हैं, आप मॉडल को 1000 बार पुनरावृति करने देते हैं। यदि आप युगों की संख्या 1 पर सेट करते हैं, तो मॉडल 4 बार पुनरावृति करेगा: प्रशिक्षण सेट में 400 रिकॉर्ड हैं, और बैच का आकार 128 है

1. 128 पंक्तियाँ
2. 128 पंक्तियाँ
3. 128 पंक्तियाँ
4. 16 पंक्तियाँ

इसलिए, युग की संख्या को शून्य पर सेट करना और पुनरावृत्ति की संख्या को परिभाषित करना आसान है जैसा कि नीचे दिए गए TensorFlow वर्गीकरण उदाहरण में दिखाया गया है।

estimator.train(input_fn=get_input_fn(training_set,                                       
                                           num_epochs=None,                                      
                                           n_batch = 128,                                      
                                           shuffle=False),                                      
                                           steps=1000)

उत्पादन

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 238.616
INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)
INFO:tensorflow:global_step/sec: 314.293
INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)
INFO:tensorflow:global_step/sec: 303.863
INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)
INFO:tensorflow:global_step/sec: 308.782
INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)
INFO:tensorflow:global_step/sec: 244.969
INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)
INFO:tensorflow:global_step/sec: 155.966
INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)
INFO:tensorflow:global_step/sec: 263.256
INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)
INFO:tensorflow:global_step/sec: 254.112
INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)
INFO:tensorflow:global_step/sec: 292.405
INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt.
INFO:tensorflow:Loss for final step: 5925.9873.

आप निम्न आदेश द्वारा टेन्सरबोर्ड की जांच कर सकते हैं:

activate hello-tf
# For MacOS
tensorboard --logdir=./train
# For Windows
tensorboard --logdir=train

चरण 5) अपने मॉडल का मूल्यांकन करें

आप नीचे दिए गए कोड से परीक्षण सेट पर अपने मॉडल के फिट का मूल्यांकन कर सकते हैं:

ev = estimator.evaluate(    
          input_fn=get_input_fn(test_set,                          
          num_epochs=1,                          
          n_batch = 128,                          
          shuffle=False))

उत्पादन

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

आप नीचे दिए गए कोड से हानि को प्रिंट कर सकते हैं:

loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))

उत्पादन

Loss: 3215.895996

मॉडल में 3215 की हानि है। त्रुटि कितनी बड़ी है, इसका अंदाजा लगाने के लिए आप सारांश सांख्यिकी की जांच कर सकते हैं।

training_set['medv'].describe()

उत्पादन

count    400.000000
mean      22.625500
std        9.572593
min        5.000000
25%       16.600000
50%       21.400000
75%       25.025000
max       50.000000
Name: medv, dtype: float64

उपरोक्त सारांश सांख्यिकी से, आप जानते हैं कि एक घर की औसत कीमत 22 हजार है, जिसमें न्यूनतम कीमत 9 हजार और अधिकतम 50 हजार है। मॉडल 3k डॉलर की एक सामान्य त्रुटि करता है।

चरण 6) भविष्यवाणी करें

अंत में, आप 6 बोस्टन घरों के मूल्य का अनुमान लगाने के लिए TensorFlow भविष्यवाणी अनुमानक का उपयोग कर सकते हैं।

y = estimator.predict(    
         input_fn=get_input_fn(prediction_set,                          
         num_epochs=1,                          
         n_batch = 128,                          
         shuffle=False))

के अनुमानित मान मुद्रित करने के लिए, आप इस कोड का उपयोग कर सकते हैं:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

उत्पादन

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]

मॉडल ने निम्नलिखित मानों का पूर्वानुमान लगाया:

घर	पूर्वानुमान
1	32.29
2	18.96
3	27.27
4	29.29
5	16.43
7	21.46

ध्यान दें कि हम का सही मूल्य नहीं जानते हैं। डीप लर्निंग के ट्यूटोरियल में, आप रैखिक मॉडल को मात देने की कोशिश करेंगे

नम्पी समाधान

यह अनुभाग बताता है कि डेटा को फीड करने के लिए numpy अनुमानक का उपयोग करके मॉडल को कैसे प्रशिक्षित किया जाए। विधि वही है सिवाय इसके कि आप numpy_input_fn अनुमानक का उपयोग करेंगे।

प्रशिक्षण_सेट_एन = pd.read_csv(“E:/boston_train.csv”).values

test_set_n = pd.read_csv(“E:/boston_test.csv”).values

भविष्यवाणी_सेट_एन = pd.read_csv(“E:/boston_predict.csv”).values

चरण 1) डेटा आयात करें

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

def prepare_data(df):     
        X_train = df[:, :-3]    
        y_train = df[:,-3]    
        return X_train, y_train

आप प्रशिक्षण/मूल्यांकन डेटासेट की विशेषताओं से लेबल को विभाजित करने के लिए फ़ंक्शन का उपयोग कर सकते हैं

X_train, y_train = prepare_data(training_set_n)
X_test, y_test = prepare_data(test_set_n)

आपको पूर्वानुमान डेटासेट के अंतिम कॉलम को बाहर करना होगा क्योंकि इसमें केवल NaN है

x_predict = prediction_set_n[:, :-2]

सरणी के आकार की पुष्टि करें। ध्यान दें कि, लेबल में आयाम नहीं होना चाहिए, इसका मतलब है (400,)।

print(X_train.shape, y_train.shape, x_predict.shape)

उत्पादन

(400, 9) (400,) (6, 9)

आप फ़ीचर कॉलम का निर्माण निम्न प्रकार से कर सकते हैं:

feature_columns = [      tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]

अनुमानक को पहले की तरह परिभाषित किया गया है, आप फीचर कॉलम और ग्राफ को कहाँ सहेजना है, इसका निर्देश देते हैं।

estimator = tf.estimator.LinearRegressor(    
         feature_columns=feature_columns,    
         model_dir="train1")

उत्पादन

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

आप मॉडल को डेटा खिलाने और फिर मॉडल को प्रशिक्षित करने के लिए numpy अनुमान का उपयोग कर सकते हैं। ध्यान दें कि, पठनीयता को आसान बनाने के लिए हम पहले input_fn फ़ंक्शन को परिभाषित करते हैं।

# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(   
           x={"x": X_train},    
           y=y_train,    
           batch_size=128,    
           shuffle=False,    
           num_epochs=None)
           estimator.train(input_fn = train_input,steps=5000)

उत्पादन

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train1/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 490.057
INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)
INFO:tensorflow:global_step/sec: 788.986
INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)
INFO:tensorflow:global_step/sec: 736.339
INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)
INFO:tensorflow:global_step/sec: 383.305
INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)
INFO:tensorflow:global_step/sec: 859.832
INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)
INFO:tensorflow:global_step/sec: 804.394
INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)
INFO:tensorflow:global_step/sec: 753.059
INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)
INFO:tensorflow:global_step/sec: 402.165
INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)
INFO:tensorflow:global_step/sec: 344.022
INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt.
INFO:tensorflow:Loss for final step: 5925.985.
Out[23]:
<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>

आप अपने मॉडल का मूल्यांकन करने के लिए एक अलग अनुमानक के साथ उसी चरण को दोहराते हैं

eval_input = tf.estimator.inputs.numpy_input_fn(    
       x={"x": X_test},    
       y=y_test, 
       shuffle=False,    
       batch_size=128,    
       num_epochs=1)
   estimator.evaluate(eval_input,steps=None)

उत्पादन

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

अंत में, आप भविष्यवाणी की गणना कर सकते हैं। यह पांडा के समान होना चाहिए।

test_input = tf.estimator.inputs.numpy_input_fn(    
        x={"x": x_predict},    
        batch_size=128,    
        num_epochs=1,   
        shuffle=False)
        y = estimator.predict(test_input) 			
predictions = list(p["predictions"] for p in itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))

उत्पादन

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]

टेन्सरफ्लो समाधान

अंतिम खंड TensorFlow समाधान के लिए समर्पित है। यह विधि अन्य की तुलना में थोड़ी अधिक जटिल है।

ध्यान दें कि यदि आप उपयोग करते हैं Jupyter नोटबुक, आपको इस सत्र को चलाने के लिए कर्नेल को पुनः आरंभ और साफ़ करना होगा।

TensorFlow ने डेटा को पाइपलाइन में पास करने के लिए एक बेहतरीन टूल बनाया है। इस अनुभाग में, आप input_fn फ़ंक्शन को स्वयं बनाएंगे।

चरण 1) डेटा का पथ और प्रारूप परिभाषित करें

सबसे पहले, आप csv फ़ाइल के पथ के साथ दो चर घोषित करते हैं। ध्यान दें कि, आपके पास दो फ़ाइलें हैं, एक प्रशिक्षण सेट के लिए और एक परीक्षण सेट के लिए।

import tensorflow as tf

df_train = "E:/boston_train.csv"

df_eval = "E:/boston_test.csv"

फिर, आपको csv फ़ाइल से उन कॉलम को परिभाषित करना होगा जिन्हें आप उपयोग करना चाहते हैं। हम सभी का उपयोग करेंगे। उसके बाद, आपको यह घोषित करना होगा कि यह किस प्रकार का वेरिएबल है।

फ्लोट्स चर [0.] द्वारा परिभाषित किए जाते हैं

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",				
                "dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]

चरण 2) input_fn फ़ंक्शन को परिभाषित करें

इस फ़ंक्शन को तीन भागों में विभाजित किया जा सकता है:

1. डेटा आयात करें
2. इटरेटर बनाएँ
3. डेटा का उपभोग करें

नीचे फ़ंक्शन को परिभाषित करने के लिए संपूर्ण कोड दिया गया है। कोड को बाद में समझाया जाएगा

def input_fn(data_file, batch_size, num_epoch = None):				
       # Step 1				
          def parse_csv(value):        
          columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)        
          features = dict(zip(COLUMNS, columns))				
          #labels = features.pop('median_house_value')        
          labels =  features.pop('medv')        
          return features, labels							
          
          # Extract lines from input files using the 
          Dataset API.    dataset = (tf.data.TextLineDataset(data_file) # Read text file       
          .skip(1) # Skip header row       
          .map(parse_csv))			   
          
          dataset = dataset.repeat(num_epoch)    
          dataset = dataset.batch(batch_size) 				
          # Step 3    
          iterator = dataset.make_one_shot_iterator()    
          features, labels = iterator.get_next()    
          return features, labels

** डेटा आयात करें **

csv फ़ाइल के लिए, डेटासेट विधि एक बार में एक पंक्ति पढ़ती है। डेटासेट बनाने के लिए, आपको ऑब्जेक्ट का उपयोग करना होगा TextLineडेटासेट। आपके डेटासेट में एक हेडर है, इसलिए आपको पहली पंक्ति को छोड़ने के लिए skip(1) का उपयोग करना होगा। इस बिंदु पर, आप केवल डेटा पढ़ते हैं और पाइपलाइन में हेडर को बाहर करते हैं। मॉडल को फीड करने के लिए, आपको लेबल से सुविधाओं को अलग करना होगा। डेटा पर किसी भी परिवर्तन को लागू करने के लिए उपयोग की जाने वाली विधि मैप है।

यह विधि एक फ़ंक्शन को कॉल करती है जिसे आप डेटा को बदलने के निर्देश देने के लिए बनाएंगे। संक्षेप में, आपको डेटा को पास करना होगा TextLineडेटासेट ऑब्जेक्ट से हेडर को हटा दें और एक फ़ंक्शन द्वारा निर्देशित रूपांतरण लागू करें।Code स्पष्टीकरण

• tf.डेटा.TextLineडेटासेट (डेटा_फ़ाइल): यह पंक्ति csv फ़ाइल पढ़ती है
• .skip(1) : हेडर को छोड़ें
• .map(parse_csv)): रिकॉर्ड को टेंसर में पार्स करें। आपको मैप ऑब्जेक्ट को निर्देश देने के लिए एक फ़ंक्शन परिभाषित करना होगा। आप इस फ़ंक्शन को parse_csv कह सकते हैं।

यह फ़ंक्शन tf.decode_csv विधि का उपयोग करके CSV फ़ाइल को पार्स करता है और फ़ीचर्स और लेबल घोषित करता है। फ़ीचर्स को डिक्शनरी या टपल के रूप में घोषित किया जा सकता है। आप डिक्शनरी विधि का उपयोग करते हैं क्योंकि यह अधिक सुविधाजनक है।Code स्पष्टीकरण

• tf.decode_csv(value, record_defaults= RECORDS_ALL): विधि decode_csv आउटपुट का उपयोग करती है TextLineडेटासेट को csv फ़ाइल पढ़ने के लिए। रिकॉर्ड_डिफ़ॉल्ट TensorFlow को कॉलम प्रकार के बारे में निर्देश देता है।
• dict(zip(_CSV_COLUMNS, columns)): डिक्शनरी को सभी कॉलम से भरें।tracइस डेटा प्रोसेसिंग के दौरान
• features.pop('median_house_value'): फ़ीचर चर से लक्ष्य चर को बाहर निकालें और एक लेबल चर बनाएँ

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

उसके बाद, आप बैच विधि से बैच आकार को नियंत्रित कर सकते हैं। इसका मतलब है कि आप डेटासेट को बताते हैं कि आप प्रत्येक पुनरावृत्ति के लिए पाइपलाइन में कितना डेटा पास करना चाहते हैं। यदि आप एक बड़ा बैच आकार सेट करते हैं, तो मॉडल धीमा हो जाएगा।

चरण 3) इटरेटर बनाएं

अब आप दूसरे चरण के लिए तैयार हैं: डेटासेट में तत्वों को वापस करने के लिए एक इटरेटर बनाएं।

ऑपरेटर बनाने का सबसे सरल तरीका make_one_shot_iterator विधि है।

इसके बाद, आप इटरेटर से फीचर्स और लेबल बना सकते हैं।

चरण 4) डेटा का उपभोग करें

आप देख सकते हैं कि input_fn फ़ंक्शन के साथ क्या होता है। डेटा का उपभोग करने के लिए आपको सत्र में फ़ंक्शन को कॉल करना होगा। आप 1 के बराबर बैच आकार के साथ प्रयास करें।

ध्यान दें कि, यह फीचर्स को शब्दकोश में तथा लेबल को सारणी के रूप में प्रिंट करता है।

यह csv फ़ाइल की पहली पंक्ति दिखाएगा। आप इस कोड को अलग-अलग बैच आकार के साथ कई बार चलाने का प्रयास कर सकते हैं।

next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)
with tf.Session() as sess:    
     first_batch  = sess.run(next_batch)    
     print(first_batch)

उत्पादन

({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))

चरण 4) फ़ीचर कॉलम को परिभाषित करें

आपको संख्यात्मक कॉलम निम्नानुसार परिभाषित करने होंगे:

X1= tf.feature_column.numeric_column('crim')
X2= tf.feature_column.numeric_column('zn')
X3= tf.feature_column.numeric_column('indus')
X4= tf.feature_column.numeric_column('nox')
X5= tf.feature_column.numeric_column('rm')
X6= tf.feature_column.numeric_column('age')
X7= tf.feature_column.numeric_column('dis')
X8= tf.feature_column.numeric_column('tax')
X9= tf.feature_column.numeric_column('ptratio')

ध्यान दें कि आपको सभी वेरिएबल को एक बकेट में संयोजित करना होगा

base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]

चरण 5) मॉडल बनाएं

आप मॉडल को LinearRegressor अनुमानक के साथ प्रशिक्षित कर सकते हैं।

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')

उत्पादन

INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

आपको inpu_fn फ़ंक्शन में तर्क लिखने की अनुमति देने के लिए लैम्ब्डा फ़ंक्शन का उपयोग करने की आवश्यकता है। यदि आप इसका उपयोग नहीं करते हैं भेड़ का बच्चा समारोह, आप मॉडल को प्रशिक्षित नहीं कर सकते.

# Train the estimatormodel.train(steps =1000,    
          input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))

उत्पादन

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train3/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 72.5646
INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)
INFO:tensorflow:global_step/sec: 101.355
INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)
INFO:tensorflow:global_step/sec: 109.293
INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)
INFO:tensorflow:global_step/sec: 102.235
INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)
INFO:tensorflow:global_step/sec: 104.656
INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)
INFO:tensorflow:global_step/sec: 106.697
INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)
INFO:tensorflow:global_step/sec: 118.454
INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)
INFO:tensorflow:global_step/sec: 114.947
INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)
INFO:tensorflow:global_step/sec: 111.484
INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt.
INFO:tensorflow:Loss for final step: 5925.9873.
Out[8]:
<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>

आप नीचे दिए गए कोड के साथ परीक्षण सेट पर अपने मॉडल के फिट का मूल्यांकन कर सकते हैं:

results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))
for key in results:   
print("   {}, was: {}".format(key, results[key]))

उत्पादन

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896
   average_loss, was: 32.158958435058594
   loss, was: 3215.89599609375
   global_step, was: 1000

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

नीचे दिए गए कोड में, आपने प्रत्येक फीचर के मान लिखे हैं जो df_predict csv फ़ाइल में निहित हैं।

आपको एक नया input_fn फ़ंक्शन लिखना होगा क्योंकि डेटासेट में कोई लेबल नहीं है। आप डेटासेट से API from_tensor का उपयोग कर सकते हैं।

prediction_input = {				
          'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],				
          'zn': [75.0,0.0,25.0,33.0,0.0,0.0],				
          'indus': [2.95,18.10,5.13,2.18,18.10,9.90],				
          'nox': [0.428,0.713,0.453,0.472,0.700,0.544],				
          'rm': [7.024,6.297,6.762,7.236,5.390,5.782],				
          'age': [15.8,91.8,43.4,41.1,98.9,71.7],				
          'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],				
          'tax': [252,666,284,222,666,304],				
          'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]
     }
     def test_input_fn():    
     dataset = tf.data.Dataset.from_tensors(prediction_input)    
     return dataset
     
     # Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)

अंततः, आप भविष्यवाणियों को मुद्रित करते हैं।

for pred in enumerate(pred_results):    
print(pred)

उत्पादन

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
(0, {'predictions': array([32.297546], dtype=float32)})
(1, {'predictions': array([18.96125], dtype=float32)})
(2, {'predictions': array([27.270979], dtype=float32)})
(3, {'predictions': array([29.299236], dtype=float32)})
(4, {'predictions': array([16.436684], dtype=float32)})
(5, {'predictions': array([21.460876], dtype=float32)})

INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})

सारांश

किसी मॉडल को प्रशिक्षित करने के लिए आपको यह करना होगा:

• विशेषताएं परिभाषित करें: स्वतंत्र चर: X
• लेबल परिभाषित करें: आश्रित चर: y
• ट्रेन/परीक्षण सेट का निर्माण करें
• प्रारंभिक वजन परिभाषित करें
• हानि फ़ंक्शन को परिभाषित करें: MSE
• मॉडल को अनुकूलित करें: ग्रेडिएंट अवरोहण
• निर्धारित करें:
  • सीखने की दर
  • युग की संख्या
  • बैच का आकार

इस ट्यूटोरियल में, आपने सीखा कि लीनियर रिग्रेशन TensorFlow अनुमानक के लिए उच्च स्तरीय API का उपयोग कैसे करें। आपको यह परिभाषित करना होगा:

1. फ़ीचर कॉलम। यदि निरंतर है: tf.feature_column.numeric_column()। आप पाइथन सूची समझ के साथ एक सूची पॉप्युलेट कर सकते हैं
2. अनुमानक: tf.estimator.LinearRegressor(feature_columns, model_dir)
3. डेटा, बैच आकार और युग को आयात करने के लिए एक फ़ंक्शन: input_fn()

इसके बाद, आप train(), evaluate() और predict() के साथ प्रशिक्षण, मूल्यांकन और भविष्यवाणी करने के लिए तैयार हैं