Full basic guide of R code

R प्रोग्रामिंग गाइड

📊 R प्रोग्रामिंग: एक संपूर्ण गाइड (A Comprehensive Guide to R Programming) 📈

R एक शक्तिशाली प्रोग्रामिंग भाषा और सॉफ्टवेयर वातावरण है जो सांख्यिकीय कंप्यूटिंग (statistical computing) और ग्राफिक्स के लिए व्यापक रूप से उपयोग किया जाता है। यह डेटा वैज्ञानिकों, सांख्यिकीविदों, शोधकर्ताओं और विश्लेषकों के बीच बहुत लोकप्रिय है। आइए R की दुनिया में गहराई से उतरें!

1. R क्या है और इसका उपयोग क्यों किया जाता है? (What is R and Why is it Used?)

R एक ओपन-सोर्स प्रोग्रामिंग भाषा है जिसे विशेष रूप से सांख्यिकीय विश्लेषण, डेटा विज़ुअलाइज़ेशन और डेटा विज्ञान कार्यों के लिए डिज़ाइन किया गया है। इसे रॉस इहाका (Ross Ihaka) और रॉबर्ट जेंटलमैन (Robert Gentleman) ने न्यूजीलैंड के ऑकलैंड विश्वविद्यालय में विकसित किया था।

R का उपयोग क्यों करें?

  • मुक्त और ओपन-सोर्स (Free and Open-Source): R उपयोग करने के लिए स्वतंत्र है और इसका कोड सार्वजनिक रूप से उपलब्ध है।
  • शक्तिशाली सांख्यिकीय क्षमताएं (Powerful Statistical Capabilities): R में सांख्यिकीय मॉडलिंग, परीक्षण और विश्लेषण के लिए अंतर्निहित (built-in) कार्यों और पैकेजों की एक विशाल श्रृंखला है।
  • उत्कृष्ट ग्राफिक्स (Excellent Graphics): R उच्च-गुणवत्ता वाले, अनुकूलन योग्य ग्राफ और प्लॉट बनाने के लिए शानदार क्षमताएं प्रदान करता है (जैसे ggplot2 पैकेज)।
  • विशाल समुदाय और पैकेज (Large Community and Packages): CRAN (Comprehensive R Archive Network) पर हजारों उपयोगकर्ता-योगदान वाले पैकेज उपलब्ध हैं, जो R की कार्यक्षमता का विस्तार करते हैं।
  • क्रॉस-प्लेटफ़ॉर्म (Cross-Platform): R विंडोज, मैकओएस और लिनक्स पर चलता है।
  • डेटा हैंडलिंग (Data Handling): R विभिन्न स्रोतों से डेटा को इम्पोर्ट करने, साफ़ करने, बदलने और विश्लेषण करने के लिए प्रभावी उपकरण प्रदान करता है।

2. R में वेरिएबल कैसे घोषित करें? (How to Declare Variables in R?)

R में वेरिएबल घोषित करने के लिए, आप मान निर्दिष्ट करने के लिए असाइनमेंट ऑपरेटर का उपयोग करते हैं। R में सबसे पसंदीदा असाइनमेंट ऑपरेटर <- है, हालाँकि आप = का भी उपयोग कर सकते हैं। वेरिएबल नामों में अक्षर, संख्याएँ, अंडरस्कोर (_) और डॉट (.) हो सकते हैं, लेकिन वे एक संख्या से शुरू नहीं हो सकते हैं। 



# संख्यात्मक वेरिएबल

age <- 30

height = 175.5

# कैरेक्टर (स्ट्रिंग) वेरिएबल

name <- "अमित"

city = 'दिल्ली'

# लॉजिकल वेरिएबल

is_student <- TRUE  # या FALSE

# वेरिएबल का मान प्रिंट करना

print(age)

print(name)

is_student

आउटपुट:



[1] 30

[1] "अमित"

[1] TRUE

3. R में डेटा टाइप क्या हैं? (What are Data Types in R?)

R में मूल डेटा प्रकार (Atomic Data Types) निम्नलिखित हैं:

  • Numeric: दशमलव मानों सहित संख्याएँ (जैसे 10.5, 55, -3.14)।
  • Integer: पूर्णांक (बिना दशमलव वाली संख्याएँ)। इन्हें L प्रत्यय लगाकर निर्दिष्ट किया जाता है (जैसे 10L, 100L)।
  • Logical: बूलियन मान - TRUE या FALSE।
  • Character: टेक्स्ट डेटा या स्ट्रिंग्स (जैसे "hello", 'R world')।
  • Complex: सम्मिश्र संख्याएँ (जैसे 3 + 2i)।
  • Raw: बाइट्स के रूप में कच्चा डेटा।

R में सबसे बुनियादी डेटा संरचना वेक्टर (vector) है, जिसमें एक ही प्रकार के तत्व होते हैं। आप c() फ़ंक्शन का उपयोग करके वेक्टर बना सकते हैं।



# विभिन्न डेटा प्रकारों के वेक्टर

numeric_vector <- c(1, 2.5, 5.7)

integer_vector <- c(1L, 5L, 10L)

logical_vector <- c(TRUE, FALSE, TRUE)

character_vector <- c("लाल", "हरा", "नीला")

# डेटा प्रकार की जाँच करना

class(numeric_vector)  # आउटपुट: "numeric"

class(integer_vector)  # आउटपुट: "integer"

class(logical_vector)  # आउटपुट: "logical"

class(character_vector) # आउटपुट: "character"

4. R में ऑपरेटर कैसे काम करते हैं? (How do Operators Work in R?)

R विभिन्न प्रकार के ऑपरेटरों का समर्थन करता है:

  • अरिथमेटिक ऑपरेटर्स (Arithmetic Operators):
    • + (जोड़)
    • - (घटाव)
    • * (गुणा)
    • / (भाग)
    • ^ या ** (घात)
    • %% (मॉड्यूलो - शेषफल)
    • %/% (पूर्णांक भाग)
  • रिलेशनल ऑपरेटर्स (Relational Operators): तुलना के लिए उपयोग किए जाते हैं, परिणाम TRUE या FALSE होता है।
    • == (बराबर)
    • != (बराबर नहीं)
    • < (से कम)
    • > (से अधिक)
    • <= (से कम या बराबर)
    • >= (से अधिक या बराबर)
  • लॉजिकल ऑपरेटर्स (Logical Operators): बूलियन मानों पर काम करते हैं।
    • & (एलिमेंट-वाइज AND)
    • | (एलिमेंट-वाइज OR)
    • ! (NOT)
    • && (शॉर्ट-सर्किट AND - केवल पहले एलिमेंट का उपयोग करता है)
    • || (शॉर्ट-सर्किट OR - केवल पहले एलिमेंट का उपयोग करता है)
  • असाइनमेंट ऑपरेटर्स (Assignment Operators): मान निर्दिष्ट करने के लिए।
    • <- (पसंदीदा)
    • =
    • -> (दाएँ से बाएँ असाइनमेंट)
  • अन्य ऑपरेटर्स:
    • : (अनुक्रम बनाने के लिए, जैसे 1:5)
    • %in% (जाँचता है कि कोई तत्व वेक्टर में है या नहीं)
    • %*% (मैट्रिक्स गुणा)


# उदाहरण

x <- 10

y <- 5

# अरिथमेटिक

x + y  # आउटपुट: 15

x / y  # आउटपुट: 2

# रिलेशनल

x > y  # आउटपुट: TRUE

x == y # आउटपुट: FALSE

# लॉजिकल

a <- TRUE

b <- FALSE

a & b  # आउटपुट: FALSE

!a     # आउटपुट: FALSE

5. R में डेटा फ्रेम कैसे बनाएं? (How to Create a Data Frame in R?)

डेटा फ्रेम R में एक सारणीबद्ध (tabular) डेटा संरचना है, जो एक्सेल शीट या SQL टेबल के समान है। इसमें विभिन्न प्रकार के कॉलम हो सकते हैं (numeric, character, logical आदि), लेकिन प्रत्येक कॉलम में एक ही प्रकार का डेटा होना चाहिए। डेटा फ्रेम बनाने के लिए data.frame() फ़ंक्शन का उपयोग किया जाता है। 



