यूएस हाउस मूल्य भविष्यवाणी

Yu Esa Ha Usa Mulya Bhavisyavani



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

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







वापसी

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



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



1. रेखीय प्रतिगमन

रैखिक प्रतिगमन एल्गोरिथ्म आश्रित विशेषता (Y) और स्वतंत्र विशेषता (X) चर के बीच एक रैखिक संबंध दिखाता है। गणितीय रूप से, हम इसका मूल्यांकन इस प्रकार कर सकते हैं:





और = एएक्स+बी

यहाँ, 'ए' और 'बी' रैखिक गुणांक हैं।

पायथन में, LinearRegression() 'sklearn.linear_model' मॉड्यूल में उपलब्ध है। हम देखेंगे कि परियोजना को लागू करते समय इसे कैसे निर्दिष्ट किया जाए। निम्नलिखित पैरामीटर वाला मॉडल है:



2. निर्णय वृक्ष

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

पायथन में, DecisionTreeRegressor 'sklearn.tree' मॉड्यूल में उपलब्ध है। हम देखेंगे कि परियोजना को लागू करते समय इसे कैसे निर्दिष्ट किया जाए। निम्नलिखित पैरामीटर वाला मॉडल है:

3. यादृच्छिक वन

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

पायथन में, RandomForestRegressor 'sklearn.ensemble' मॉड्यूल में उपलब्ध है। निम्नलिखित पैरामीटर वाला मॉडल है। हम 'n_estimator' पैरामीटर में पेड़ों की संख्या निर्दिष्ट कर सकते हैं। यह डिफ़ॉल्ट रूप से 100 है.

कार्यान्वयन

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

1. ट्रेन और टेस्ट डेटासेट लोड करना

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

सबसे पहले, हमें अपने स्थानीय पीसी से Colab Env में फ़ाइलें लोड करनी होंगी। यहां से डेटासेट डाउनलोड करें यहाँ .

# अपने Google Colab में housings_train.csv और house_test.csv फ़ाइलें अपलोड करें

# एक के बाद एक।

से गूगल। और अन्य आयात फ़ाइलें

फ़ाइलें. डालना ( )

read_csv() वह फ़ंक्शन है जिसका उपयोग CSV डेटा को एक वेरिएबल में लोड करने के लिए किया जाता है। यह फ़ाइल नाम को पैरामीटर के रूप में लेता है।

आयात पांडा

# घरों_ट्रेन.सीएसवी को ट्रेन_डेटा वेरिएबल में लोड करें

ट्रेन_डेटा = पांडा. read_csv ( 'houses_train.csv' )

# house_test.csv को test_data वेरिएबल में लोड करें

परीक्षण डेटा = पांडा. read_csv ( 'हाउस_टेस्ट.सीएसवी' )

# test_data को test_data1 वेरिएबल में संग्रहीत करें

test_data1 = परीक्षण डेटा

आइए प्रत्येक कॉलम में कॉलम और गैर-शून्य रिकॉर्ड की संख्या देखें। यह जानकारी प्राप्त करने के लिए Pandas.DataFrame.info() का उपयोग किया जाता है।

छपाई ( ट्रेन_डेटा. जानकारी ( ) )

छपाई ( test_data1. जानकारी ( ) )

आउटपुट:

2. डेटा प्रीप्रोसेसिंग

दोनों डेटासेट में, 'लॉट_साइज़' कॉलम वर्गफुट और एकड़ के साथ मान रखता है (आप 'लॉट_साइज़_यूनिट' कॉलम में पंक्तियों को देखकर भिन्नता पाएंगे)। लेकिन फॉर्मेट sqft में होना चाहिए. इसलिए, हमें 'lot_size' कॉलम में मानों को एकड़ से वर्गफुट में बदलने की आवश्यकता है। इसी तरह, यह 'test_data1' के लिए भी किया जाना है।

DataFrame.loc[] का उपयोग यहां 'lot_size_units' को 'एकड़' के साथ खोजने और 'lot_size' में मौजूद मान को 43560 से गुणा करने के लिए किया जाता है।

# ट्रेन_डेटा में लॉट_साइज एकड़ मान को वर्ग फुट में बदलें

