पायथन और स्किकिट-लर्न के साथ रैंडम फ़ॉरेस्ट एल्गोरिथम के लिए निश्चित गाइड

परिचय

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

यदि आप इनसे परिचित नहीं हैं - तो चिंता न करें, हम इन सभी अवधारणाओं को कवर करेंगे।

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

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

एक कम्प्यूटेशनल संरचना है जो ठीक यही करती है, यह है पेड़ संरचना। वृक्ष संरचना का उपयोग करके, आप प्रत्येक श्रेणी के लिए विभिन्न प्रभागों का प्रतिनिधित्व करने में सक्षम होंगे।

निर्णय के पेड़

आप पेड़ के नोड्स को कैसे पॉप्युलेट करते हैं? यह कहाँ है निर्णय के पेड़ ध्यान में आना।

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

नीचे, पेड़ का एक उदाहरण दिया गया है जिसका वर्णन किया गया है:

पेड़ की छवि में, 7 वर्ग हैं, शीर्ष पर एक जो कुल 100 महिलाओं के लिए है, यह शीर्ष वर्ग नीचे दो वर्गों से जुड़ा हुआ है, जो महिलाओं को 78 गैर गर्भवती और 22 गर्भवती महिलाओं की संख्या के आधार पर विभाजित करता है, और पिछले दोनों वर्गों से चार वर्ग हैं; ऊपर प्रत्येक वर्ग से दो जुड़े हुए हैं जो महिलाओं को उनके क्षेत्र के आधार पर विभाजित करते हैं, गर्भवती नहीं होने के लिए, 45 शहरी क्षेत्र में, 33 ग्रामीण क्षेत्र में और गर्भवती के लिए, 14 ग्रामीण क्षेत्र में और 8 शहरी क्षेत्र में रहते हैं। बस एक पेड़ को देखकर, उन विभाजनों को समझना आसान है और देखें कि कैसे प्रत्येक "परत" पिछले वाले से ली गई है, वे परतें पेड़ हैं स्तर, स्तरों का वर्णन करता है गहराई पेड़ का:

ऊपर की छवि में देखें कि पहला वृक्ष स्तर है स्तर 0 जहां केवल एक वर्ग है, उसके बाद स्तर 1 जहां दो वर्ग हैं, और स्तर 2 जहां चार वर्ग हैं। यह है एक गहराई २८४ पेड़.

स्तर 0 में वह वर्ग है जो पेड़ की उत्पत्ति करता है, पहले वाला, जिसे कहा जाता है रूट नोड, इस जड़ के दो हैं बच्चा नोड्स स्तर 1 में, अर्थात् पैरेंट नोड्स स्तर 2 में चार नोड्स के लिए। देखें कि जिन "स्क्वायर" का हम अब तक उल्लेख कर रहे हैं, वे वास्तव में कहलाते हैं नोड्स; और यह कि प्रत्येक पिछला नोड निम्नलिखित नोड्स का जनक है, जो उसके बच्चे हैं। प्रत्येक स्तर के बच्चे के नोड जिनके माता-पिता समान हैं, कहलाते हैं भाई बहन, जैसा कि अगली छवि में देखा जा सकता है:

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

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

ऊपर की छवि को देखकर, हम देख सकते हैं कि प्रत्येक ट्री नोड के प्रश्नों के उत्तर - "क्या वह एक प्रतिभागी है?", "क्या वह गर्भवती है?", "क्या वह ग्रामीण क्षेत्र में रहती है?"- हाँ हैं, हाँ, और हाँ, तो ऐसा लगता है कि पेड़ इस मामले में एक निर्णय ले सकता है, कि महिला अनुसंधान में भाग ले सकती है।

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

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

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

अब जब हम समझते हैं कि निर्णय वृक्ष क्या है, इसका उपयोग कैसे किया जा सकता है, और इसका वर्णन करने के लिए किस नामकरण का उपयोग किया जाता है, तो हम इसकी सीमाओं के बारे में सोच सकते हैं।

यादृच्छिक वनों को समझना

यदि कुछ प्रतिभागी शहरी और ग्रामीण क्षेत्रों के बीच विभाजन पर रहते हैं तो निर्णय का क्या होता है? क्या पेड़ इस रिकॉर्ड को ग्रामीण या शहरी में जोड़ देगा? इस डेटा को वर्तमान में हमारे पास मौजूद संरचना में फिट करना कठिन लगता है, क्योंकि यह काफी स्पष्ट है।

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

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

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

प्रारंभिक प्रश्न के उत्तर के बारे में, हम पहले से ही जानते हैं कि यह पेड़ के पत्तों में कूटबद्ध होगा - लेकिन जब हमारे पास एक के बजाय कई पेड़ होते हैं तो क्या बदल जाता है?