# वेक्टर बनाना

student_id <- c(101, 102, 103, 104)

student_name <- c("राहुल", "प्रिया", "मोहन", "गीता")

marks <- c(75, 88, 92, 65)

passed <- c(TRUE, TRUE, TRUE, FALSE)

# डेटा फ्रेम बनाना

student_data <- data.frame(

  ID = student_id,

  Name = student_name,

  Score = marks,

  Result = passed

)

# डेटा फ्रेम प्रिंट करना

print(student_data)

# डेटा फ्रेम की संरचना देखना

str(student_data)

आउटपुट (print):



   ID  Name Score Result

1 101  राहुल    75   TRUE

2 102  प्रिया    88   TRUE

3 103  मोहन    92   TRUE

4 104  गीता    65  FALSE

आउटपुट (str):



'data.frame':   4 obs. of  4 variables:

 $ ID    : num  101 102 103 104

 $ Name  : chr  "राहुल" "प्रिया" "मोहन" "गीता"

 $ Score : num  75 88 92 65

 $ Result: logi  TRUE TRUE TRUE FALSE

6. R में डेटा को कैसे सब्सेट करें? (How to Subset Data in R?)

डेटा को सब्सेट करना मतलब डेटा संरचना (जैसे वेक्टर, लिस्ट, डेटा फ्रेम) के विशिष्ट हिस्सों का चयन करना है। इसके कई तरीके हैं:

  • इंडेक्सिंग (Indexing) [[]]:
    • वेक्टर: vector[index] (जैसे marks[2] दूसरा अंक देगा)
    • डेटा फ्रेम: dataframe[row_index, column_index] (जैसे student_data[1, 2] पहली पंक्ति और दूसरा कॉलम देगा)। इंडेक्स खाली छोड़ने से सभी पंक्तियाँ या कॉलम चुने जाते हैं (जैसे student_data[1, ] पहली पंक्ति चुनेगा, student_data[, 2] दूसरा कॉलम चुनेगा)।
  • नाम से चयन (Selection by Name):
    • डेटा फ्रेम कॉलम: dataframe$column_name (जैसे student_data$Name) या dataframe[["column_name"]]।
  • लॉजिकल कंडीशन (Logical Conditions): शर्तों के आधार पर डेटा चुनना।
    • vector[logical_condition] (जैसे marks[marks > 80])
    • dataframe[logical_condition_on_rows, ] (जैसे student_data[student_data$Score > 80, ])
  • subset() फ़ंक्शन: डेटा फ्रेम को सब्सेट करने का एक सुविधाजनक तरीका।


# इंडेक्सिंग का उपयोग

first_row <- student_data[1, ]

name_column <- student_data[, "Name"] # या student_data[, 2]

second_student_score <- student_data[2, "Score"] # या student_data[2, 3]

# नाम से चयन

student_names <- student_data$Name

student_scores <- student_data[["Score"]]

# लॉजिकल कंडीशन

passed_students <- student_data[student_data$Result == TRUE, ]

high_scorers <- student_data[student_data$Score >= 90, ]

# subset() फ़ंक्शन का उपयोग

high_scorers_subset <- subset(student_data, Score >= 90)

# परिणाम प्रिंट करना

print(passed_students)

print(high_scorers_subset)

7. R में डेटा को कैसे मर्ज करें? (How to Merge Data in R?)

दो डेटा फ्रेम को एक या अधिक सामान्य कॉलम (कुंजी) के आधार पर संयोजित करने के लिए merge() फ़ंक्शन का उपयोग किया जाता है। यह SQL JOIN ऑपरेशन के समान है। 



# एक और डेटा फ्रेम बनाएं (जैसे विषय जानकारी)

subject_data <- data.frame(

  ID = c(101, 102, 104, 105),

  Subject = c("Math", "Science", "Math", "History")

)

# ID कॉलम के आधार पर मर्ज करें (केवल सामान्य ID वाले छात्र शामिल होंगे)

merged_data_inner <- merge(student_data, subject_data, by = "ID")

print("Inner Merge:")

print(merged_data_inner)

# सभी छात्रों को शामिल करने के लिए बाएं जॉइन (student_data के सभी छात्र)

merged_data_left <- merge(student_data, subject_data, by = "ID", all.x = TRUE)

print("Left Merge:")

print(merged_data_left)

# सभी पंक्तियों को शामिल करने के लिए फुल आउटर जॉइन

merged_data_outer <- merge(student_data, subject_data, by = "ID", all = TRUE)

print("Outer Merge:")

print(merged_data_outer)

नोट: dplyr पैकेज left_join(), right_join(), inner_join(), full_join() जैसे अधिक सहज ज्ञान युक्त जॉइन फ़ंक्शन प्रदान करता है।

8. R में डेटा को कैसे ट्रांसफॉर्म करें? (How to Transform Data in R?)

डेटा ट्रांसफॉर्मेशन में मौजूदा डेटा से नई जानकारी बनाने के लिए कॉलम जोड़ना, संशोधित करना या हटाना शामिल है।

  • नए कॉलम जोड़ना: आप सीधे $ ऑपरेटर का उपयोग करके या मौजूदा कॉलम पर गणना करके नए कॉलम बना सकते हैं।
  • कॉलम संशोधित करना: मौजूदा कॉलम को ओवरराइट करें।
  • transform() फ़ंक्शन: बेस R में डेटा फ्रेम को संशोधित करने का एक तरीका।
  • dplyr पैकेज: mutate() (कॉलम जोड़ने/संशोधित करने के लिए), select() (कॉलम चुनने के लिए), rename() (कॉलम का नाम बदलने के लिए) जैसे शक्तिशाली फ़ंक्शन प्रदान करता है।


# नया कॉलम जोड़ना: स्कोर प्रतिशत (मान लें कि अधिकतम अंक 100 हैं)

student_data$Percentage <- (student_data$Score / 100) * 100

# transform() का उपयोग करके एक और कॉलम जोड़ना (उदाहरण)

student_data <- transform(student_data, Score_Plus_5 = Score + 5)

# dplyr का उपयोग (पहले dplyr इंस्टॉल और लोड करें: install.packages("dplyr"), library(dplyr))

# library(dplyr)

# student_data <- student_data %>%

#   mutate(Score_Squared = Score^2,

#          Name_Upper = toupper(Name)) %>%

#   rename(Student_Identifier = ID)

print(student_data)

9. & 10. R में ग्राफ़ और प्लॉट कैसे बनाएं? (How to Create Graphs and Plots in R?)

R में डेटा विज़ुअलाइज़ेशन के लिए शक्तिशाली क्षमताएं हैं। आप बेस R ग्राफ़िक्स या ggplot2 जैसे अधिक उन्नत पैकेज का उपयोग कर सकते हैं।

बेस R ग्राफ़िक्स (Base R Graphics)

बेस R सरल और त्वरित प्लॉट बनाने के लिए फ़ंक्शन प्रदान करता है:

  • plot(): सामान्य स्कैटर प्लॉट और अन्य प्रकार के प्लॉट के लिए।
  • hist(): हिस्टोग्राम (डेटा के वितरण को दिखाने के लिए)।
  • boxplot(): बॉक्स प्लॉट (डेटा के प्रसार और आउटलायर्स को दिखाने के लिए)।
  • barplot(): बार चार्ट (श्रेणीबद्ध डेटा की तुलना करने के लिए)।
  • pie(): पाई चार्ट (आनुपातिक डेटा दिखाने के लिए, हालांकि अक्सर अनुशंसित नहीं)।


# बेस R प्लॉट उदाहरण (student_data का उपयोग करके)

# स्कैटर प्लॉट: ID बनाम स्कोर

plot(student_data$ID, student_data$Score,

     main = "Student Scores by ID",

     xlab = "Student ID",

     ylab = "Score",

     pch = 16, # बिंदु का प्रकार

     col = "blue") # रंग