ट्रेन_डेटा. जगह [ ( ट्रेन_डेटा [ 'lot_size_units' ] == 'एकड़' ) , 'बड़ा आकार' ] = ट्रेन_डेटा [ 'बड़ा आकार' ] * 43560

# test_data1 में लॉट_साइज एकड़ मान को वर्ग फुट में बदलें

test_data1. जगह [ ( test_data1 [ 'lot_size_units' ] == 'एकड़' ) , 'बड़ा आकार' ] = test_data1 [ 'बड़ा आकार' ] * 43560

छपाई ( ट्रेन_डेटा. सिर ( ) )

छपाई ( test_data1. सिर ( ) )

आउटपुट:

अब, आप देखेंगे कि 'लॉट_साइज़' कॉलम में सभी मान वर्गफुट मान हैं।

आपको इस कॉलम में कुछ लुप्त मान दिखाई देते हैं। आइए कॉलम में मौजूद NaN मानों को दोनों डेटासेट में समान कॉलम के माध्य से बदलें।

DataFrame['column_name'].fillna() का उपयोग माध्य() फ़ंक्शन का उपयोग करके लुप्त मानों को माध्य से भरने के लिए किया जाता है। DataFrame['column_name'].mean() को finna() फ़ंक्शन के पैरामीटर के रूप में पास किया जाता है। आइए अब माध्य प्रदर्शित करें और गिनती देखें:

# लॉट_साइज़ कॉलम में मौजूद लुप्त मानों को मौजूदा मानों के माध्य से भरें

ट्रेन_डेटा [ 'बड़ा आकार' ] = ट्रेन_डेटा [ 'बड़ा आकार' ] . अनुभव करना ( ट्रेन_डेटा [ 'बड़ा आकार' ] . अर्थ ( ) )

# प्रदर्शन माध्य

छपाई ( 'ट्रेन डेटा माध्य मान:' , ट्रेन_डेटा [ 'बड़ा आकार' ] . अर्थ ( ) )

छपाई ( केवल ( ट्रेन_डेटा [ 'बड़ा आकार' ] ) )

# लॉट_साइज़ कॉलम में मौजूद लुप्त मानों को मौजूदा मानों के माध्य से भरें

test_data1 [ 'बड़ा आकार' ] = test_data1 [ 'बड़ा आकार' ] . अनुभव करना ( test_data1 [ 'बड़ा आकार' ] . अर्थ ( ) )

# प्रदर्शन माध्य

छपाई ( 'परीक्षण डेटा माध्य मान:' , test_data1 [ 'बड़ा आकार' ] . अर्थ ( ) )

छपाई ( केवल ( test_data1 [ 'बड़ा आकार' ] ) )

आउटपुट:

'लॉट_साइज़' कॉलम ट्रेन डेटासेट में मौजूद गायब मानों को 18789.95194 के औसत मान से बदल दिया जाता है और 'लॉट_साइज़' कॉलम टेस्ट डेटासेट में मौजूद लापता मानों को 8961.0 के औसत मान से बदल दिया जाता है।

3. डेटा सफ़ाई

मॉडल को प्रशिक्षित करते समय, कुछ अनावश्यक विशेषताएँ होती हैं जिनकी परिणाम की भविष्यवाणी करने के लिए आवश्यकता नहीं होती है। हमारे मामले में, तीन विशेषताएँ हैं जो 'lot_size_units', 'zip_code', और 'size_units' हैं जिन्हें दोनों डेटासेट से हटाया जाना है। Pandas.DataFrame.drop() का उपयोग दोनों डेटासेट से इन तीन कॉलमों को हटाने के लिए किया जाता है।

ट्रेन_डेटा = ट्रेन_डेटा. बूँद ( [ 'lot_size_units' , 'ज़िप कोड' , 'आकार_इकाइयाँ' ] , एक्सिस = 1 )

test_data1 = test_data1. बूँद ( [ 'lot_size_units' , 'ज़िप कोड' , 'आकार_इकाइयाँ' ] , एक्सिस = 1 )

छपाई ( ट्रेन_डेटा. जानकारी ( ) )

छपाई ( test_data1. जानकारी ( ) )

आउटपुट:

अब, डेटासेट अच्छी स्थिति में हैं। अनावश्यक कॉलम हटा दिए जाते हैं और लुप्त मान मौजूद नहीं होते हैं।

4. डेटा विज़ुअलाइज़ेशन

आइए ट्रेन डेटा के कॉलम के लिए एक हिस्टोग्राम बनाएं। Pandas.DataFrame.hist() फ़ंक्शन का उपयोग सभी विशेषताओं के लिए हिस्टोग्राम उत्पन्न करने के लिए किया जाता है।

ट्रेन_डेटा. इतिहास ( अंजीर का आकार = ( 4 , 9 ) )

आउटपुट:

ट्रेन डेटा के लिए बिस्तरों, स्नानघरों, आकार, लॉट_आकार और मूल्य कॉलम के लिए हिस्टोग्राम तैयार किया जाता है।

आइए एक-दूसरे के संबंध में सभी क्षेत्रों के लिए सहसंबंध बनाएं। Plotly.express मॉड्यूल का उपयोग सहसंबद्ध मानों को प्लॉट करने के लिए किया जाता है।

आयात षडयंत्रपूर्वक। अभिव्यक्त करना

ठीक है = ट्रेन_डेटा. ठीक है ( )

# सहसंबद्ध डेटा प्लॉट करें

दृश्य_अंजीर = षडयंत्रपूर्वक। अभिव्यक्त करना . imshow ( ठीक है , text_auto = सत्य )

# प्रदर्शन

दृश्य_अंजीर. दिखाओ ( )

आउटपुट:

  1. बिस्तर 0.2935 मूल्य के साथ सहसंबद्ध हैं, -0.059 लॉट_आकार के साथ सहसंबद्ध हैं, 0.77 आकार के साथ सहसंबद्ध हैं, और 0.65 स्नान के साथ सहसंबद्ध हैं।
  2. स्नानगृह कीमत के साथ 0.3173 सहसंबद्ध हैं, -0.054 लॉट आकार के साथ सहसंबद्ध हैं, 0.667 स्नानगृह के साथ सहसंबद्ध हैं, और 0.771 बिस्तरों के साथ सहसंबद्ध हैं।
  3. आकार 0.444 कीमत के साथ सहसंबद्ध है, -0.044 लॉट_आकार के साथ सहसंबद्ध है, 0.667 आकार के साथ सहसंबद्ध है, और 0.652 बिस्तरों के साथ सहसंबद्ध है।

5. मॉडल तैयार करना

हमें कीमत को ट्रेन_डेटा से हटाकर लक्ष्य के रूप में निर्धारित करने की आवश्यकता है। सुनिश्चित करें कि ट्रेन और टेस्ट डेटा में मौजूद विशेषताएँ इस चरण में समान होनी चाहिए।

लक्ष्य = ट्रेन_डेटा [ 'कीमत' ]

ट्रेन_डेटा = ट्रेन_डेटा. बूँद ( [ 'कीमत' ] , एक्सिस = 1 )

छपाई ( ट्रेन_डेटा. जानकारी ( ) )

छपाई ( test_data1. जानकारी ( ) )

आउटपुट:

अब, चार स्वतंत्र विशेषताएँ हैं (बिस्तर, स्नानघर, आकार, और लॉट_साइज़) और कीमत निर्भर विशेषता है जो इन चार विशेषताओं पर निर्भर करती है।

6. मॉडल का प्रशिक्षण

सबसे पहले, हम RandomForestRegressor एल्गोरिथम लागू करते हैं। इसे “sklearn.ensemble” पैकेज से आयात करें। यह एक संयोजन तकनीक है.

  1. RandomForestRegressor() से एक मॉडल बनाएं। हम इस मॉडल के लिए कोई पैरामीटर नहीं दे रहे हैं। इसलिए, निर्णय वृक्षों की संख्या डिफ़ॉल्ट रूप से 100 है।
  2. मॉडल को फिट करने के लिए फिट() विधि का उपयोग करें। इसमें दो पैरामीटर लगते हैं. पहला पैरामीटर आश्रित विशेषताएँ है और दूसरा पैरामीटर क्लास लेबल/लक्ष्य है।
  3. मॉडल सटीकता देखने के लिए स्कोर() विधि का उपयोग करें। यह भी फिट() विधि के समान समान पैरामीटर लेता है।