यदि वृक्षों को एक वर्गीकरण के लिए संयोजित किया जाता है, तो परिणाम अधिकांश उत्तरों द्वारा परिभाषित किया जाएगा, इसे कहते हैं बहुमत मतदान; और प्रतिगमन की स्थिति में, वन में प्रत्येक वृक्ष द्वारा दी गई संख्या होगी औसतन.

पहनावा सीखना और मॉडल पहनावा

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

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

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

व्यापक पैमाने पर उपयोग को देखते हुए, स्किकिट-लर्न जैसे पुस्तकालयों ने RandomForestRegressors और RandomForestClassifiers, अपने स्वयं के निर्णय वृक्ष कार्यान्वयन के शीर्ष पर निर्मित, शोधकर्ताओं को अपने स्वयं के पहनावा बनाने से बचने की अनुमति देने के लिए।

चलो बेतरतीब जंगलों में गोता लगाएँ!

रैंडम फ़ॉरेस्ट एल्गोरिथम कैसे काम करता है?

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

1. कई यादृच्छिक रिकॉर्ड चुनें, यह कोई भी संख्या हो सकती है, जैसे कि 4, 20, 76, 150, या यहां तक ​​कि 2.000 डेटासेट से (कहा जाता है) N रिकॉर्ड)। संख्या डेटासेट की चौड़ाई पर निर्भर करेगी, व्यापक, बड़ा N हो सकता है। यह वह जगह है जहां बिना सोचे समझे एल्गोरिथम के नाम में हिस्सा आता है!
2. उनके आधार पर एक निर्णय वृक्ष बनाएँ N यादृच्छिक रिकॉर्ड;
3. एल्गोरिथ्म के लिए परिभाषित पेड़ों की संख्या, या जंगल में पेड़ों की संख्या के अनुसार, चरण 1 और 2 को दोहराएं। यह यादृच्छिक डेटा रिकॉर्ड के सेट से अधिक पेड़ उत्पन्न करता है;
4. चरण 3 के बाद, अंतिम चरण आता है, जो परिणामों की भविष्यवाणी कर रहा है:
   • वर्गीकरण के मामले में: वन में प्रत्येक पेड़ उस श्रेणी की भविष्यवाणी करेगा जिससे नया रिकॉर्ड संबंधित है। उसके बाद, नया रिकॉर्ड उस श्रेणी को सौंपा जाता है जो बहुमत वोट जीतती है।
   • प्रतिगमन के मामले में: जंगल में प्रत्येक पेड़ नए रिकॉर्ड के लिए एक मूल्य की भविष्यवाणी करता है, और अंतिम भविष्यवाणी मूल्य की गणना जंगल में सभी पेड़ों द्वारा अनुमानित सभी मूल्यों का औसत लेकर की जाएगी।

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

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

स्किकिट-लर्न के साथ यादृच्छिक वन मॉडल का निर्माण और प्रशिक्षण

अब तक उपयोग किए गए उदाहरणों में गर्भावस्था, रहने का क्षेत्र और महिलाओं को शामिल करने का एक कारण था।

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

एकत्र किए गए डेटा को तब कॉमा-सेपरेटेड-वैल्यू (सीएसवी) फ़ाइल में व्यवस्थित किया गया था और अपलोड किया गया था यूसीआई की मशीन लर्निंग रिपॉजिटरी.

यह वह डेटा है जिसका हम अभ्यास करने के लिए उपयोग करेंगे और यह समझने की कोशिश करेंगे कि गर्भवती महिला के पास ए कम, मध्यम or उच्च मृत्यु दर का जोखिम।

वर्गीकरण के लिए रैंडम फ़ॉरेस्ट का उपयोग करना

चूंकि हम जानना चाहते हैं कि क्या महिला के पास है कम, मध्यम or उच्च मृत्यु दर का जोखिम, इसका मतलब है कि हम तीन वर्गों के साथ एक वर्गीकरण करेंगे। जब किसी समस्या में दो से अधिक वर्ग होते हैं, तो उसे कहा जाता है बहुरंगी समस्या, एक के विपरीत बाइनरी समस्या (जहां आप दो वर्गों के बीच चुनते हैं, आमतौर पर 0 और 1).

इस पहले उदाहरण में, हम एक रैंडम फ़ॉरेस्ट क्लासिफायरियर और पायथन के स्किकिट-लर्न के साथ एक मल्टीक्लास वर्गीकरण मॉडल लागू करेंगे।

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

पुस्तकालयों का आयात करना

