TensorFlow (उदाहरण) के साथ रैखिक प्रतिगमन

विषय - सूची:

Anonim

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

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

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

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

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

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

इस TensorFlow प्रतिगमन ट्यूटोरियल में, आप सीखेंगे:

  • रैखिक प्रतिगमन क्या है?
  • एक रेखीय प्रतिगमन मॉडल को कैसे प्रशिक्षित किया जाए
  • TensorFlow के साथ एक रैखिक प्रतिगमन को कैसे प्रशिक्षित किया जाए
  • पांडा
  • Numpy Solution
  • Tensorflow solution

एक रेखीय प्रतिगमन मॉडल को कैसे प्रशिक्षित किया जाए

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

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

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

यह एक बहुत ही सटीक तरीका नहीं है और त्रुटि के लिए प्रवृत्त होता है, विशेष रूप से सैकड़ों अंकों के साथ एक डेटासेट के साथ।

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

साथ में:

  • वजन x से संबंधित है
  • मॉडल का अवशिष्ट या त्रुटि है। इसमें वह शामिल है जो मॉडल डेटा से नहीं सीख सकता है

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

  • = 3.8
  • = 2.78

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

y = 3.8 + 2.78x

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

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

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

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

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

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

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

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

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

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

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

कहा पे:

  • अनुमानित मूल्य को संदर्भित करता है
  • y वास्तविक मूल्य है
  • मी टिप्पणियों की संख्या है

ध्यान दें कि मतलब की गणितीय संकेतन है।

लक्ष्य सबसे अच्छा है कि एमएसई को कम से कम मिल जाए

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • पंडों के साथ
  • Numpy के साथ
  • केवल टीएफ

ध्यान दें, सभी विकल्प समान परिणाम प्रदान करते हैं।

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

  • लॉस फंकशन
  • ऑप्टिमाइज़ करें: ग्रेडिएंट डिसेंट
  • मैट्रिस गुणा
  • ग्राफ और टेंसर

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

पांडा

आपको मॉडल को प्रशिक्षित करने के लिए आवश्यक पुस्तकालयों को आयात करना होगा।

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

चरण 1) पांडा के साथ डेटा आयात करें।

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

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

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

prediction_set = pd.read_csv ("E: /boston_predict.csv", Skipinitialspace = True, 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 ()।

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

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

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

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

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

  • प्रतिगामी
    • DNNRegressor
    • लीनियरराइजर
    • DNNLineaCombinedRegressor
  • वर्गीकरणकर्ता
    • DNNClassifier
    • रैखिकक्लासीफायर
    • DNNLineaCombinedClassifier

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

फ़ंक्शन को दो तर्क चाहिए:

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

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

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': , '_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)

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

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

Tensorflow आकलनकर्ता इस तीन चरणों को आसानी से पूरा करने के लिए तीन अलग-अलग कार्य प्रदान करता है।

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

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

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

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

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 = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO: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.

आप Tensorboard निम्नलिखित कमांड की जाँच कर सकते हैं:

activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --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:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO: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.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: 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-1000INFO: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 है

२

18.96 है

३

27.27

४

29.29 है

५

16.43

।

21.46 है

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

Numpy Solution

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

training_set_n = pd.read_csv ("E: /boston_train.csv"। मान)

test_set_n = pd.read_csv ("E: /boston_test.csv"। मान)

prediction_set_n = pd.read_csv ("E: /boston_predict.vv") मान।

चरण 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': , '_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}

आप मॉडल को डेटा खिलाने के लिए और फिर मॉडल को प्रशिक्षित करने के लिए सुन्न अनुमान का उपयोग कर सकते हैं। ध्यान दें कि, पठनीयता को कम करने के लिए हम पहले 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 = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO: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]:

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

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:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[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-1000INFO: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 solution

अंतिम खंड एक 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 1def 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 theDataset 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 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels

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

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

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

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

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

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

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

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

चरण 3) पुनरावृत्त बनाएँ

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

ऑपरेटर बनाने का सबसे सरल तरीका मेक_ऑन_शॉट_टरेटर विधि है।

उसके बाद, आप इट्रेटर से सुविधाओं और लेबल बना सकते हैं।

चरण 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': , '_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 = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO: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]:

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

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:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_step, was: 1000

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

नीचे दिए गए कोड में, आपने df_predict csv फ़ाइल में निहित प्रत्येक सुविधाओं के मूल्यों को लिखा था।

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

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-1000INFO: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)})

सारांश

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

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

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

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

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