# हिस्टोग्राम: स्कोर का वितरण

hist(student_data$Score,

     main = "Distribution of Scores",

     xlab = "Score",

     col = "lightblue",

     border = "black")

# बॉक्स प्लॉट: स्कोर का प्रसार

boxplot(student_data$Score,

        main = "Boxplot of Scores",

        ylab = "Score",

        col = "lightgreen")

# बार प्लॉट (उदाहरण के लिए, उत्तीर्ण/अनुत्तीर्ण छात्रों की संख्या)

result_counts <- table(student_data$Result) # TRUE/FALSE की गिनती

barplot(result_counts,

        main = "Number of Passed vs Failed Students",

        xlab = "Result (FALSE=Fail, TRUE=Pass)",

        ylab = "Number of Students",

        col = c("red", "darkgreen"))

# प्लॉट में टेक्स्ट जोड़ना (उदाहरण)

text(x = 103, y = 95, labels = "Highest Score") # plot() के बाद इस्तेमाल करें

11. R में ggplot2 पैकेज कैसे उपयोग करें? (How to Use the ggplot2 Package in R?)

ggplot2 R में डेटा विज़ुअलाइज़ेशन के लिए सबसे लोकप्रिय और शक्तिशाली पैकेजों में से एक है। यह "ग्राफिक्स के व्याकरण" (Grammar of Graphics) पर आधारित है, जो आपको परतों (layers) में प्लॉट बनाने की अनुमति देता है।

मुख्य घटक (Key Components):

  • ggplot(): प्लॉट इनिशियलाइज़ करता है, डेटा और एस्थेटिक मैपिंग (aes()) निर्दिष्ट करता है। aes() परिभाषित करता है कि डेटा के चर (variables) प्लॉट के विज़ुअल गुणों (जैसे x-अक्ष, y-अक्ष, रंग, आकार) से कैसे मैप होते हैं।
  • Geoms (Geometric Objects): प्लॉट पर डेटा का प्रतिनिधित्व कैसे किया जाता है (जैसे बिंदु, रेखाएं, बार)। उदाहरण: geom_point(), geom_line(), geom_bar(), geom_histogram(), geom_boxplot()।
  • Stats (Statistical Transformations): डेटा पर सांख्यिकीय परिवर्तन लागू करते हैं (जैसे स्मूथिंग, बिनिंग)।
  • Scales: नियंत्रित करते हैं कि डेटा मान एस्थेटिक्स (जैसे रंग ढाल, अक्ष सीमा) पर कैसे मैप होते हैं।
  • Facets: डेटा के सबसेट के लिए अलग-अलग प्लॉट बनाते हैं।
  • Themes: प्लॉट के गैर-डेटा तत्वों (जैसे पृष्ठभूमि, ग्रिड लाइन, फ़ॉन्ट) को अनुकूलित करते हैं।


# ggplot2 इंस्टॉल और लोड करें

# install.packages("ggplot2")

library(ggplot2)

# ggplot2 का उपयोग करके स्कैटर प्लॉट

ggplot(data = student_data, aes(x = ID, y = Score)) +

  geom_point(aes(color = Result, size = Score)) + # रंग और आकार को मैप करें

  labs(title = "Student Scores by ID (ggplot2)",

       x = "Student ID",

       y = "Score",

       color = "Passed",

       size = "Score Value") +

  theme_minimal() # एक साफ थीम लागू करें

# ggplot2 का उपयोग करके बार प्लॉट (परिणाम के आधार पर)

ggplot(data = student_data, aes(x = Result, fill = Result)) +

  geom_bar() +

  labs(title = "Count of Students by Result (ggplot2)",

       x = "Result (FALSE=Fail, TRUE=Pass)",

       y = "Number of Students") +

  scale_fill_manual(values = c("FALSE" = "tomato", "TRUE" = "steelblue")) + # कस्टम रंग

  theme_light()

# ggplot2 का उपयोग करके हिस्टोग्राम

ggplot(data = student_data, aes(x = Score)) +

  geom_histogram(binwidth = 10, fill = "cornflowerblue", color = "black") +

  labs(title = "Distribution of Scores (ggplot2)",

       x = "Score",

       y = "Frequency") +

  theme_bw()

12. R में डेटा विज़ुअलाइजेशन के लिए कौन से पैकेज उपयोगी हैं? (Which Packages are Useful for Data Visualization in R?)

R में डेटा विज़ुअलाइज़ेशन के लिए कई उत्कृष्ट पैकेज हैं:

  • ggplot2: सबसे लोकप्रिय, ग्राफिक्स के व्याकरण पर आधारित, अत्यधिक अनुकूलन योग्य।
  • Base R Graphics: त्वरित और सरल प्लॉट के लिए अच्छा है, कोई अतिरिक्त पैकेज आवश्यक नहीं है।
  • lattice: मल्टी-पैनल प्लॉट (trellis graphics) बनाने के लिए अच्छा है।
  • plotly: इंटरैक्टिव और वेब-आधारित प्लॉट बनाने के लिए उत्कृष्ट। ggplot2 प्लॉट को भी इंटरैक्टिव बना सकता है।
  • ggvis: ggplot2 के समान दर्शन, वेब ग्राफिक्स (vega) पर ध्यान केंद्रित करता है।
  • rgl: इंटरैक्टिव 3D प्लॉटिंग के लिए।
  • leaflet: इंटरैक्टिव मानचित्र बनाने के लिए।
  • Specialized Packages: जैसे survminer (उत्तरजीविता विश्लेषण के लिए), ggmap (मानचित्र पर डेटा प्लॉट करने के लिए), wordcloud (शब्द बादल बनाने के लिए)।

13. R में सांख्यिकी विश्लेषण कैसे करें? (How to Perform Statistical Analysis in R?)

R सांख्यिकीय विश्लेषण के लिए बनाया गया है। इसमें बुनियादी से लेकर उन्नत तकनीकों तक के लिए अंतर्निहित फ़ंक्शन और पैकेज हैं।

  • वर्णनात्मक सांख्यिकी (Descriptive Statistics): डेटा को सारांशित करना।
    • summary(): न्यूनतम, अधिकतम, चतुर्थक (quartiles), माध्य (mean), माध्यिका (median) देता है।
    • mean(), median(), sd() (मानक विचलन), var() (प्रसरण), min(), max(), range(), quantile()।
    • table(): आवृत्ति सारणी (frequency table) बनाता है।
    • cor(): सहसंबंध मैट्रिक्स (correlation matrix) की गणना करता है।
    • psych पैकेज: अधिक विस्तृत वर्णनात्मक आँकड़े प्रदान करता है (describe() फ़ंक्शन)।
  • अनुमानित सांख्यिकी (Inferential Statistics): नमूना डेटा से जनसंख्या के बारे में निष्कर्ष निकालना।
    • टी-टेस्ट (T-tests): t.test() (एक-नमूना, स्वतंत्र-नमूना, युग्मित-नमूना)।
    • एनोवा (ANOVA): aov() (समूहों के बीच माध्यों की तुलना)।
    • ची-स्क्वायर टेस्ट (Chi-squared Test): chisq.test() (श्रेणीबद्ध चरों के बीच संबंध का परीक्षण)।
    • सहसंबंध परीक्षण (Correlation Test): cor.test()।


# वर्णनात्मक सांख्यिकी

summary(student_data$Score)

mean(student_data$Score)

sd(student_data$Score)

table(student_data$Result)

# सहसंबंध (ID और Score के बीच - हालांकि यहाँ सार्थक नहीं)

cor(student_data$ID, student_data$Score)

# टी-टेस्ट उदाहरण (मान लें कि हमारे पास दो समूहों के स्कोर हैं)

groupA_scores <- c(75, 80, 85, 78)

groupB_scores <- c(88, 92, 95, 90)

t.test(groupA_scores, groupB_scores) # स्वतंत्र नमूना टी-टेस्ट

# ची-स्क्वायर टेस्ट उदाहरण (मान लें कि हमारे पास लिंग और परिणाम हैं)

# contingency_table <- table(student_data$Gender, student_data$Result)