हम डेटा को पढ़ने के लिए पंडों का उपयोग करेंगे, इसकी कल्पना करने के लिए सीबॉर्न और माटप्लोटलिब, और महान उपयोगिता विधियों के लिए NumPy:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

डेटासेट आयात करना

निम्न कोड डेटासेट आयात करता है और इसे एक पायथन में लोड करता है DataFrame:

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

डेटा की पहली पांच पंक्तियों को देखने के लिए, हम निष्पादित करते हैं head() आदेश:

dataset.head()

यह आउटपुट:

    Age SystolicBP  DiastolicBP BS      BodyTemp    HeartRate   RiskLevel
0   25  130         80          15.0    98.0        86          high risk
1   35  140         90          13.0    98.0        70          high risk
2   29  90          70          8.0     100.0       80          high risk
3   30  140         85          7.0     98.0        70          high risk
4   35  120         60          6.1     98.0        76          low risk

यहां हम शोध के दौरान एकत्र की गई सभी विशेषताओं को देख सकते हैं।

• उम्र: साल में उम्र।
• सिस्टोलिक बीपी: एमएमएचजी में रक्तचाप का ऊपरी मूल्य, गर्भावस्था के दौरान एक महत्वपूर्ण विशेषता।
• डायस्टोलिक बीपी: एमएमएचजी में रक्तचाप का कम मूल्य, गर्भावस्था के दौरान एक और महत्वपूर्ण विशेषता।
• बीएस: दाढ़ एकाग्रता, mmol / L के संदर्भ में रक्त शर्करा का स्तर।
• हृदय गति: प्रति मिनट धड़कनों में आराम करने वाली हृदय गति।
• जोखिम स्तर: गर्भावस्था के दौरान जोखिम स्तर।
• बॉडी टेम्प: शरीर का तापमान।

अब जब हम इस बारे में अधिक समझ गए हैं कि क्या मापा जा रहा है, हम डेटा के प्रकारों को देख सकते हैं info():

dataset.info()

इसका परिणाम यह होगा:

RangeIndex: 1014 entries, 0 to 1013
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   Age          1014 non-null   int64  
 1   SystolicBP   1014 non-null   int64  
 2   DiastolicBP  1014 non-null   int64  
 3   BS           1014 non-null   float64
 4   BodyTemp     1014 non-null   float64
 5   HeartRate    1014 non-null   int64  
 6   RiskLevel    1014 non-null   object 
dtypes: float64(2), int64(4), object(1)
memory usage: 55.6+ KB

देखने से RangeIndex लाइन, हम देख सकते हैं कि 1014 रिकॉर्ड और कॉलम हैं Non-Null Count सूचित करता है कि डेटा में कोई गुम मान नहीं है। इसका मतलब है, हमें लापता डेटा के लिए कोई उपचार करने की आवश्यकता नहीं होगी!

में Dtype स्तंभ, हम प्रत्येक चर के प्रकार को देख सकते हैं। वर्तमान में, float64 कॉलम जैसे BS और BodyTemp संख्यात्मक मान हैं जो किसी भी सीमा में भिन्न हो सकते हैं, जैसे कि 15.0, 15.51, 15.76, 17.28, जिससे वे संख्यात्मक रूप से निरंतर (आप हमेशा फ्लोटिंग पॉइंट नंबर, विज्ञापन अनंत में 0 जोड़ सकते हैं)। दूसरी ओर, चर जैसे Age, SystolicBP, DiastolicBP, तथा HeartRate प्रकार के हैं int64, इसका अर्थ है कि संख्याएँ केवल इकाई के अनुसार बदलती हैं, जैसे कि 11, 12, 13, 14 - हमारी हृदय गति 77.78 नहीं होगी, यह या तो 77 या 78 है - ये हैं संख्यात्मक रूप से असतत मान। और हमारे पास भी है RiskLevel पंजीकरण शुल्क object प्रकार, यह आमतौर पर इंगित करता है कि चर एक पाठ है, और हमें संभवतः इसे एक संख्या में बदलने की आवश्यकता होगी। चूंकि जोखिम का स्तर निम्न से उच्च की ओर बढ़ता है, इसलिए श्रेणियों में एक निहित क्रम होता है, यह इंगित करता है कि यह एक है स्पष्ट रूप से क्रमिक चर।

डेटा प्रकारों को देखने के बाद, हम उपयोग कर सकते हैं describe() कुछ वर्णनात्मक आँकड़ों पर एक चोटी लेने के लिए, जैसे प्रत्येक स्तंभ के माध्य मान, मानक विचलन, मात्राएँ, न्यूनतम और अधिकतम डेटा मान:

dataset.describe().T 

