फेस और amp के साथ TensorFlow रैखिक प्रतिगमन; सहभागिता शब्द

इस ट्यूटोरियल में, आप सीखेंगे कि डेटा की जाँच कैसे करें और इसे सरल रेखीय प्रतिगमन कार्य बनाने के लिए तैयार करें।

यह ट्यूटोरियल दो भागों में विभाजित है:

• बातचीत के लिए देखो
• मॉडल का परीक्षण करें

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

डेटासेट से बना है:

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

इस ट्यूटोरियल में, हम एक लीनियर रेजिस्टर का उपयोग करके औसत मूल्य का अनुमान लगाएंगे, लेकिन मशीन सीखने की एक विशेष प्रक्रिया पर ध्यान केंद्रित है: "डेटा तैयारी।"

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

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

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

व्यवसाय पर शिक्षा के सीमित प्रभाव को पकड़ने के लिए, हम एक सहभागिता शब्द का उपयोग कर सकते हैं।

यदि आप मजदूरी समीकरण को देखते हैं, तो यह बन जाता है:

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

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

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

• सारांश आँकड़े
• पहलुओं का अवलोकन करें
• दीप गोता लगाएँ
• पहलू स्थापित करें
• अवलोकन
• ग्राफ़
• दीप गोता लगाएँ
• TensorFlow
• डेटा तैयार करना
• मूल प्रतिगमन: बेंचमार्क
• मॉडल में सुधार करें: इंटरेक्शन शब्द

सारांश आँकड़े

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

पहले चरण के रूप में, डेटा को पांडा डेटाफ्रेम के रूप में लोड करें और एक प्रशिक्षण सेट और परीक्षण सेट बनाएं।

टिप्स: इस ट्यूटोरियल के लिए, आपको Python में matplotlit और seaborn स्थापित करना होगा। आप Jupyter के साथ फ्लाई पर पायथन पैकेज स्थापित कर सकते हैं। आपको ऐसा नहीं करना चाहिए

!conda install -- yes matplotlib

लेकिन अ

import sys!{sys.executable} -m pip install matplotlib # Already installed!{sys.executable} -m pip install seaborn

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

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

नीचे दिया गया कोड आवश्यक पुस्तकालयों को आयात करता है।

import pandas as pdfrom sklearn import datasetsimport tensorflow as tffrom sklearn.datasets import load_bostonimport numpy as np

लाइब्रेरी स्केलेर में बोस्टन डेटासेट शामिल हैं। डेटा आयात करने के लिए आप इसके API को कॉल कर सकते हैं।

boston = load_boston()df = pd.DataFrame(boston.data) 

फ़ीचर का नाम ऑब्जेक्ट सरणी में ऑब्जेक्ट feature_names में संग्रहीत किया जाता है।

boston.feature_names

उत्पादन

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
आप स्तंभों का नाम बदल सकते हैं।
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

आप चर CHAS को एक स्ट्रिंग चर के रूप में परिवर्तित करते हैं और यदि CHAS = 1 और नहीं तो CHAS = 0 के साथ इसे लेबल करते हैं
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
पांडा के साथ, यह डेटासेट को विभाजित करने के लिए सीधा है। आप बेतरतीब ढंग से डेटासेट को 80 प्रतिशत प्रशिक्षण सेट और 20 प्रतिशत परीक्षण सेट के साथ विभाजित करते हैं। पंडों के पास डेटा फ्रेम के नमूने को विभाजित करने के लिए एक अंतर्निहित लागत फ़ंक्शन है।


पहला पैरामीटर फ़्रेक 0 से 1 तक का मान है। आपने इसे डेटा फ्रेम के बेतरतीब ढंग से 80 प्रतिशत का चयन करने के लिए 0.8 पर सेट किया है।
Random_state सभी के लिए समान डेटाफ़्रेम वापस करने की अनुमति देता है।
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
आप डेटा का आकार प्राप्त कर सकते हैं। यह होना चाहिए:

ट्रेन सेट: 506 * 0.8 = 405
टेस्ट सेट: 506 * 0.2 = 101

print(df_train.shape, df_test.shape)
उत्पादन 
(405, 14) (101, 14) 
 