# chisq.test(contingency_table)

14. R में रिग्रेशन विश्लेषण कैसे करें? (How to Perform Regression Analysis in R?)

रिग्रेशन विश्लेषण एक आश्रित चर (dependent variable) और एक या अधिक स्वतंत्र चरों (independent variables) के बीच संबंध को मॉडल करने के लिए उपयोग किया जाता है।

  • लीनियर रिग्रेशन (Linear Regression): lm() फ़ंक्शन का उपयोग किया जाता है। सिंटेक्स lm(formula, data) है, जहाँ formula dependent_var ~ independent_var1 + independent_var2 जैसा दिखता है।
  • मॉडल सारांश (Model Summary): summary() फ़ंक्शन मॉडल के परिणाम दिखाता है, जिसमें गुणांक (coefficients), R-स्क्वायर, p-मान आदि शामिल हैं।
  • अन्य प्रकार के रिग्रेशन: लॉजिस्टिक रिग्रेशन (glm() फ़ंक्शन family = binomial के साथ), पोइसन रिग्रेशन (glm() family = poisson के साथ), आदि।


# उदाहरण: क्या ID स्कोर का पूर्वानुमान लगा सकता है? (शैक्षणिक उदाहरण)

# एक साधारण लीनियर मॉडल बनाएं

regression_model <- lm(Score ~ ID, data = student_data)

# मॉडल का सारांश देखें

summary(regression_model)

# मॉडल से पूर्वानुमान लगाना (नए डेटा पर)

new_ids <- data.frame(ID = c(105, 106))

predicted_scores <- predict(regression_model, newdata = new_ids)

print("Predicted Scores:")

print(predicted_scores)

# मॉडल निदान प्लॉट (Model Diagnostics Plots)

# plot(regression_model) # यह 4 प्लॉट दिखाएगा

15. R में हाइपोथीसिस टेस्टिंग कैसे करें? (How to Perform Hypothesis Testing in R?)

हाइपोथीसिस टेस्टिंग एक सांख्यिकीय विधि है जिसका उपयोग किसी जनसंख्या के बारे में किए गए दावे या परिकल्पना (hypothesis) का मूल्यांकन करने के लिए नमूना डेटा का उपयोग करके किया जाता है। R में कई परीक्षणों के लिए अंतर्निहित फ़ंक्शन हैं:

  • टी-टेस्ट (T-test): t.test() - एक या दो समूहों के माध्यों की तुलना करता है।
    • एक-नमूना टी-टेस्ट: t.test(x, mu = population_mean)
    • स्वतंत्र दो-नमूना टी-टेस्ट: t.test(x, y) या t.test(formula, data)
    • युग्मित टी-टेस्ट: t.test(x, y, paired = TRUE)
  • एनोवा (ANOVA): aov() - दो से अधिक समूहों के माध्यों की तुलना करता है।
  • ची-स्क्वायर टेस्ट (Chi-squared Test): chisq.test() - श्रेणीबद्ध चरों के बीच स्वतंत्रता या अच्छाई-फिट (goodness-of-fit) का परीक्षण करता है।
  • सहसंबंध परीक्षण (Correlation Test): cor.test() - दो मात्रात्मक चरों के बीच रैखिक संबंध का परीक्षण करता है।
  • अन्य परीक्षण: विलकॉक्सन रैंक-सम टेस्ट (wilcox.test() - गैर-पैरामीट्रिक टी-टेस्ट), शपिरो-विल्क टेस्ट (shapiro.test() - सामान्यता का परीक्षण), आदि।

प्रत्येक परीक्षण फ़ंक्शन आमतौर पर एक p-value लौटाता है। यदि p-value आपके चुने हुए सार्थकता स्तर (significance level, आमतौर पर 0.05) से कम है, तो आप शून्य परिकल्पना (null hypothesis) को अस्वीकार करते हैं।



# उदाहरण: एक-नमूना टी-टेस्ट

# क्या छात्रों का औसत स्कोर 80 से काफी अलग है?

t_test_result <- t.test(student_data$Score, mu = 80)

print(t_test_result)

# परिणाम से p-value निकालना

p_value <- t_test_result$p.value

print(paste("P-value:", p_value))

if (p_value < 0.05) {

  print("शून्य परिकल्पना को अस्वीकार करें: औसत स्कोर 80 से काफी अलग है।")

} else {

  print("शून्य परिकल्पना को अस्वीकार करने में विफल: औसत स्कोर 80 से काफी अलग नहीं है।")

}

16. R में कॉन्फिडेंस इंटरवल कैसे बनाएं? (How to Create Confidence Intervals in R?)

कॉन्फिडेंस इंटरवल (CI) एक सीमा प्रदान करता है जिसके भीतर जनसंख्या पैरामीटर (जैसे माध्य या अनुपात) के गिरने की संभावना होती है। कई R सांख्यिकीय परीक्षण फ़ंक्शन स्वचालित रूप से कॉन्फिडेंस इंटरवल की गणना करते हैं।

  • t.test() डिफ़ॉल्ट रूप से माध्य के अंतर (या एकल माध्य) के लिए 95% CI लौटाता है। आप conf.level तर्क को बदलकर स्तर बदल सकते हैं (जैसे conf.level = 0.99)।
  • prop.test() अनुपात के लिए CI प्रदान करता है।
  • lm() या glm() मॉडल के लिए, confint() फ़ंक्शन गुणांकों के लिए CI की गणना करता है।
  • आप बूटस्ट्रैपिंग (bootstrapping) तकनीकों (जैसे boot पैकेज का उपयोग करके) का उपयोग करके भी CI की गणना कर सकते हैं।


# t.test से कॉन्फिडेंस इंटरवल प्राप्त करना

t_test_result <- t.test(student_data$Score, conf.level = 0.95)

confidence_interval <- t_test_result$conf.int

print("Mean Score के लिए 95% Confidence Interval:")

print(confidence_interval)

# रिग्रेशन गुणांक के लिए कॉन्फिडेंस इंटरवल

regression_model <- lm(Score ~ ID, data = student_data)

conf_intervals_coeffs <- confint(regression_model, level = 0.95)

print("Regression Coefficients के लिए 95% Confidence Intervals:")

print(conf_intervals_coeffs)

17. R में मशीन लर्निंग मॉडल कैसे बनाएं? (How to Build Machine Learning Models in R?)

R मशीन लर्निंग के लिए एक शक्तिशाली मंच है, जिसमें विभिन्न प्रकार के एल्गोरिदम और वर्कफ़्लो प्रबंधन के लिए पैकेज उपलब्ध हैं।

सामान्य चरण (General Steps):

  1. समस्या परिभाषित करें (Define Problem): क्या यह वर्गीकरण (classification), प्रतिगमन (regression), क्लस्टरिंग (clustering) आदि है?
  2. डेटा तैयार करें (Prepare Data): डेटा एकत्र करें, साफ करें, प्रीप्रोसेस करें (स्केलिंग, एन्कोडिंग), और प्रशिक्षण/परीक्षण सेट में विभाजित करें।
  3. मॉडल चुनें (Choose Model): समस्या और डेटा के आधार पर उपयुक्त एल्गोरिथम चुनें।
  4. मॉडल प्रशिक्षित करें (Train Model): प्रशिक्षण डेटा का उपयोग करके मॉडल को प्रशिक्षित करें।
  5. मॉडल का मूल्यांकन करें (Evaluate Model): परीक्षण डेटा का उपयोग करके मॉडल के प्रदर्शन का मूल्यांकन करें।
  6. मॉडल ट्यून करें (Tune Model): सर्वश्रेष्ठ प्रदर्शन के लिए मॉडल के हाइपरपैरामीटर समायोजित करें।
  7. पूर्वानुमान लगाएं (Make Predictions): नए, अनदेखे डेटा पर पूर्वानुमान लगाने के लिए प्रशिक्षित मॉडल का उपयोग करें।