उपरोक्त कोड प्रदर्शित करता है:

            count   mean        std         min     25%     50%     75%     max
Age         1014.0  29.871795   13.474386   10.0    19.0    26.0    39.0    70.0
SystolicBP  1014.0  113.198225  18.403913   70.0    100.0   120.0   120.0   160.0
DiastolicBP 1014.0  76.460552   13.885796   49.0    65.0    80.0    90.0    100.0
BS          1014.0  8.725986    3.293532    6.0     6.9     7.5     8.0     19.0
BodyTemp    1014.0  98.665089   1.371384    98.0    98.0    98.0    98.0    103.0
HeartRate   1014.0  74.301775   8.088702    7.0     70.0    76.0    80.0    90.0
RiskLevel   1014.0  0.867850    0.807353    0.0     0.0     1.0     2.0     2.0

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

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

इस मामले में, डेटा प्रीप्रोसेसिंग में हम जो कदम उठा सकते हैं, वह श्रेणीबद्ध को बदलना है RiskLevel एक संख्यात्मक एक में स्तंभ।

डेटा विज़ुअलाइज़ करना

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

g = sns.pairplot(dataset, hue='RiskLevel')
g.fig.suptitle("Scatterplot and histogram of pairs of variables color coded by risk level", 
               fontsize = 14, 
               y=1.05); 

उपरोक्त कोड उत्पन्न करता है:

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

बुनियादी खोजपूर्ण डेटा विश्लेषण के साथ, हम प्रीप्रोसेस कर सकते हैं RiskLevel स्तंभ.

वर्गीकरण के लिए डेटा प्रीप्रोसेसिंग

सुनिश्चित करने के लिए केवल तीन वर्ग हैं RiskLevel हमारे डेटा में, और कोई अन्य मान गलत तरीके से नहीं जोड़ा गया है, हम इसका उपयोग कर सकते हैं unique() स्तंभ के अद्वितीय मान प्रदर्शित करने के लिए:

dataset['RiskLevel'].unique()

यह आउटपुट:

array(['high risk', 'low risk', 'mid risk'], dtype=object)

कक्षाओं की जाँच की जाती है, अब अगला चरण प्रत्येक मान को एक संख्या में बदलना है। चूंकि वर्गीकरणों के बीच एक क्रम है, हम 0, 1 और 2 के मूल्यों का उपयोग कर सकते हैं कम, मध्यम और उच्च जोखिम। पायथन के बाद कॉलम मान बदलने के कई तरीके हैं सरल बेहतर है कि जटिल आदर्श वाक्य, हम प्रयोग करेंगे .replace() विधि, और बस उन्हें उनके पूर्णांक अभ्यावेदन के साथ बदलें:

dataset['RiskLevel'] = dataset['RiskLevel'].replace('low risk', 0).replace('mid risk', 1).replace('high risk', 2)

मूल्यों को बदलने के बाद, हम डेटा को मॉडल के प्रशिक्षण के लिए उपयोग किए जाने वाले डेटा में विभाजित कर सकते हैं विशेषताएं or X, और हम क्या भविष्यवाणी करना चाहते हैं लेबलों or y:

y = dataset['RiskLevel']
X = dataset.drop(['RiskLevel'], axis=1)

एक बार X और y सेट तैयार हैं, हम स्किकिट-लर्न का उपयोग कर सकते हैं train_test_split() उन्हें ट्रेन और टेस्ट सेट में विभाजित करने की विधि:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

यहां, हम परीक्षण के लिए 20% डेटा और प्रशिक्षण के लिए 80% का उपयोग कर रहे हैं।

रैंडम फ़ॉरेस्ट क्लासिफायर का प्रशिक्षण

स्किकिट-लर्न के तहत लागू किया गया पहनावा sklearn.ensemble मापांक। वर्गीकरण के लिए उपयोग किए जाने वाले निर्णय वृक्षों का एक समूह, जिसमें बहुमत वोट लिया जाता है, के रूप में कार्यान्वित किया जाता है RandomForestClassifier.

ट्रेन और परीक्षण सेट होने के बाद, हम आयात कर सकते हैं RandomForestClassifier वर्ग और मॉडल बनाएँ। शुरू करने के लिए, सेटिंग करके तीन पेड़ों वाला एक जंगल बनाएं n_estimators पैरामीटर 3 के रूप में, और प्रत्येक पेड़ के साथ सेटिंग करके तीन स्तर होते हैं max_depth2 तक:

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=3, 
                             max_depth=2,
                             random_state=SEED)

मॉडल को डेटा के आसपास फिट करने के लिए - हम कहते हैं fit() विधि, प्रशिक्षण सुविधाओं और लेबल में पासिंग:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

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