df_test.head(5)
उत्पादन
 

 
 
 
 
CRIM 
 
ZN 
 
सिंधु 
 
चास 
 
NOX 
 
आर एम 
 
उम्र 
 
जिले 
 
रेड 
 
कर 
 
PTRATIO 
 
ख 
 
LSTAT 
 
कीमत 
 

 
 
० 
 
0.00632 है 
 
18.0 
 
२.३१ 
 
नहीं न 
 
0.538 है 
 
6.575 है 
 
65.2 
 
4.0900 है 
 
1.0 
 
296.0 
 
15.3 
 
396.90 है 
 
4.98 
 
24.0 
 

 
 
1 
 
0.02731 है 
 
0.0 
 
7.07 है 
 
नहीं न 
 
0.469 है 
 
6.421 है 
 
78.9 है 
 
4.9671 है 
 
2.0 
 
242.0 
 
17.8 
 
396.90 है 
 
9.14 
 
21.6 
 

 
 
३ 
 
0.03237 है 
 
0.0 
 
२.१18 
 
नहीं न 
 
0.458 
 
6.998 
 
45.8 
 
6.0622 है 
 
3.0 
 
222.0 
 
18.7 
 
394.63 है 
 
२.९ ​​४ 
 
33.4 
 

 
 
६ 
 
0.08829 
 
12.5 
 
7.87 
 
नहीं न 
 
0.524 है 
 
6.012 
 
66.6 
 
5.5605 है 
 
५.० 
 
311.0 
 
15.2 
 
395.60 है 
 
12.43 
 
22.9 है 
 

 
 
। 
 
0.14455 है 
 
12.5 
 
7.87 
 
नहीं न 
 
0.524 है 
 
6.172 है 
 
96.1 
 
5.9505 है 
 
५.० 
 
311.0 
 
15.2 
 
396.90 है 
 
19.15 है 
 
27.1 
 

 

 

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

पहलुओं का अवलोकन करें


दीप गोता लगाएँ


पहलुओं का अवलोकन करें
पहलुओं का अवलोकन डेटासेट का अवलोकन देता है। पहलू अवलोकन डेटा की स्तंभों को खारी जानकारी दिखाने वाली पंक्तियों में विभाजित करता है

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

यह किसी भी मशीन सीखने के कार्य से पहले करने के लिए कम से कम न्यूनतम है। इस उपकरण के साथ, आप इस महत्वपूर्ण कदम को याद नहीं करते हैं, और यह कुछ असामान्यताओं को उजागर करता है।

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

पहलू स्थापित करें
आप अधिकांश विश्लेषण के लिए Facet web ऐप का उपयोग कर सकते हैं। इस ट्यूटोरियल में, आप देखेंगे कि इसे ज्यूपिटर नोटबुक के भीतर कैसे उपयोग किया जाए।
सबसे पहले, आपको nbextensions को स्थापित करने की आवश्यकता है। यह इस कोड के साथ किया जाता है। आप अपनी मशीन के टर्मिनल में निम्नलिखित कोड को कॉपी और पेस्ट करें।
pip install jupyter_contrib_nbextensions 
ठीक इसके बाद, आपको अपने कंप्यूटर में रिपॉजिटरी को क्लोन करना होगा। आपके पास दो विकल्प हैं:
विकल्प 1) इस कोड को टर्मिनल में कॉपी और पेस्ट करें (अनुशंसित)
यदि आपके पास अपनी मशीन पर Git स्थापित नहीं है, तो कृपया इस URL https://git-scm.com/download/win पर जाएं और निर्देश का पालन करें। एक बार जब आप कर लेते हैं, तो आप मैक उपयोगकर्ता या एनाकोंडा प्रॉम्प्ट के लिए विंडोज उपयोगकर्ता के लिए टर्मिनल में गिट कमांड का उपयोग कर सकते हैं
git clone https://github.com/PAIR-code/facets 
विकल्प 2) https://github.com/PAIR-code/facets पर जाएं और रिपॉजिटरी डाउनलोड करें।