लोकप्रिय ML पैकेज (Popular ML Packages):

  • caret: वर्गीकरण और प्रतिगमन प्रशिक्षण के लिए एक व्यापक ढाँचा। डेटा विभाजन, प्रीप्रोसेसिंग, मॉडल प्रशिक्षण, हाइपरपैरामीटर ट्यूनिंग और मूल्यांकन को सुव्यवस्थित करता है।
  • tidymodels: tidyverse सिद्धांतों के साथ एकीकृत एक आधुनिक ML ढाँचा (caret का उत्तराधिकारी माना जाता है)।
  • randomForest: रैंडम फॉरेस्ट एल्गोरिथम के लिए।
  • e1071: सपोर्ट वेक्टर मशीन (SVM), Naive Bayes, और अन्य के लिए।
  • rpart: डिसीजन ट्री के लिए।
  • glmnet: नियमितीकृत रिग्रेशन (रिज, लासो) के लिए।
  • xgboost, lightgbm: ग्रेडिएंट बूस्टिंग मशीनों के लिए।
  • keras, tensorflow: डीप लर्निंग के लिए R इंटरफेस।

18. R में सुपरवाइज्ड लर्निंग कैसे करें? (How to Perform Supervised Learning in R?)

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

  • वर्गीकरण (Classification): आउटपुट एक श्रेणी है (जैसे 'पास'/'फेल', 'स्पैम'/'नॉट स्पैम')। एल्गोरिदम: लॉजिस्टिक रिग्रेशन, SVM, डिसीजन ट्री, रैंडम फॉरेस्ट, Naive Bayes।
  • प्रतिगमन (Regression): आउटपुट एक निरंतर मान है (जैसे स्कोर, मूल्य)। एल्गोरिदम: लीनियर रिग्रेशन, रैंडम फॉरेस्ट रिग्रेशन, SVR।

caret पैकेज का उपयोग करके एक उदाहरण वर्कफ़्लो:



# caret पैकेज इंस्टॉल और लोड करें

# install.packages("caret")

# install.packages("e1071") # उदाहरण के लिए आवश्यक हो सकता है

library(caret)

# डेटा तैयार करें (iris डेटासेट का उपयोग करें)

data(iris)

dataset <- iris

# डेटा को प्रशिक्षण और परीक्षण सेट में विभाजित करें

set.seed(123) # पुनरुत्पादन के लिए

trainIndex <- createDataPartition(dataset$Species, p = 0.8, list = FALSE, times = 1)

training_set <- dataset[trainIndex,]

testing_set <- dataset[-trainIndex,]

# मॉडल प्रशिक्षण (उदाहरण: रैंडम फॉरेस्ट)

# नियंत्रण पैरामीटर सेट करें (जैसे क्रॉस-वैलिडेशन)

control <- trainControl(method = "cv", number = 10) # 10-गुना क्रॉस-वैलिडेशन

metric <- "Accuracy"

# मॉडल प्रशिक्षित करें

set.seed(7)

rf_model <- train(Species ~ ., data = training_set, method = "rf", # rf = रैंडम फॉरेस्ट

                  metric = metric, trControl = control)

# सर्वश्रेष्ठ मॉडल प्रिंट करें

print(rf_model)

# परीक्षण सेट पर पूर्वानुमान लगाएं

predictions <- predict(rf_model, testing_set)

# प्रदर्शन का मूल्यांकन करें (Confusion Matrix)

confusionMatrix(predictions, testing_set$Species)

19. R में अनसुपरवाइज्ड लर्निंग कैसे करें? (How to Perform Unsupervised Learning in R?)

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

  • क्लस्टरिंग (Clustering): समान विशेषताओं वाले डेटा बिंदुओं को समूहों में समूहित करना। एल्गोरिदम: K-मीन्स (kmeans()), पदानुक्रमित क्लस्टरिंग (hclust()), DBSCAN।
  • आयाम में कमी (Dimensionality Reduction): डेटा में चरों (आयामों) की संख्या को कम करना, जबकि महत्वपूर्ण जानकारी को बनाए रखना। तकनीकें: प्रिंसिपल कंपोनेंट एनालिसिस (PCA) (prcomp(), princomp()), t-SNE।
  • एसोसिएशन रूल माइनिंग (Association Rule Mining): आइटमसेट के बीच संबंधों की खोज करना (जैसे "जो लोग ब्रेड खरीदते हैं वे मक्खन भी खरीदते हैं")। एल्गोरिदम: Apriori (arules पैकेज)।


# क्लस्टरिंग उदाहरण: K-मीन्स (iris डेटा का उपयोग करके, Species कॉलम को हटाकर)

# केवल संख्यात्मक विशेषताओं का चयन करें

iris_features <- iris[, 1:4]

# डेटा को स्केल करना अक्सर K-मीन्स के लिए अच्छा होता है

scaled_features <- scale(iris_features)

# K-मीन्स क्लस्टरिंग लागू करें (मान लें कि हम 3 क्लस्टर चाहते हैं)

set.seed(100)

kmeans_result <- kmeans(scaled_features, centers = 3, nstart = 25) # nstart स्थिरता में मदद करता है

# क्लस्टर असाइनमेंट देखें

print(kmeans_result$cluster)

# क्लस्टर केंद्रों को देखें

print(kmeans_result$centers)

# क्लस्टर परिणामों की कल्पना करें (PCA का उपयोग करके)

pca_result <- prcomp(scaled_features)

pca_data <- data.frame(pca_result$x[, 1:2], Cluster = as.factor(kmeans_result$cluster))

library(ggplot2)

ggplot(pca_data, aes(x = PC1, y = PC2, color = Cluster)) +

  geom_point(size = 3) +

  labs(title = "K-Means Clustering Results (PCA Visualization)") +

  theme_minimal()

# PCA उदाहरण

pca_summary <- summary(pca_result)

print(pca_summary) # देखें कि प्रत्येक घटक कितना प्रसरण समझाता है

20. R में मॉडल चयन और मूल्यांकन कैसे करें? (How to Perform Model Selection and Evaluation in R?)

सही मॉडल चुनना और उसके प्रदर्शन का निष्पक्ष रूप से मूल्यांकन करना महत्वपूर्ण है।

मॉडल चयन (Model Selection):

  • क्रॉस-वैलिडेशन (Cross-Validation): डेटा को कई फोल्ड में विभाजित करके मॉडल के प्रदर्शन का अधिक मजबूत अनुमान प्राप्त करने की तकनीक (जैसे k-fold CV)। caret और tidymodels में इसे लागू करना आसान है।
  • हाइपरपैरामीटर ट्यूनिंग (Hyperparameter Tuning): मॉडल के पैरामीटर (जिन्हें डेटा से नहीं सीखा जाता है, जैसे रैंडम फॉरेस्ट में पेड़ों की संख्या) को अनुकूलित करने के लिए ग्रिड सर्च, रैंडम सर्च या बायेसियन ऑप्टिमाइज़ेशन जैसी तकनीकों का उपयोग करना। caret::train() में tuneGrid या tuneLength तर्क होते हैं।
  • फ़ीचर चयन (Feature Selection): प्रदर्शन में सुधार या मॉडल को सरल बनाने के लिए सबसे प्रासंगिक विशेषताओं का चयन करना।

मॉडल मूल्यांकन (Model Evaluation):