मॉडल में थोड़ी गहराई से देखने के लिए, हम प्रत्येक पेड़ की कल्पना कर सकते हैं और वे डेटा को कैसे विभाजित कर रहे हैं। यह प्रयोग करके किया जा सकता है tree स्किकिट-लर्न में बनाया गया मॉड्यूल, और फिर समेकन में प्रत्येक अनुमानक के माध्यम से लूपिंग:

from sklearn import tree

features = X.columns.values 
classes = ['0', '1', '2'] 



for estimator in rfc.estimators_:
    print(estimator)
    plt.figure(figsize=(12,6))
    tree.plot_tree(estimator,
                   feature_names=features,
                   class_names=classes,
                   fontsize=8, 
                   filled=True, 
                   rounded=True)
    plt.show()

उपरोक्त कोड ट्री प्लॉट प्रदर्शित करता है:

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

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

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

रैंडमफ़ॉरेस्ट क्लासिफायर का मूल्यांकन

स्किकिट-लर्न एक प्रदान करके बेसलाइन बनाना आसान बनाता है DummyClassifier, जो भविष्यवाणियों को आउटपुट करता है इनपुट सुविधाओं का उपयोग किए बिना (पूरी तरह से यादृच्छिक आउटपुट)। यदि आपका मॉडल इससे बेहतर है DummyClassifier, कुछ सीखना हो रहा है! सीखने को अधिकतम करने के लिए - आप a का उपयोग करके स्वचालित रूप से विभिन्न हाइपरपरमेटर्स का परीक्षण कर सकते हैं RandomizedSearchCV or GridSearchCV. एक आधार रेखा होने के अलावा, आप कई मेट्रिक्स के लेंस से अपने मॉडल के प्रदर्शन का मूल्यांकन कर सकते हैं।

एल्गोरिदम का मूल्यांकन करने के लिए उपयोग किए जा सकने वाले कुछ पारंपरिक वर्गीकरण मेट्रिक्स सटीक, रिकॉल, एफ 1-स्कोर, सटीकता और भ्रम मैट्रिक्स हैं। यहाँ उनमें से प्रत्येक पर एक संक्षिप्त विवरण दिया गया है:

1. शुद्धता: जब हमारा उद्देश्य यह समझना है कि हमारे क्लासिफायर द्वारा कौन से सही भविष्यवाणी मूल्यों को सही माना गया था। सटीकता उन सच्चे सकारात्मक मूल्यों को उन नमूनों से विभाजित करेगी जिनकी भविष्यवाणी सकारात्मक के रूप में की गई थी;

$$
सटीक = frac {पाठ {सही सकारात्मक}} {पाठ {सच्चे सकारात्मक} + पाठ {गलत सकारात्मक}}
$$

2. वापस बुलाना: आमतौर पर सटीकता के साथ-साथ यह समझने के लिए गणना की जाती है कि हमारे क्लासिफायर द्वारा कितने सच्चे सकारात्मक की पहचान की गई थी। रिकॉल की गणना वास्तविक सकारात्मक को किसी भी चीज से विभाजित करके की जाती है जिसे सकारात्मक के रूप में भविष्यवाणी की जानी चाहिए थी।

$$
याद = frac {पाठ {सही सकारात्मक}} {पाठ {सच्चे सकारात्मक} + पाठ {गलत नकारात्मक}}
$$

3. एफ 1 का स्कोर: संतुलित है या अनुकूल माध्य सटीकता और याद की। निम्नतम मान 0 है और उच्चतम 1 है। कब f1-score 1 के बराबर है, इसका मतलब है कि सभी वर्गों की सही भविष्यवाणी की गई थी - यह वास्तविक डेटा के साथ प्राप्त करने के लिए एक बहुत ही कठिन स्कोर है (अपवाद लगभग हमेशा मौजूद होते हैं)।

$$
टेक्स्ट{f1-स्कोर} = 2* फ़्रेक{टेक्स्ट{सटीक} * टेक्स्ट{रिकॉल}}{टेक्स्ट{सटीक} + टेक्स्ट{रिकॉल}}
$$

4. असमंजस का जाल: जब हमें यह जानने की आवश्यकता होती है कि हमें कितने नमूने सही या गलत मिले प्रत्येक वर्ग. वे मान जो सही थे और सही भविष्यवाणी की गई थी, कहलाते हैं सच्ची सकारात्मकता, जिनकी भविष्यवाणी सकारात्मक के रूप में की गई थी लेकिन सकारात्मक नहीं थी, उन्हें कहा जाता है झूठी सकारात्मक. एक ही नामकरण सच नकारात्मक और झूठे नकारात्मक नकारात्मक मूल्यों के लिए प्रयोग किया जाता है;