से सीखा कलाकारों की टुकड़ी आयात RandomForestRegressor

# मॉडल को परिभाषित करें

मॉडल1 = RandomForestRegressor ( )

# मॉडल फिट करें

मॉडल1. उपयुक्त ( ट्रेन_डेटा , लक्ष्य )

# मॉडल सटीकता

छपाई ( मॉडल1. अंक ( ट्रेन_डेटा , लक्ष्य ) * 100 )

आउटपुट:

86.08400889419033

7. मॉडल का परीक्षण करें और परिणाम संग्रहीत करें

यह अंतिम चरण है जहां हमें परिणाम की भविष्यवाणी करने और उन्हें संग्रहीत करने की आवश्यकता है।

  1. परीक्षण डेटा की भविष्यवाणी करने के लिए पूर्वानुमान () विधि का उपयोग किया जाता है। इसका उपयोग मॉडल के साथ किया जाता है और मानों/डेटाफ़्रेम की नेस्टेड सूची लेता है।
  2. परिणामों को CSV फ़ाइल में संग्रहीत करने के लिए to_csv() विधि का उपयोग करें।
  3. फ़ाइल को Python परिवेश (Google Colab) से डाउनलोड करें।
# मॉडल1 के साथ test_data1 की भविष्यवाणी करें।

परीक्षण डेटा [ 'कीमत' ] = मॉडल1. भविष्यवाणी करना ( test_data1 )

# test_data को test_results.csv पर सेव करें

परीक्षण डेटा। to_csv ( 'test_results.csv' )

# इस फ़ाइल को Colab से डाउनलोड करें

फ़ाइलें. डाउनलोड करना ( 'test_results.csv' )

आउटपुट:

आइए 505 रिकॉर्ड्स में से 20 रिकॉर्ड दिखाएं। आप देख सकते हैं कि मूल्य कॉलम प्रत्येक घर के लिए अनुमानित मान रखता है।

अन्य मॉडल

आइए DecisionTreeRegressor का उपयोग करके घरों की भविष्यवाणी करें। आप इसे 'sklearn.tree' मॉड्यूल से आयात करने में सक्षम हैं।

से सीखा पेड़ आयात DecisionTreeRegressor

# मॉडल को परिभाषित करें

मॉडल2 = DecisionTreeRegressor ( )

# मॉडल फिट करें

मॉडल2. उपयुक्त ( ट्रेन_डेटा , लक्ष्य )

# मॉडल सटीकता

छपाई ( मॉडल2. अंक ( ट्रेन_डेटा , लक्ष्य ) * 100 )

# मॉडल1 के साथ test_data1 की भविष्यवाणी करें।

परीक्षण डेटा [ 'कीमत' ] = मॉडल2. भविष्यवाणी करना ( test_data1 )

# test_data को test_results.csv पर सेव करें

परीक्षण डेटा। to_csv ( 'test_results.csv' )

# इस फ़ाइल को Colab से डाउनलोड करें

फ़ाइलें. डाउनलोड करना ( 'test_results.csv' )

आउटपुट:

99.94183165335028

आप अनुमानित परिणाम यहां देख सकते हैं:

आइए LinearrEgression का उपयोग करके घरों की भविष्यवाणी करें। मॉडल को 'sklearn.linear_model' मॉड्यूल से आयात करें।

से सीखा रैखिक_मॉडल आयात रेखीय प्रतिगमन

# मॉडल को परिभाषित करें

मॉडल3 = रेखीय प्रतिगमन ( )

# मॉडल फिट करें

मॉडल3. उपयुक्त ( ट्रेन_डेटा , लक्ष्य )

# मॉडल1 के साथ test_data1 की भविष्यवाणी करें।

परीक्षण डेटा [ 'कीमत' ] = मॉडल3. भविष्यवाणी करना ( test_data1 )

# test_data को test_results.csv पर सेव करें

परीक्षण डेटा। to_csv ( 'test_results.csv' )

# इस फ़ाइल को Colab से डाउनलोड करें

फ़ाइलें. डाउनलोड करना ( 'test_results.csv' )

आप अनुमानित परिणाम यहां देख सकते हैं:

निष्कर्ष

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