उपयोग किए जाने वाले मेट्रिक्स समस्या के प्रकार पर निर्भर करते हैं:

  • वर्गीकरण मेट्रिक्स (Classification Metrics):
    • सटीकता (Accuracy): सही पूर्वानुमानों का कुल अनुपात।
    • संवेदनशीलता (Sensitivity/Recall): वास्तविक पॉजिटिव में से कितने सही ढंग से पहचाने गए।
    • विशिष्टता (Specificity): वास्तविक नेगेटिव में से कितने सही ढंग से पहचाने गए।
    • परिशुद्धता (Precision): पॉजिटिव पूर्वानुमानों में से कितने वास्तव में पॉजिटिव थे।
    • F1-स्कोर: परिशुद्धता और रिकॉल का हार्मोनिक माध्य।
    • AUC (Area Under the ROC Curve): ROC वक्र के तहत क्षेत्र, समग्र प्रदर्शन का माप।
    • Confusion Matrix: वास्तविक बनाम अनुमानित वर्गों को सारणीबद्ध करता है। caret::confusionMatrix()
  • प्रतिगमन मेट्रिक्स (Regression Metrics):
    • MAE (Mean Absolute Error): औसत निरपेक्ष त्रुटि।
    • MSE (Mean Squared Error): औसत वर्ग त्रुटि।
    • RMSE (Root Mean Squared Error): वर्गित त्रुटियों के माध्य का वर्गमूल (मूल इकाई में त्रुटि)।
    • R-स्क्वायर (R-squared): आश्रित चर में प्रसरण का अनुपात जो स्वतंत्र चर द्वारा समझाया गया है।
    • Adjusted R-स्क्वायर: मॉडल में प्रिडिक्टर्स की संख्या के लिए R-स्क्वायर को समायोजित करता है।


# caret में मूल्यांकन का उदाहरण (ऊपर वर्गीकरण उदाहरण से जारी)

# confusionMatrix पहले ही विभिन्न मेट्रिक्स दिखाता है

conf_matrix <- confusionMatrix(predictions, testing_set$Species)

print(conf_matrix)

# विशिष्ट मेट्रिक्स निकालना

accuracy <- conf_matrix$overall['Accuracy']

print(paste("Accuracy:", accuracy))

# प्रतिगमन मूल्यांकन (ऊपर lm मॉडल का उपयोग करके)

summary(regression_model) # R-squared और Adjusted R-squared देता है

# RMSE की गणना (उदाहरण)

actual_scores <- student_data$Score

predicted_lm_scores <- predict(regression_model, student_data)

rmse <- sqrt(mean((actual_scores - predicted_lm_scores)^2))

print(paste("RMSE for lm model:", rmse))

21. & 22. R में डेटा कैसे इम्पोर्ट और एक्सपोर्ट करें? (How to Import and Export Data in R?)

R विभिन्न फ़ाइल स्वरूपों से डेटा पढ़ (इम्पोर्ट) और लिख (एक्सपोर्ट) सकता है।

डेटा इम्पोर्ट करना (Importing Data):

  • CSV फ़ाइलें (.csv): read.csv("file_path.csv")। कॉमन तर्क: header=TRUE/FALSE, sep=",", stringsAsFactors=FALSE (आधुनिक R में डिफ़ॉल्ट)।
  • टेक्स्ट फ़ाइलें (.txt): read.table("file_path.txt", header=TRUE/FALSE, sep="\t") (टैब-सीमांकित के लिए sep="\t")।
  • एक्सेल फ़ाइलें (.xlsx, .xls): readxl पैकेज (read_excel() फ़ंक्शन) या openxlsx पैकेज। 
    # install.packages("readxl")

library(readxl)

excel_data <- read_excel("path/to/your/file.xlsx", sheet = "Sheet1")
  • अन्य सांख्यिकीय सॉफ्टवेयर फ़ाइलें: haven पैकेज SPSS (.sav), Stata (.dta), और SAS (.sas7bdat) फ़ाइलों को पढ़ने के लिए (read_spss(), read_dta(), read_sas())।
  • JSON फ़ाइलें: jsonlite पैकेज (fromJSON())।
  • डेटाबेस: DBI और विशिष्ट डेटाबेस बैकएंड पैकेज (जैसे RPostgreSQL, RMariaDB, odbc)।

डेटा एक्सपोर्ट करना (Exporting Data):

  • CSV फ़ाइलें: write.csv(your_dataframe, "output_file.csv", row.names = FALSE) (row.names=FALSE आमतौर पर वांछित होता है)।
  • टेक्स्ट फ़ाइलें: write.table(your_dataframe, "output_file.txt", sep = "\t", row.names = FALSE, quote = FALSE)।
  • एक्सेल फ़ाइलें: writexl पैकेज (write_xlsx()) या openxlsx पैकेज। 
    # install.packages("writexl")

library(writexl)

write_xlsx(your_dataframe, "output_file.xlsx")
  • R डेटा फ़ाइलें (.RData, .rds):
    • save(object1, object2, file="my_data.RData"): एकाधिक R ऑब्जेक्ट्स को सहेजता है। इन्हें load("my_data.RData") का उपयोग करके लोड किया जाता है।
    • saveRDS(single_object, file="my_object.rds"): एक एकल R ऑब्जेक्ट को सहेजता है। इसे readRDS("my_object.rds") का उपयोग करके लोड किया जाता है और एक वेरिएबल को असाइन किया जाना चाहिए। .rds अक्सर पसंदीदा होता है।


# CSV इम्पोर्ट उदाहरण

# मान लें कि 'sample_data.csv' नामक एक फ़ाइल है

# data <- read.csv("sample_data.csv")

# CSV एक्सपोर्ट उदाहरण (student_data का उपयोग करके)

write.csv(student_data, "student_output.csv", row.names = FALSE)

# RDS ऑब्जेक्ट को सहेजना और पढ़ना

saveRDS(student_data, "student_data.rds")

loaded_student_data <- readRDS("student_data.rds")

print(identical(student_data, loaded_student_data)) # जांचें कि क्या वे समान हैं (TRUE होना चाहिए)

23. R में विभिन्न फाइल फॉर्मेट कैसे पढ़ें और लिखें? (How to Read and Write Different File Formats in R?)

यह प्रश्न पिछले अनुभाग (21 और 22) में विस्तृत रूप से कवर किया गया है। मुख्य बात यह याद रखना है कि विभिन्न प्रारूपों के लिए विशिष्ट फ़ंक्शन या पैकेज की आवश्यकता होती है:

  • CSV/टेक्स्ट: बेस R (read.csv, write.csv, read.table, write.table)
  • एक्सेल: readxl (पढ़ना), writexl (लिखना), openxlsx (पढ़ना/लिखना/फॉर्मेटिंग)
  • SPSS/Stata/SAS: haven
  • JSON: jsonlite
  • R ऑब्जेक्ट्स: बेस R (save, load, saveRDS, readRDS)
  • डेटाबेस: DBI + ड्राइवर (जैसे RPostgreSQL)
  • वेब से डेटा: httr, rvest (वेब स्क्रैपिंग के लिए)

24. & 25. R में पैकेज कैसे इंस्टॉल और लोड करें? (How to Install and Load Packages in R?)

पैकेज R की कार्यक्षमता का विस्तार करते हैं। CRAN (Comprehensive R Archive Network) पर हजारों पैकेज उपलब्ध हैं।

पैकेज इंस्टॉल करना (Installing Packages):

आप install.packages() फ़ंक्शन का उपयोग करके CRAN से पैकेज इंस्टॉल करते हैं। आपको इसे केवल एक बार करने की आवश्यकता है (या जब आप पैकेज को अपडेट करना चाहते हैं)।



# एक पैकेज इंस्टॉल करना (जैसे dplyr)

install.packages("dplyr")

# एक साथ कई पैकेज इंस्टॉल करना

install.packages(c("ggplot2", "readxl", "caret"))

पैकेज लोड करना (Loading Packages):

किसी पैकेज के फ़ंक्शंस का उपयोग करने के लिए, आपको उसे अपनी वर्तमान R सत्र में लोड करना होगा। यह library() या require() फ़ंक्शन का उपयोग करके किया जाता है। आपको हर बार एक नया R सत्र शुरू करने पर पैकेज लोड करने की आवश्यकता होती है।



# dplyr पैकेज लोड करना

library(dplyr)

# ggplot2 पैकेज लोड करना

library(ggplot2)

# require() का उपयोग करना (आमतौर पर फ़ंक्शंस या स्क्रिप्ट के अंदर उपयोग किया जाता है)

if (require(readxl)) {

  # readxl सफलतापूर्वक लोड हो गया

  print("readxl पैकेज लोड हो गया।")

} else {

  print("readxl पैकेज इंस्टॉल नहीं है या लोड नहीं हो सका।")

  # install.packages("readxl") # यदि आवश्यक हो तो इंस्टॉल करें

}

