शुरू करेंमुफ़्त में शुरू करें

एक छोटे उदाहरण पर vtreat

इस अभ्यास में, आप एक छोटे उदाहरण पर श्रेणीबद्ध वैरिएबल को one-hot-encode करने के लिए vtreat का उपयोग करेंगे. vtreat एक treatment plan बनाता है जो श्रेणीबद्ध वैरिएबल्स को इंडिकेटर वैरिएबल्स में बदलता है (कोड "lev"), और संख्यात्मक वैरिएबल्स से खराब मानों को साफ करता है (कोड "clean").

ट्रीटमेंट प्लान डिज़ाइन करने के लिए फ़ंक्शन designTreatmentsZ() का उपयोग करें (docs)

treatplan <- designTreatmentsZ(data, varlist)
  • data: मूल प्रशिक्षण डेटा फ़्रेम
  • varlist: ट्रीट किए जाने वाले इनपुट वैरिएबल्स का वेक्टर (स्ट्रिंग्स के रूप में).

designTreatmentsZ() एक लिस्ट लौटाता है जिसमें scoreFrame नाम का एक एलिमेंट होता है: एक डेटा फ़्रेम जिसमें नए वैरिएबल्स के नाम और प्रकार शामिल होते हैं:

scoreFrame <- treatplan %>% 
            magrittr::use_series(scoreFrame) %>% 
            select(varName, origName, code)
  • varName: नए ट्रीट किए गए वैरिएबल का नाम
  • origName: उस मूल वैरिएबल का नाम जिससे ट्रीट किया गया वैरिएबल आया है
  • code: नए वैरिएबल का प्रकार.
    • "clean": एक संख्यात्मक वैरिएबल जिसमें NA या NaN नहीं हैं
    • "lev": मूल श्रेणीबद्ध वैरिएबल के किसी विशिष्ट स्तर के लिए इंडिकेटर वैरिएबल.

(magrittr::use_series() (docs) पाइप्स में उपयोग करने के लिए $ का उपनाम है.)

इन अभ्यासों के लिए, हमें varName चाहिए जहाँ code या तो "clean" या "lev" हो:

newvarlist <- scoreFrame %>% 
             filter(code %in% c("clean", "lev") %>%
             magrittr::use_series(varName)

डेटासेट को पूरी तरह संख्यात्मक और one-hot-encoded वैरिएबल्स में बदलने के लिए prepare() का उपयोग करें (docs):

data.treat <- prepare(treatplan, data, varRestrictions = newvarlist)
  • treatplan: ट्रीटमेंट प्लान
  • data: ट्रीट किए जाने वाला डेटा फ़्रेम
  • varRestrictions: ट्रीटेड डेटा में वांछित वैरिएबल्स

dframe डेटा फ़्रेम और magrittr पैकेज पहले से लोड किए गए हैं.

यह अभ्यास पाठ्यक्रम का हिस्सा है

R में Supervised Learning: Regression

पाठ्यक्रम देखें

अभ्यास निर्देश

  • dframe प्रिंट करें. हम मान लेंगे कि color और size इनपुट वैरिएबल्स हैं, और popularity वह आउटपुट है जिसकी भविष्यवाणी करनी है.
  • इनपुट वैरिएबल्स के नामों (स्ट्रिंग्स के रूप में) के साथ vars नाम का एक वेक्टर बनाएँ.
  • पैकेज vtreat लोड करें.
  • designTreatmentsZ() का उपयोग करके vars में दिए वैरिएबल्स के लिए एक ट्रीटमेंट प्लान बनाएँ. इसे वैरिएबल treatplan में असाइन करें.
  • ट्रीटमेंट प्लान से scoreFrame निकालें और देखें कि पुराने वैरिएबल्स नए वैरिएबल्स में कैसे मैप हुए हैं.
    • आपको केवल varName, origName और code कॉलम चाहिए.
    • नए इंडिकेटर वैरिएबल्स के नाम क्या हैं? सतत (continuous) वैरिएबल का नाम क्या है?
  • newvars नाम का एक वेक्टर बनाएँ जिसमें varName शामिल हो जहाँ code या तो clean या lev है. इसे प्रिंट करें.
  • prepare() का उपयोग करके नया डेटा फ़्रेम dframe.treat बनाएँ जो dframe का one-hot-encoded संस्करण हो (आउटकम कॉलम के बिना).
    • इसे प्रिंट करें और dframe से तुलना करें.

इंटरैक्टिव व्यावहारिक अभ्यास

इस अभ्यास को इस नमूना कोड को पूरा करके आज़माएँ।

# Print dframe
dframe

# Create and print a vector of variable names
(vars <- ___)

# Load the package vtreat
___

# Create the treatment plan
treatplan <- ___(___, ___)

# Examine the scoreFrame
(scoreFrame <- treatplan %>%
    use_series(scoreFrame) %>%
    select(___, ___, ___))

# We only want the rows with codes "clean" or "lev"
(newvars <- scoreFrame %>%
    filter(code %in% ___) %>%
    use_series(varName))

# Create the treated training data
(dframe.treat <- ___(___, ___, varRestriction = newvars))
कोड संपादित करें और चलाएँ