5. शुद्धता: बताता है कि हमारे क्लासिफायरियर ने कितनी भविष्यवाणियां कीं। न्यूनतम सटीकता मान 0 है और उच्चतम 1 है। प्रतिशत प्राप्त करने के लिए उस मान को आमतौर पर 100 से गुणा किया जाता है:

$$
सटीकता = फ़्रेक {पाठ {सही भविष्यवाणियों की संख्या}} {पाठ {भविष्यवाणियों की कुल संख्या}}
$$

आवश्यक पुस्तकालयों को आयात करने और परिणामों को देखने के लिए आप निम्न स्क्रिप्ट को निष्पादित कर सकते हैं:

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk)')

print(classification_report(y_test,y_pred))

आउटपुट कुछ इस तरह दिखेगा:

                precision    recall  f1-score   support

           0       0.53      0.89      0.66        80
           1       0.57      0.17      0.26        76
           2       0.74      0.72      0.73        47

    accuracy                           0.58       203
   macro avg       0.61      0.59      0.55       203
weighted avg       0.59      0.58      0.53       203

वर्गीकरण रिपोर्ट में, निरीक्षण करें कि रिकॉल उच्च है, कक्षा 0.89 के लिए 0, कक्षा 2 के लिए सटीकता और रिकॉल दोनों उच्च हैं, 0.74, 0.72 - और कक्षा 1 के लिए, वे कम हैं, विशेष रूप से 0.17 की रिकॉल और 0.57 की सटीकता . व्यक्तिगत रूप से सभी तीन वर्गों के लिए रिकॉल और सटीक के बीच संबंध को इसमें कैप्चर किया गया है F1 स्कोर, जो रिकॉल और सटीक के बीच हार्मोनिक माध्य है - मॉडल कर रहा है अच्छा कक्षा 0 के लिए, कक्षा 1 के लिए काफी खराब और कक्षा 2 के लिए सभ्य।

मॉडल की पहचान करते समय बहुत कठिन समय हो रहा है मध्यम जोखिम वाले मामले.

हमारे रैंडम फ़ॉरेस्ट क्लासिफायर द्वारा केवल 3 पेड़ों के साथ प्राप्त की गई सटीकता है 0.58 (58%) - इसका मतलब है कि यह आधे से थोड़ा अधिक सही परिणाम प्राप्त कर रहा है। यह एक कम सटीकता है, और शायद अधिक वृक्षों को जोड़कर इसमें सुधार किया जा सकता है।

भ्रम मैट्रिक्स को देखकर, हम देख सकते हैं कि अधिकांश गलतियाँ मध्यम जोखिम के 52 रिकॉर्ड को कम जोखिम के रूप में वर्गीकृत करते समय होती हैं, जो कक्षा 1 की कम याद को और अधिक अंतर्दृष्टि प्रदान करती है। यह मध्यम-जोखिम वाले रोगियों को निम्न के रूप में वर्गीकृत करने के पक्षपाती है- जोखिम रोगियों।

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

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

features_df = pd.DataFrame({'features': rfc.feature_names_in_, 'importances': rfc.feature_importances_ })


features_df_sorted = features_df.sort_values(by='importances', ascending=False)


g = sns.barplot(data=features_df_sorted, x='importances', y ='features', palette="rocket")
sns.despine(bottom = True, left = True)
g.set_title('Feature importances')
g.set(xlabel=None)
g.set(ylabel=None)
g.set(xticks=[])
for value in g.containers:
    g.bar_label(value, padding=2)

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

यह अंत में अधिक पेड़ों के साथ एक नया मॉडल बनाने का समय है, यह देखने के लिए कि यह परिणामों को कैसे प्रभावित करता है। आइए बनाते हैं rfc_ 900 पेड़, 8 स्तर और एक ही बीज वाला जंगल। क्या नतीजे सुधरेंगे?

rfc_ = RandomForestClassifier(n_estimators=900, 
                             max_depth=7,
                             random_state=SEED)
rfc_.fit(X_train, y_train)
y_pred = rfc_.predict(X_test)

मेट्रिक्स की गणना और प्रदर्शित करना:

cm_ = confusion_matrix(y_test, y_pred)
sns.heatmap(cm_, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk) for 900 trees with 8 levels')

print(classification_report(y_test,y_pred))

यह आउटपुट:

                precision    recall  f1-score   support

           0       0.68      0.86      0.76        80
           1       0.75      0.58      0.65        76
           2       0.90      0.81      0.85        47

    accuracy                           0.74       203
   macro avg       0.78      0.75      0.75       203