library() बनाम require():

  • library(package): यदि पैकेज लोड नहीं हो पाता है तो एक त्रुटि देता है। आमतौर पर स्क्रिप्ट की शुरुआत में इंटरेक्टिव रूप से या उपयोग के लिए पसंद किया जाता है।
  • require(package): यदि पैकेज लोड नहीं हो पाता है तो एक चेतावनी देता है और FALSE लौटाता है। यह फ़ंक्शंस के अंदर उपयोगी है जहाँ आप जांचना चाहते हैं कि क्या कोई पैकेज उपलब्ध है और तदनुसार कार्य करना है।

26. R में कस्टम पैकेज कैसे बनाएं? (How to Create Custom Packages in R?)

अपने स्वयं के R पैकेज बनाना आपके कोड को व्यवस्थित करने, साझा करने और पुन: उपयोग करने का एक शानदार तरीका है। यह एक उन्नत विषय है, लेकिन मूल चरण इस प्रकार हैं:

  1. सेटअप (Setup):
    • devtools और roxygen2 पैकेज इंस्टॉल करें: install.packages(c("devtools", "roxygen2"))
    • RStudio प्रोजेक्ट का उपयोग करना सहायक होता है।
  2. पैकेज संरचना बनाना (Create Package Structure):
    • RStudio में: File -> New Project -> New Directory -> R Package.
    • या devtools::create("yourPackageName") का उपयोग करें।
    • यह आवश्यक निर्देशिकाएँ (जैसे R/, man/) और फ़ाइलें (जैसे DESCRIPTION, NAMESPACE) बनाएगा।
  3. फ़ंक्शन लिखना (Write Functions):
    • अपने R फ़ंक्शन लिखें और उन्हें R/ निर्देशिका में .R फ़ाइलों के रूप में सहेजें।
  4. दस्तावेज़ीकरण (Documentation):
    • roxygen2 टिप्पणियों का उपयोग करके अपने फ़ंक्शंस के ठीक ऊपर दस्तावेज़ लिखें। ये विशेष टिप्पणियाँ (#' से शुरू) फ़ंक्शन क्या करता है, उसके पैरामीटर क्या हैं, वह क्या लौटाता है, और उदाहरण प्रदान करते हैं।
    • devtools::document() चलाएँ। यह roxygen टिप्पणियों से man/ निर्देशिका में दस्तावेज़ीकरण फ़ाइलें (.Rd) और NAMESPACE फ़ाइल उत्पन्न करेगा।
  5. निर्भरताएँ जोड़ना (Add Dependencies):
    • यदि आपका पैकेज अन्य पैकेजों पर निर्भर करता है, तो उन्हें DESCRIPTION फ़ाइल में (जैसे Imports: फ़ील्ड में) सूचीबद्ध करें। फ़ंक्शंस में बाहरी पैकेज फ़ंक्शंस का उपयोग करते समय packageName::functionName() का उपयोग करें या उन्हें NAMESPACE में आयात करें।
  6. जाँचना और बनाना (Check and Build):
    • devtools::check() चलाएँ: यह सुनिश्चित करने के लिए कि आपका पैकेज CRAN मानकों को पूरा करता है, विभिन्न जाँचें करता है।
    • devtools::install(): अपने पैकेज को स्थानीय रूप से इंस्टॉल और लोड करता है ताकि आप इसका परीक्षण कर सकें।
    • devtools::build(): साझा करने या जमा करने के लिए पैकेज का एक टार्बॉल (.tar.gz) बनाता है।

यह प्रक्रिया का एक सरलीकृत अवलोकन है। पैकेज विकास में विगनेट्स (vignettes), परीक्षण (testing), और संस्करण नियंत्रण (version control) जैसे अतिरिक्त पहलू शामिल हो सकते हैं।

27. R में फंक्शन कैसे बनाएं? (How to Create Functions in R?)

फ़ंक्शन कोड के पुन: प्रयोज्य ब्लॉक होते हैं जो एक विशिष्ट कार्य करते हैं। वे आपके कोड को मॉड्यूलर, पढ़ने में आसान और बनाए रखने में आसान बनाते हैं।

सिंटेक्स (Syntax):



function_name <- function(argument1, argument2, ...) {

  # फंक्शन का कोड (गणना, क्रियाएं)

  # ...

  # वैकल्पिक: एक मान लौटाना

  return(result_value)

  # या, R में अंतिम मूल्यांकनित व्यंजक स्वचालित रूप से वापस आ जाता है

  # result_value

}
  • function_name: वह नाम जिससे आप फ़ंक्शन को कॉल करेंगे।
  • function: फ़ंक्शन बनाने के लिए कीवर्ड।
  • argument1, argument2: इनपुट मान (पैरामीटर) जो फ़ंक्शन स्वीकार करता है। आप डिफ़ॉल्ट मान भी प्रदान कर सकते हैं (जैसे argument1 = default_value)।
  • {...}: फ़ंक्शन का मुख्य भाग, जिसमें R कोड होता है।
  • return(result_value): वैकल्पिक रूप से फ़ंक्शन से एक आउटपुट मान लौटाता है। यदि return() का उपयोग नहीं किया जाता है, तो फ़ंक्शन के मुख्य भाग में अंतिम मूल्यांकनित व्यंजक वापस आ जाता है।


# उदाहरण 1: दो संख्याओं को जोड़ने वाला एक सरल फ़ंक्शन

add_numbers <- function(x, y) {

  sum_result <- x + y

  return(sum_result)

}

# फ़ंक्शन को कॉल करना

result <- add_numbers(5, 3)

print(result) # आउटपुट: 8

# उदाहरण 2: डिफ़ॉल्ट मान वाला फ़ंक्शन

greet <- function(name, greeting = "नमस्ते") {

  message <- paste(greeting, ",", name, "!")

  print(message)

}

# फ़ंक्शन को कॉल करना

greet("दुनिया")        # आउटपुट: नमस्ते , दुनिया !

greet("Alice", "Hello") # आउटपुट: Hello , Alice !

# उदाहरण 3: अंतिम व्यंजक स्वचालित रूप से वापस आता है

multiply_numbers <- function(a, b) {

  a * b # कोई return() नहीं, लेकिन यह मान वापस आ जाएगा

}

product <- multiply_numbers(4, 6)

print(product) # आउटपुट: 24

28. R में लूप और कंडीशनल स्टेटमेंट कैसे उपयोग करें? (How to Use Loops and Conditional Statements in R?)

लूप और कंडीशनल स्टेटमेंट प्रोग्राम के प्रवाह को नियंत्रित करने के लिए मौलिक हैं।

कंडीशनल स्टेटमेंट (Conditional Statements):

ये आपको शर्तों के आधार पर कोड के ब्लॉक निष्पादित करने की अनुमति देते हैं।

  • if स्टेटमेंट: यदि कोई शर्त सत्य है तो कोड निष्पादित करता है। 
    

x <- 10

if (x > 5) {

  print("x 5 से बड़ा है")

}
  • if-else स्टेटमेंट: यदि शर्त सत्य है तो एक ब्लॉक निष्पादित करता है, अन्यथा दूसरा ब्लॉक निष्पादित करता है। 
    

y <- -3

if (y >= 0) {

  print("y गैर-ऋणात्मक है")

} else {

  print("y ऋणात्मक है")

}
  • if-else if-else स्टेटमेंट: एकाधिक शर्तों की जाँच करता है। 
    

score <- 75

if (score >= 90) {

  grade <- "A"

} else if (score >= 80) {

  grade <- "B"

} else if (score >= 70) {

  grade <- "C"

} else {

  grade <- "D"

}

print(paste("Grade:", grade)) # आउटपुट: Grade: C
  • ifelse() फ़ंक्शन: वेक्टराइज्ड कंडीशनल असाइनमेंट के लिए एक संक्षिप्त तरीका। ifelse(condition, value_if_true, value_if_false) 
    

numbers <- c(1, -2, 3, -4, 5)

sign_desc <- ifelse(numbers >= 0, "Positive/Zero", "Negative")

print(sign_desc) # आउटपुट: "Positive/Zero" "Negative" "Positive/Zero" "Negative" "Positive/Zero"

लूप्स (Loops):

लूप कोड के एक ब्लॉक को बार-बार निष्पादित करते हैं।

  • for लूप: एक अनुक्रम (sequence) या वेक्टर के प्रत्येक आइटम के लिए पुनरावृति करता है। 
    

# 1 से 5 तक संख्याओं का वर्ग प्रिंट करें

for (i in 1:5) {

  square <- i * i

  print(paste("Square of", i, "is", square))

}

# एक वेक्टर के माध्यम से पुनरावृति करें

colors <- c("red", "green", "blue")

for (col in colors) {

  print(paste("Current color:", col))

}
  • while लूप: जब तक कोई शर्त सत्य रहती है तब तक कोड निष्पादित करता है। सुनिश्चित करें कि स्थिति अंततः झूठी हो जाए, अन्यथा आपको एक अनंत लूप मिलेगा! 
    

count <- 1

while (count <= 5) {

  print(paste("Count is:", count))

  count <- count + 1 # काउंटर बढ़ाना महत्वपूर्ण है!

}
  • repeat लूप: कोड को अनिश्चित काल तक निष्पादित करता है जब तक कि break स्टेटमेंट का सामना न हो। आमतौर पर if स्टेटमेंट के साथ प्रयोग किया जाता है। 
    

x <- 0

repeat {

  print(x)

  x <- x + 1

  if (x > 3) {

    break # लूप से बाहर निकलें

  }

}
  • लूप नियंत्रण स्टेटमेंट:
    • break: वर्तमान लूप (for, while, repeat) से तुरंत बाहर निकलता है।
    • next: लूप के वर्तमान पुनरावृत्ति को छोड़ देता है और अगले पर जाता है।
    

# next का उदाहरण: विषम संख्याएँ छोड़ें

for(i in 1:10) {

  if(i %% 2 != 0) { # यदि i विषम है

    next

  }

  print(paste("Even number:", i))

}

महत्वपूर्ण नोट: R में, लूप का उपयोग अक्सर आवश्यक नहीं होता है क्योंकि कई ऑपरेशन वेक्टराइज्ड होते हैं (अगला भाग देखें)। वेक्टराइज्ड कोड आमतौर पर लूप से तेज़ और लिखने में आसान होता है।

29. R में वेक्टराइज्ड ऑपरेशन कैसे करें? (How to Perform Vectorized Operations in R?)

वेक्टराइजेशन R की प्रमुख शक्तियों में से एक है। इसका मतलब है कि ऑपरेशन्स या फ़ंक्शन्स को पूरे वैक्टर (या मैट्रिसेस, डेटा फ्रेम कॉलम) पर एक साथ लागू किया जा सकता है, बिना स्पष्ट for लूप लिखे। यह कोड को अधिक संक्षिप्त, पढ़ने में आसान और अक्सर बहुत तेज़ बनाता है क्योंकि अंतर्निहित कार्यान्वयन आमतौर पर C या फोरट्रान में अनुकूलित होते हैं।

उदाहरण:

मान लीजिए आप किसी संख्यात्मक वेक्टर के प्रत्येक तत्व में 5 जोड़ना चाहते हैं।

लूप दृष्टिकोण (Loop Approach - कम पसंदीदा):



numbers <- c(10, 20, 30, 40, 50)

result_loop <- numeric(length(numbers)) # परिणाम के लिए एक खाली वेक्टर बनाएं

for (i in 1:length(numbers)) {

  result_loop[i] <- numbers[i] + 5

}

print(result_loop)

वेक्टराइज्ड दृष्टिकोण (Vectorized Approach - पसंदीदा):



numbers <- c(10, 20, 30, 40, 50)

result_vectorized <- numbers + 5 # सीधा, संक्षिप्त और तेज़!

print(result_vectorized)

अन्य वेक्टराइज्ड ऑपरेशन:

  • सभी अरिथमेटिक ऑपरेटर (+, -, *, /, ^, आदि) वेक्टराइज्ड हैं।
  • सभी रिलेशनल ऑपरेटर (>, <, ==, आदि) वेक्टराइज्ड हैं, जो एक लॉजिकल वेक्टर लौटाते हैं।
  • कई अंतर्निहित फ़ंक्शन वेक्टराइज्ड हैं: sqrt(), log(), exp(), sin(), cos(), abs(), round(), toupper(), tolower(), paste() (कुछ तर्कों के साथ)।
  • ifelse() वेक्टराइज्ड कंडीशनल लॉजिक के लिए बहुत उपयोगी है।
  • apply() परिवार के फ़ंक्शन (apply, lapply, sapply, tapply, mapply) डेटा संरचनाओं पर पुनरावृति करने और फ़ंक्शन लागू करने के लिए वेक्टराइज्ड विकल्प प्रदान करते हैं, अक्सर लूप से बेहतर।


# वेक्टराइज्ड लॉजिकल तुलना

high_scores_flag <- student_data$Score > 85

print(high_scores_flag) # आउटपुट: [1] FALSE  TRUE  TRUE FALSE

# वेक्टराइज्ड फ़ंक्शन का उपयोग

sqrt_scores <- sqrt(student_data$Score) # प्रत्येक स्कोर का वर्गमूल

print(sqrt_scores)

# lapply का उपयोग करके लिस्ट के प्रत्येक तत्व पर फ़ंक्शन लागू करना

my_list <- list(a = 1:5, b = rnorm(5)) # एक लिस्ट बनाएं

list_means <- lapply(my_list, mean) # प्रत्येक तत्व का माध्य गणना करें

print(list_means)

# sapply lapply के समान है लेकिन परिणाम को सरल बनाने का प्रयास करता है (जैसे वेक्टर में)

vector_means <- sapply(my_list, mean)

print(vector_means)

जब भी संभव हो, R में वेक्टराइज्ड ऑपरेशन्स का उपयोग करने का प्रयास करें। यह R कोड लिखने का मुहावरेदार (idiomatic) तरीका है और आमतौर पर बेहतर प्रदर्शन की ओर ले जाता है।

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

टिप्पणियाँ

एक टिप्पणी भेजें

इस ब्लॉग से लोकप्रिय पोस्ट

JavaScript basic to advance guide

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

Tool Room Lath Machine: A Complete Guide

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

html Post Creator introduction

🚀 HTML पोस्ट क्रिएटर: अब ब्लॉग पोस्ट बनाना हुआ आसान! क्या आप ब्लॉगिंग शुरू करना चाहते हैं, लेकिन HTML कोड के बारे में जानकर घबराते हैं? या फिर आप एक अनुभवी ब्लॉगर हैं जो अपने काम को और तेज़ करना चाहते हैं? तो आपके लिए HTML पोस्ट क्रिएटर एकदम सही समाधान है। यह एक अद्भुत AI-आधारित टूल है जो आपको बिना किसी तकनीकी ज्ञान के मिनटों में शानदार और आकर्षक ब्लॉग पोस्ट बनाने में मदद करता है। HTML पोस्ट क्रिएटर सिर्फ एक साधारण एडिटर नहीं है। यह एक स्मार्ट असिस्टेंट है जो आपके काम को आसान और क्रिएटिव बनाता है। ✨ यह कैसे काम करता है? इस टूल का इस्तेमाल करना बहुत आसान है। आपको बस अपनी पोस्ट के लिए सामग्री (कंटेंट) और डिज़ाइन के बारे में सोचना है, और बाकी का काम हमारा AI संभाल लेगा। 🎯 1. अपनी पोस्ट को आकर्षक टाइटल दें आप अपनी पोस्ट के लिए मैन्युअल रूप से टाइटल लिख सकते हैं या हमारे AI-सुझाव का उपयोग कर सकते हैं। बस अपने विषय को दर्ज करें, और AI आपको कई रचनात्मक और आकर्षक टाइटल सुझाएगा। साथ ही, आप अपनी पसंद के अनुसार टाइटल का रंग भी चुन स...
और पढ़ें