यदि आप पहला विकल्प चुनते हैं, तो फ़ाइल आपकी डाउनलोड फ़ाइल में समाप्त होती है। आप फ़ाइल को डाउनलोड करने दे सकते हैं या उसे किसी अन्य पथ पर ले जा सकते हैं।
आप यह जांच सकते हैं कि इस आदेश पंक्ति के साथ पहलू कहाँ संग्रहीत हैं:
echo `pwd`/`ls facets` 
अब जब आपने Facets स्थित कर लिया है, तो आपको इसे Jupyter नोटबुक में स्थापित करने की आवश्यकता है। आपको कार्य निर्देशिका को उस पथ पर सेट करने की आवश्यकता है जहां पहलू स्थित है।
आपका वर्तमान कार्य निर्देशिका और पहलू ज़िप का स्थान समान होना चाहिए।

आपको कार्यशील निर्देशिका को पहलू की ओर इंगित करने की आवश्यकता है:
cd facets
Jupyter में Facets स्थापित करने के लिए, आपके पास दो विकल्प हैं। यदि आपने सभी उपयोगकर्ताओं के लिए कॉनडा के साथ जुपिटर स्थापित किया है, तो इस कोड को कॉपी करें:
उपयोग कर सकते हैं ज्यूपिटर नेक्स्टेंशन स्थापित करें
jupyter nbextension install facets-dist/
अन्यथा, उपयोग करें:
jupyter nbextension install facets-dist/ --user
बिलकुल ठीक, आप सब सेट हैं। आइए खुलते हैं पहलू अवलोकन।

अवलोकन
अवलोकन आँकड़ों की गणना करने के लिए पायथन लिपि का उपयोग करता है। आपको जेपीटर को जेनेरिक_फेट्योर_स्टैटिस्टिक्स_गेंनेटर नामक स्क्रिप्ट आयात करने की आवश्यकता है। चिंता मत करो; स्क्रिप्ट पहलुओं फ़ाइलों में स्थित है।
आपको इसके रास्ते का पता लगाने की जरूरत है। यह आसानी से हो जाता है। आप पहलू खोलते हैं, फ़ाइल facets_overview खोलते हैं और फिर अजगर। रास्ते की नकल करो

उसके बाद, जुपिटर पर वापस जाएं, और निम्नलिखित कोड लिखें। पथ '/ उपयोगकर्ता / थॉमस / पहलुओं / facets_overview / अजगर' को अपने पथ में बदलें।
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
आप नीचे दिए गए कोड के साथ स्क्रिप्ट आयात कर सकते हैं।
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
खिड़कियों में, एक ही कोड बन जाता है
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
सुविधा आँकड़ों की गणना करने के लिए, आपको फ़ंक्शन GenericFeatureStatisticsGenerator () का उपयोग करने की आवश्यकता है, और आप ऑब्जेक्ट ProtoFromDataFrames का उपयोग करते हैं। आप एक शब्दकोश में डेटा फ़्रेम पास कर सकते हैं। उदाहरण के लिए, यदि हम ट्रेन सेट के लिए एक सारांश आँकड़ा बनाना चाहते हैं, तो हम सूचना को शब्दकोश में संग्रहीत कर सकते हैं और इसका उपयोग कर सकते हैं।


'name': 'train', 'table': df_train 

नाम तालिका प्रदर्शित करने का नाम है, और आप उस तालिका के नाम का उपयोग करते हैं जिसे आप सारांश की गणना करना चाहते हैं। आपके उदाहरण में, डेटा युक्त तालिका df_train है
# Calculate the feature statistics proto from the datasets and stringify it for use in facets overviewimport base64gfsg = GenericFeatureStatisticsGenerator()proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train},{'name': 'test', 'table': df_test}])#proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train}])protostr = base64.b64encode(proto.SerializeToString()).decode("utf-8")
अंत में, आप बस नीचे दिए गए कोड को कॉपी और पेस्ट करें। कोड सीधे GitHub से आता है। आपको यह देखने में सक्षम होना चाहिए:

# Display the facets overview visualization for this data# Displfrom IPython.core.display import display, HTMLHTML_TEMPLATE = """
"""html = HTML_TEMPLATE.format(protostr=protostr)display(HTML(html))
 
ग्राफ़
आपके द्वारा डेटा और उनके वितरण की जांच करने के बाद, आप एक सहसंबंध मैट्रिक्स की साजिश कर सकते हैं। सहसंबंध मैट्रिक्स Pearson गुणांक की गणना करता है। यह गुणांक -1 और 1 के बीच बंधुआ है, जिसका सकारात्मक मान सकारात्मक सहसंबंध और ऋणात्मक मान ऋणात्मक सहसंबंध इंगित करता है।
आप यह देखने के लिए इच्छुक हैं कि कौन से चर बातचीत की शर्तों के लिए एक अच्छे उम्मीदवार हो सकते हैं।
## Choose important feature and further check with Dive%matplotlib inlineimport matplotlib.pyplot as pltimport seaborn as snssns.set(style="ticks")# Compute the correlation matrixcorr = df.corr('pearson')# Generate a mask for the upper trianglemask = np.zeros_like(corr, dtype=np.bool)mask[np.triu_indices_from(mask)] = True# Set up the matplotlib figuref, ax = plt.subplots(figsize=(11, 9))# Generate a custom diverging colormapcmap = sns.diverging_palette(220, 10, as_cmap=True)# Draw the heatmap with the mask and correct aspect ratiosns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,annot=True,square=True, linewidths=.5, cbar_kws={"shrink": .5})
उत्पादन 

पींग

मैट्रिक्स से, आप देख सकते हैं:

LSTAT
आर एम

PRICE के साथ दृढ़ता से सहसंबद्ध हैं। एक और रोमांचक विशेषता NOX और INDUS के बीच मजबूत सकारात्मक सहसंबंध है, जिसका अर्थ है कि दो चर एक ही दिशा में चलते हैं। इसके अलावा, PRICE के साथ भी सहसंबद्ध हैं। DIS भी IND और NOX के साथ अत्यधिक सहसंबद्ध है।
आपके पास कुछ पहले संकेत हैं कि IND और NOX इंटरसेप्ट टर्म के लिए अच्छे उम्मीदवार हो सकते हैं और DIS पर भी ध्यान केंद्रित करना दिलचस्प हो सकता है।
आप एक जोड़ी ग्रिड की साजिश रचकर थोड़ा गहराई में जा सकते हैं। यह आपके द्वारा पहले दिए गए सहसंबंध मानचित्र के बारे में विस्तार से वर्णन करेगा।
जोड़ी ग्रिड हम निम्नलिखित के रूप में बना रहे हैं:

ऊपरी हिस्सा: फिट लाइन के साथ स्कैटर प्लॉट
विकर्ण: कर्नेल घनत्व प्लॉट
निचला भाग: बहुभिन्नरूपी कर्नेल घनत्व प्लॉट

आप चार स्वतंत्र चर पर ध्यान केंद्रित करते हैं। पसंद PRICE के साथ मजबूत सहसंबंध के साथ चर से मेल खाती है

सिंधु
NOX
आर एम
LSTAT

इसके अलावा, मूल्य।
ध्यान दें कि मानक त्रुटि डिफ़ॉल्ट रूप से स्कैटर प्लॉट में जोड़ी जाती है।
attributes = ["PRICE", "INDUS", "NOX", "RM", "LSTAT"]g = sns.PairGrid(df[attributes])g = g.map_upper(sns.regplot, color="g")g = g.map_lower(sns.kdeplot,cmap="Reds", shade=True, shade_lowest=False)g = g.map_diag(sns.kdeplot)
उत्पादन 

चलो ऊपरी भाग से शुरू करते हैं:

मूल्य INDUS, NOX और LSTAT के साथ नकारात्मक रूप से सहसंबद्ध है; आरएम के साथ सकारात्मक रूप से सहसंबद्ध।
LSTAT और PRICE के साथ थोड़ी गैर-रैखिकता है
मूल्य के 50 के बराबर होने पर एक सीधी रेखा की तरह होता है। डेटासेट के विवरण से, PRICE को 50 के मान पर काट दिया गया है

विकर्ण

एनओएक्स में दो क्लस्टर हैं, एक 0.5 के आसपास और एक 0.85 के आसपास है।

इसके बारे में अधिक जांचने के लिए, आप निचले हिस्से को देख सकते हैं। बहुभिन्नरूपी कर्नेल घनत्व एक मायने में दिलचस्प है यह रंग जहां अधिकांश बिंदु हैं। तितर बितर भूखंड के साथ अंतर एक संभावना घनत्व खींचता है, भले ही किसी दिए गए समन्वय के लिए डाटासेट में कोई मतलब नहीं है। जब रंग अधिक मजबूत होता है, तो यह इस क्षेत्र के चारों ओर बिंदु के उच्च सांद्रता को इंगित करता है।
यदि आप INDUS और NOX के लिए बहुभिन्नरूपी घनत्व की जांच करते हैं, तो आप सकारात्मक सहसंबंध और दो समूहों को देख सकते हैं। जब उद्योग का हिस्सा 18 से ऊपर है, नाइट्रिक ऑक्साइड सांद्रता 0.6 से ऊपर है।
आप रैखिक संबंध में INDUS और NOX के बीच बातचीत जोड़ने के बारे में सोच सकते हैं।
अंत में, आप Google द्वारा बनाए गए दूसरे टूल, फेस डीप डाइव का उपयोग कर सकते हैं। इंटरफ़ेस को चार मुख्य वर्गों में विभाजित किया गया है। केंद्र में केंद्रीय क्षेत्र डेटा का ज़ूम करने योग्य प्रदर्शन है। पैनल के शीर्ष पर, ड्रॉप-डाउन मेनू है जहां आप मुखरता, स्थिति और रंग को नियंत्रित करने के लिए डेटा की व्यवस्था को बदल सकते हैं। दाईं ओर, डेटा की एक विशिष्ट पंक्ति का एक विस्तृत दृश्य है। इसका मतलब है कि आप उस विशेष डेटा बिंदु के बारे में विस्तार से देखने के लिए केंद्र विज़ुअलाइज़ेशन के किसी भी बिंदु पर क्लिक कर सकते हैं।
डेटा विज़ुअलाइज़ेशन चरण के दौरान, आप घर की कीमत पर स्वतंत्र चर के बीच युग्मक सहसंबंध की तलाश में रुचि रखते हैं। हालांकि, इसमें कम से कम तीन चर शामिल हैं, और 3 डी भूखंडों के साथ काम करने के लिए जटिल है।
इस समस्या से निपटने का एक तरीका यह है कि एक श्रेणीगत चर बनाया जाए। यही है, हम एक 2 डी प्लॉट का रंग डॉट बना सकते हैं। आप चर मूल्य को चार श्रेणियों में विभाजित कर सकते हैं, प्रत्येक श्रेणी एक चतुर्थक है (यानी, 0.25, 0.5, 0.75)। आप इस नए चर Q_PRICE को कहते हैं।
## Check non linearity with important featuresdf['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])## Show non linearity between RM and LSTATax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")


दीप गोता लगाएँ
डीप डाइव खोलने के लिए, आपको डेटा को एक जेनसन फॉर्मेट में बदलना होगा। उसके लिए एक वस्तु के रूप में पंडों। आप पंडों के डेटासेट के बाद tojj का उपयोग कर सकते हैं।
कोड की पहली पंक्ति डेटासेट के आकार को संभालती है।
df['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])sprite_size = 32 if len(df.index)>50000 else 64jsonstr = df.to_json(orient='records')
नीचे दिया गया कोड Google GitHub से आता है। कोड चलाने के बाद, आपको यह देखने में सक्षम होना चाहिए:

# Display thde Dive visualization for this datafrom IPython.core.display import display, HTML# Create Facets templateHTML_TEMPLATE = """
"""# Load the json dataset and the sprite_size into the templatehtml = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)# Display the templatedisplay(HTML(html))
आपको यह देखने के लिए दिलचस्पी है कि क्या उद्योग दर, ऑक्साइड एकाग्रता, नौकरी केंद्र की दूरी और घर की कीमत के बीच कोई संबंध है।
उसके लिए, आप पहले मूल्य सीमा के साथ उद्योग रेंज और रंग द्वारा डेटा को विभाजित करते हैं:

फेसिंग एक्स चुनें और INDUS चुनें।
डिस्प्ले का चयन करें और DIS चुनें। यह घर की कीमत के चतुर्थक के साथ डॉट्स को रंग देगा

यहां, गहरे रंगों का मतलब है कि पहले जॉब सेंटर की दूरी दूर है।
अब तक, यह फिर से दिखाता है कि आप क्या जानते हैं, कम उद्योग दर, उच्च कीमत। अब आप NOX द्वारा INDUX द्वारा ब्रेकडाउन को देख सकते हैं।

फेसिंग Y चुनें और NOX चुनें।

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

TensorFlow
इस खंड में, आप TensorFlow अनुमानकों एपीआई के साथ रैखिक क्लासिफायरफ़ाइल का अनुमान लगाएंगे। आप निम्नानुसार आगे बढ़ेंगे:

डेटा तैयार करें
एक बेंचमार्क मॉडल का अनुमान लगाएं: कोई इंटरैक्शन नहीं
बातचीत के साथ एक मॉडल का अनुमान लगाएं

याद रखें, मशीन लर्निंग का लक्ष्य त्रुटि को कम करना है। इस मामले में, सबसे कम औसत चुकता त्रुटि वाला मॉडल जीत जाएगा। TensorFlow अनुमानक स्वचालित रूप से इस मीट्रिक की गणना करता है।
डेटा तैयार करना
अधिकांश मामलों में, आपको अपना डेटा बदलने की आवश्यकता है। यही कारण है कि पहलू अवलोकन आकर्षक है। सारांश सांख्यिकीय से, आपने देखा कि वहाँ आउटलेयर हैं। वे मान अनुमानों को प्रभावित करते हैं क्योंकि वे उस जनसंख्या की तरह नहीं दिखते हैं जिसका आप विश्लेषण कर रहे हैं। बाहरी लोगों ने आमतौर पर परिणामों को पक्षपाती किया। उदाहरण के लिए, एक सकारात्मक रूपरेखा गुणांक से आगे निकल जाती है।
इस समस्या से निपटने के लिए एक अच्छा समाधान चर को मानकीकृत करना है। मानकीकरण का अर्थ है, एक का मानक विचलन और शून्य का साधन। मानकीकरण की प्रक्रिया में दो चरण शामिल हैं। सबसे पहले, यह चर के औसत मूल्य को घटाता है। दूसरे, यह विचरण से विभाजित होता है ताकि वितरण में एक इकाई विचरण हो
लाइब्रेरी स्केलेर चर को मानकीकृत करने में सहायक है। आप इस उद्देश्य के लिए ऑब्जेक्ट स्केल के साथ प्रीप्रोसेसिंग मॉड्यूल का उपयोग कर सकते हैं।
आप डेटासेट को स्केल करने के लिए नीचे दिए गए फ़ंक्शन का उपयोग कर सकते हैं। ध्यान दें कि आप लेबल कॉलम और श्रेणीबद्ध चर स्केल नहीं करते हैं।
from sklearn import preprocessingdef standardize_data(df):X_scaled = preprocessing.scale(df[['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']])X_scaled_df = pd.DataFrame(X_scaled, columns = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'])df_scale = pd.concat([X_scaled_df,df['CHAS'],df['PRICE']],axis=1, join='inner')return df_scale
आप स्केल्ड ट्रेन / टेस्ट सेट के निर्माण के लिए फ़ंक्शन का उपयोग कर सकते हैं।
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
मूल प्रतिगमन: बेंचमार्क
सबसे पहले, आप बातचीत के बिना एक मॉडल को प्रशिक्षित और परीक्षण करते हैं। इसका उद्देश्य मॉडल के प्रदर्शन मीट्रिक को देखना है।
मॉडल को प्रशिक्षित करने का तरीका उच्च-स्तरीय एपीआई पर ट्यूटोरियल के समान है । आप TensorFlow अनुमानक LinearRegressor का उपयोग करेंगे।
एक अनुस्मारक के रूप में, आपको चुनने की आवश्यकता है:

मॉडल में डालने के लिए सुविधाएँ
सुविधाओं को बदलना
रैखिक रेजिस्टर का निर्माण
input_fn फ़ंक्शन का निर्माण करें
मॉडल को प्रशिक्षित करें
मॉडल का परीक्षण करें

आप मॉडल को प्रशिक्षित करने के लिए डाटासेट में सभी चर का उपयोग करते हैं। कुल में, ग्यारह निरंतर चर और एक श्रेणीगत चर हैं
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
आप सुविधाओं को एक संख्यात्मक कॉलम या श्रेणीबद्ध कॉलम में परिवर्तित करते हैं
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]#categorical_features = tf.feature_column.categorical_column_with_hash_bucket(CATE_FEATURES, hash_bucket_size=1000)categorical_features = [tf.feature_column.categorical_column_with_vocabulary_list('CHAS', ['yes','no'])]
आप linearRegressor के साथ मॉडल बनाते हैं। आप मॉडल को फ़ोल्डर ट्रेन_Boston में संग्रहीत करते हैं
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
उत्पादन 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston', '_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}
ट्रेन या परीक्षण डेटा के प्रत्येक कॉलम को फ़ंक्शन get_input_fn के साथ टेन्सर में परिवर्तित किया जाता है
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT', 'CHAS']LABEL= 'PRICE'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)
आप ट्रेन के आंकड़ों पर मॉडल का अनुमान लगाते हैं।
model.train(input_fn=get_input_fn(df_train_scale,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_Boston/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 144.457INFO:tensorflow:loss = 76982.734, step = 101 (0.697 sec)INFO:tensorflow:global_step/sec: 258.392INFO:tensorflow:loss = 21246.334, step = 201 (0.383 sec)INFO:tensorflow:global_step/sec: 227.998INFO:tensorflow:loss = 30534.78, step = 301 (0.439 sec)INFO:tensorflow:global_step/sec: 210.739INFO:tensorflow:loss = 36794.5, step = 401 (0.477 sec)INFO:tensorflow:global_step/sec: 234.237INFO:tensorflow:loss = 8562.981, step = 501 (0.425 sec)INFO:tensorflow:global_step/sec: 238.1INFO:tensorflow:loss = 34465.08, step = 601 (0.420 sec)INFO:tensorflow:global_step/sec: 237.934INFO:tensorflow:loss = 12241.709, step = 701 (0.420 sec)INFO:tensorflow:global_step/sec: 220.687INFO:tensorflow:loss = 11019.228, step = 801 (0.453 sec)INFO:tensorflow:global_step/sec: 232.702INFO:tensorflow:loss = 24049.678, step = 901 (0.432 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston/model.ckpt.INFO:tensorflow:Loss for final step: 23228.568.
अंत में, आप परीक्षण सेट पर मॉडल के प्रदर्शन का अनुमान लगाते हैं
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
उत्पादन 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:40:43INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:40:43INFO:tensorflow:Saving dict for global step 1000: average_loss = 86.89361, global_step = 1000, loss = 1650.9785{'average_loss': 86.89361, 'global_step': 1000, 'loss': 1650.9785}
मॉडल का नुकसान 1650 है। यह अगले भाग में हरा देने वाला मीट्रिक है

मॉडल में सुधार करें: इंटरेक्शन शब्द
ट्यूटोरियल के पहले भाग के दौरान, आपने चर के बीच एक दिलचस्प संबंध देखा। विभिन्न विज़ुअलाइज़ेशन तकनीकों से पता चला कि INDUS और NOS एक साथ जुड़े हुए हैं और कीमत पर प्रभाव को बढ़ाने के लिए बदल जाते हैं। केवल INDUS और NOS के बीच की बातचीत कीमत को प्रभावित नहीं करती है, बल्कि DIS के साथ इंटरैक्ट करने पर यह प्रभाव और मजबूत होता है।
यह इस विचार को सामान्य बनाने और यह देखने का समय है कि क्या आप मॉडल की भविष्यवाणी की गई मॉडल में सुधार कर सकते हैं।
आपको प्रत्येक डेटासेट सेट पर दो नए कॉलम जोड़ने होंगे: ट्रेन + परीक्षण। उसके लिए, आप इंटरैक्शन शब्द की गणना करने के लिए एक फ़ंक्शन बनाते हैं और ट्रिपल इंटरेक्शन शब्द की गणना करने के लिए एक और एक फ़ंक्शन बनाते हैं। प्रत्येक फ़ंक्शन एक एकल स्तंभ बनाता है। नए चर बनाए जाने के बाद, आप उन्हें प्रशिक्षण डेटासेट और परीक्षण डेटासेट में भेज सकते हैं।
सबसे पहले, आपको INDUS और NOX के बीच बातचीत के लिए एक नया चर बनाने की आवश्यकता है।
नीचे दिया गया फ़ंक्शन आपके डेटा INDUS और NOX में var_1 और var_2 के बीच की सहभागिता के साथ दो डेटाफ़्रेम, ट्रेन और परीक्षण देता है।
def interaction_term(var_1, var_2, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]test = t_test.rename(name)return train, test
आप दो नए कॉलम संग्रहीत करते हैं
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
दूसरे, आप ट्रिपल इंटरैक्शन शब्द की गणना करने के लिए एक दूसरा फ़ंक्शन बनाते हैं।
def triple_interaction_term(var_1, var_2,var_3, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]*df_train_scale[var_3]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]*df_test_scale[var_3]test = t_test.rename(name)return train, testinteration_ind_ns_dis_train, interation_ind_ns_dis_test= triple_interaction_term('INDUS', 'NOX', 'DIS','INDUS_NOS_DIS')
अब जब आपके पास आवश्यक सभी कॉलम हैं, तो आप उन्हें प्रशिक्षित करने और डाटासेट का परीक्षण करने के लिए जोड़ सकते हैं। आप इन दो नए डेटाफ़्रेम को नाम देते हैं:

df_train_new
df_test_new

df_train_new = pd.concat([df_train_scale,interation_ind_ns_train,interation_ind_ns_dis_train],axis=1, join='inner')df_test_new = pd.concat([df_test_scale,interation_ind_ns_test,interation_ind_ns_dis_test],axis=1, join='inner')df_train_new.head(5)
उत्पादन 

यही वह है; आप इंटरैक्शन शर्तों के साथ नए मॉडल का अनुमान लगा सकते हैं और देख सकते हैं कि प्रदर्शन मीट्रिक कैसा है।
CONTI_FEATURES_NEW = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS']### Define categorical listcontinuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]model = tf.estimator.LinearRegressor(model_dir="train_Boston_1",feature_columns= categorical_features + continuous_features_new)
उत्पादन 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston_1', '_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}
कोड
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS','CHAS']LABEL= 'PRICE'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)
 
model.train(input_fn=get_input_fn(df_train_new,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_Boston_1/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 124.844INFO:tensorflow:loss = 65522.3, step = 101 (0.803 sec)INFO:tensorflow:global_step/sec: 182.704INFO:tensorflow:loss = 15384.148, step = 201 (0.549 sec)INFO:tensorflow:global_step/sec: 208.189INFO:tensorflow:loss = 22020.305, step = 301 (0.482 sec)INFO:tensorflow:global_step/sec: 213.855INFO:tensorflow:loss = 28208.812, step = 401 (0.468 sec)INFO:tensorflow:global_step/sec: 209.758INFO:tensorflow:loss = 7606.877, step = 501 (0.473 sec)INFO:tensorflow:global_step/sec: 196.618INFO:tensorflow:loss = 26679.76, step = 601 (0.514 sec)INFO:tensorflow:global_step/sec: 196.472INFO:tensorflow:loss = 11377.163, step = 701 (0.504 sec)INFO:tensorflow:global_step/sec: 172.82INFO:tensorflow:loss = 8592.07, step = 801 (0.578 sec)INFO:tensorflow:global_step/sec: 168.916INFO:tensorflow:loss = 19878.56, step = 901 (0.592 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston_1/model.ckpt.INFO:tensorflow:Loss for final step: 19598.387.
 
model.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
उत्पादन 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:41:14INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston_1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:41:14INFO:tensorflow:Saving dict for global step 1000: average_loss = 79.78876, global_step = 1000, loss = 1515.9863{'average_loss': 79.78876, 'global_step': 1000, 'loss': 1515.9863}
नया नुकसान 1515 है। बस दो नए चर जोड़कर, आप नुकसान को कम करने में सक्षम थे। इसका मतलब है कि आप बेंचमार्क मॉडल की तुलना में बेहतर भविष्यवाणी कर सकते हैं।