weighted avg       0.76      0.74      0.74       203

इससे पता चलता है कि कैसे अधिक पेड़ों और अधिक विशिष्ट पेड़ों (उच्च स्तर) को जोड़ने से हमारे मैट्रिक्स में सुधार हुआ है। हमारे पास अभी भी कक्षा 1 के लिए कम रिकॉल है, लेकिन सटीकता अब 74% है। उच्च जोखिम वाले मामलों का वर्गीकरण करते समय F1-स्कोर 0.85 है, जिसका अर्थ है कि पिछले मॉडल में 0.73 की तुलना में उच्च जोखिम वाले मामलों की अब अधिक आसानी से पहचान की जा सकती है!

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

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

प्रतिगमन के लिए रैंडम फ़ॉरेस्ट का उपयोग करना

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

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

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

पुस्तकालय और डेटा आयात करना

import pandas as pd
import numpy as np
import maplotlib.pyplot as plt
import seaborn as sns

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

प्रतिगमन के लिए डेटा प्रीप्रोसेसिंग

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

from sklearn.model_selection import train_test_split

SEED = 42

y = dataset['BS']
X = dataset.drop(['BS'], axis=1) 

X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

एक रैंडमफ़ॉरेस्ट रेजिस्टर का प्रशिक्षण

अब जब हमने अपने डेटासेट का विस्तार कर लिया है, तो इस प्रतिगमन समस्या को हल करने के लिए अपने एल्गोरिथ्म को प्रशिक्षित करने का समय आ गया है, इसे थोड़ा बदलने के लिए - हम जंगल में 20 पेड़ों के साथ एक मॉडल बनाएंगे और प्रत्येक में 4 स्तर होंगे। ऐसा करने के लिए, आप निम्न कोड निष्पादित कर सकते हैं:

from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor(n_estimators=20, 
                            max_depth=3, 
                            random_state=SEED)

rfr.fit(X_train, y_train)
y_pred = rfr.predict(X_test)

आप के सभी पैरामीटर के लिए विवरण प्राप्त कर सकते हैं RandomForestRegressor आधिकारिक दस्तावेज में.

चूंकि 20 पेड़ों की साजिश रचने और उन्हें देखने के लिए कुछ समय और समर्पण की आवश्यकता होगी, हम केवल पहले वाले को देख सकते हैं कि यह वर्गीकरण के पेड़ से कैसे अलग है:

from sklearn import tree

features = X.columns

first_tree = rfr.estimators_[0]

plt.figure(figsize=(15,6))
tree.plot_tree(first_tree,
               feature_names=features,
               fontsize=8, 
               filled=True, 
               rounded=True);

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

मशीन सीखने की समस्या को हल करते समय और एल्गोरिथम के प्रदर्शन का मूल्यांकन करते समय अंतिम और अंतिम चरण पर आगे बढ़ने का समय आ गया है!

एक रैंडमफ़ॉरेस्ट रेजिस्टर का मूल्यांकन

प्रतिगमन समस्याओं के लिए एक एल्गोरिथम का मूल्यांकन करने के लिए उपयोग किए जाने वाले मेट्रिक्स औसत पूर्ण त्रुटि (MAE), औसत चुकता त्रुटि (MSE), और मूल माध्य चुकता त्रुटि (RMSE) हैं।

1. मीन एब्सोल्यूट एरर (MAE): जब हम अनुमानित मानों को वास्तविक मानों से घटाते हैं, तो त्रुटियाँ प्राप्त करते हुए, उन त्रुटियों के निरपेक्ष मानों का योग करते हैं और उनका माध्य प्राप्त करते हैं। यह मीट्रिक मॉडल की प्रत्येक भविष्यवाणी के लिए समग्र त्रुटि की धारणा देता है, छोटा (0 के करीब) बेहतर होता है।

$$
मॅई = (frac{1}{n})sum_{i=1}^{n}बाएं | वास्तविक – पूर्वानुमानित अधिकार |
$$

2. माध्य चुकता त्रुटि (MSE): यह MAE मीट्रिक के समान है, लेकिन यह त्रुटियों के निरपेक्ष मानों का वर्ग करता है। इसके अलावा, एमएई के साथ, छोटा, या 0 के करीब, बेहतर। बड़ी त्रुटियों को और भी बड़ा बनाने के लिए MSE मान को चुकता किया जाता है। एक बात पर पूरा ध्यान देना चाहिए, यह है कि आमतौर पर इसके मूल्यों के आकार और इस तथ्य के कारण कि वे डेटा के समान पैमाने पर नहीं हैं, इसकी व्याख्या करना एक कठिन मीट्रिक है।

$$
mse = sum_{i=1}^{D}(वास्तविक - अनुमानित)^2
$$

3. रूट माध्य चुकता त्रुटि (RMSE): MSE के साथ उठाई गई व्याख्या की समस्या को उसके अंतिम मान का वर्गमूल प्राप्त करके हल करने का प्रयास करता है, ताकि इसे डेटा की समान इकाइयों में वापस स्केल किया जा सके। जब हमें त्रुटि के साथ डेटा के वास्तविक मूल्य को प्रदर्शित करने या दिखाने की आवश्यकता होती है, तो इसकी व्याख्या करना आसान और अच्छा होता है। यह दिखाता है कि डेटा कितना भिन्न हो सकता है, इसलिए, यदि हमारे पास 4.35 का आरएमएसई है, तो हमारा मॉडल या तो त्रुटि कर सकता है क्योंकि इसने वास्तविक मूल्य में 4.35 जोड़ा, या वास्तविक मूल्य प्राप्त करने के लिए 4.35 की आवश्यकता थी। 0 के जितना करीब होगा, उतना ही अच्छा है।

$$
rmse = sqrt{ sum_{i=1}^{D}(वास्तविक - अनुमानित)^2}
$$

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

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

इन मानों को खोजने के लिए आप निम्न कोड कर सकते हैं:

from sklearn.metrics import mean_absolute_error, mean_squared_error

print('Mean Absolute Error:', mean_absolute_error(y_test, y_pred))
print('Mean Squared Error:', mean_squared_error(y_test, y_pred))
print('Root Mean Squared Error:', np.sqrt(mean_squared_error(y_test, y_pred)))

आउटपुट होना चाहिए:

Mean Absolute Error: 1.127893702896059
Mean Squared Error: 3.0802988503933326
Root Mean Squared Error: 1.755078018320933

20 पेड़ों के साथ, मूल माध्य वर्ग त्रुटि 1.75 है जो कम है, लेकिन फिर भी - पेड़ों की संख्या बढ़ाकर और अन्य मापदंडों के साथ प्रयोग करके, यह त्रुटि शायद और भी छोटी हो सकती है।

रैंडम फ़ॉरेस्ट का उपयोग करने के लाभ

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

1. यादृच्छिक वन एल्गोरिथ्म पक्षपाती नहीं है, क्योंकि कई पेड़ हैं और प्रत्येक पेड़ को डेटा के एक यादृच्छिक सबसेट पर प्रशिक्षित किया जाता है। मूल रूप से, यादृच्छिक वन एल्गोरिथ्म "भीड़" की शक्ति पर निर्भर करता है; इसलिए एल्गोरिथ्म के पूर्वाग्रह की समग्र डिग्री कम हो जाती है।
2. यह एल्गोरिथम बहुत स्थिर है। यहां तक ​​कि अगर डेटासेट में एक नया डेटा बिंदु पेश किया जाता है, तो समग्र एल्गोरिथ्म बहुत अधिक प्रभावित नहीं होता है क्योंकि नया डेटा एक पेड़ को प्रभावित कर सकता है, लेकिन इसके लिए सभी पेड़ों को प्रभावित करना बहुत कठिन होता है।
3. रैंडम फ़ॉरेस्ट एल्गोरिथम तब अच्छा काम करता है जब आपके पास श्रेणीबद्ध और संख्यात्मक दोनों विशेषताएं हों।
4. रैंडम फ़ॉरेस्ट एल्गोरिथम तब भी अच्छी तरह से काम करता है जब डेटा में मान गुम होते हैं या इसे स्केल नहीं किया गया होता है।

रैंडम फ़ॉरेस्ट का उपयोग करने के नुकसान

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

आगे जा रहे हैं - हैंड-हेल्ड एंड-टू-एंड प्रोजेक्ट

आपका जिज्ञासु स्वभाव आपको और आगे जाना चाहता है? हम अनुशंसा करते हैं कि हमारी जाँच करें निर्देशित परियोजना: "हैंड्स-ऑन हाउस प्राइस प्रेडिक्शन - पायथन में मशीन लर्निंग".

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

Tensorflow के शीर्ष पर बने डीप लर्निंग एपीआई केरस का उपयोग करते हुए, हम आर्किटेक्चर के साथ प्रयोग करेंगे, स्टैक्ड मॉडल का एक समूह बनाएंगे और एक को प्रशिक्षित करेंगे। मेटा-लर्नर तंत्रिका नेटवर्क (स्तर -1 मॉडल) एक घर के मूल्य निर्धारण का पता लगाने के लिए।

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

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