कई अव्यक्त वर्ग मॉडल से दृश्यमान परिणाम

Question

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

मुझे अक्सर यह समझने के लिए विभिन्न मॉडलों में देखने के लिए बहुत उपयोगी लगता है कि कक्षा = (i) के साथ मॉडल में वर्गीकृत टिप्पणियों को वर्ग = (i + 1) के साथ मॉडल द्वारा कैसे वितरित किया जाता है। बहुत कम से कम आप कभी-कभी बहुत मजबूत क्लस्टर पा सकते हैं जो मॉडल में कक्षाओं की संख्या की परवाह किए बिना मौजूद हैं।

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

क्या कोई मुझे सही दिशा में इशारा कर सकता है। नीचे एक उदाहरण डाटासेट पुन: पेश करने के लिए कोड है। प्रत्येक वेक्टर xi 100 अवलोकनों के वर्गीकरण का प्रतिनिधित्व करता है, जिसमें मैं संभव कक्षाओं के साथ एक मॉडल में हूं। मैं रेखांकन करना चाहता हूं कि कॉलम से कक्षा में कक्षा से कक्षा तक कैसे अवलोकन (पंक्तियाँ) चलती हैं।

x1 <- sample(1:1, 100, replace=T)
x2 <- sample(1:2, 100, replace=T)
x3 <- sample(1:3, 100, replace=T)
x4 <- sample(1:4, 100, replace=T)
x5 <- sample(1:5, 100, replace=T)

results <- cbind (x1, x2, x3, x4, x5)

मैं कल्पना करता हूं कि एक ग्राफ बनाने का एक तरीका है जहां नोड्स वर्गीकरण हैं और किनारों को दर्शाते हैं (वजन या रंग द्वारा) वर्गीकरण से एक मॉडल से दूसरे में जाने वाली टिप्पणियों का%। उदाहरण के लिए

अद्यतन: igraph पैकेज के साथ कुछ प्रगति कर रहा है। ऊपर दिए गए कोड से ...

poLCA परिणाम कक्षा सदस्यता का वर्णन करने के लिए समान संख्याओं को रीसायकल करता है, इसलिए आपको थोड़ा सा पुनरावर्तन करने की आवश्यकता है।

N<-ncol(results) 
n<-0
for(i in 2:N) {
results[,i]<- (results[,i])+((i-1)+n)
n<-((i-1)+n)
}

फिर आपको सभी क्रॉस-टेब्यूलेशन और उनकी आवृत्तियों को प्राप्त करने की आवश्यकता है, और उन्हें सभी किनारों को परिभाषित करने वाले एक मैट्रिक्स में rbind करें। ऐसा करने के लिए शायद बहुत अधिक सुरुचिपूर्ण तरीका है।

results <-as.data.frame(results)

g1           <- count(results,c("x1", "x2"))

g2           <- count(results,c("x2", "x3"))
colnames(g2) <- c("x1", "x2", "freq")

g3           <- count(results,c("x3", "x4"))
colnames(g3) <- c("x1", "x2", "freq")

g4           <- count(results,c("x4", "x5"))
colnames(g4) <- c("x1", "x2", "freq")

results <- rbind(g1, g2, g3, g4)

library(igraph)

g1 <- graph.data.frame(results, directed=TRUE)

plot.igraph(g1, layout=layout.reingold.tilford)

आईग्राफ विकल्पों के साथ अधिक खेलने का समय मुझे लगता है।

Comments

यदि आपको कोई समाधान मिलता है जो आपको संतुष्ट करता है, तो आप अपने कोड को उत्तर के रूप में भी पोस्ट कर सकते हैं

— गाला

यह कुछ-कुछ परसेट की तरह हो रहा है । R कार्यान्वयन के लिए ggparallel देखें ।

— एंडी डब्ल्यू

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

— chl

Answer 1

अब तक, सबसे अच्छा विकल्प जो मैंने पाया है, आपके सुझावों के लिए धन्यवाद, ये हैं:

  library (igraph)
  library (ggparallel)

# Generate random data

  x1 <- sample(1:1, 1000, replace=T)
  x2 <- sample(2:3, 1000, replace=T)
  x3 <- sample(4:6, 1000, replace=T)
  x4 <- sample(7:10, 1000, replace=T)
  x5 <- sample(11:15, 1000, replace=T)
  results <- cbind (x1, x2, x3, x4, x5)
  results <-as.data.frame(results)

# Make a data frame for the edges and counts

  g1           <- count (results, c("x1", "x2"))

  g2           <- count (results, c("x2", "x3"))
  colnames(g2) <- c     ("x1", "x2", "freq")

  g3           <- count (results, c("x3", "x4"))
  colnames(g3) <- c     ("x1", "x2", "freq")

  g4           <- count (results, c("x4", "x5"))
  colnames(g4) <- c     ("x1", "x2", "freq")

  edges        <- rbind (g1, g2, g3, g4)

# Make a data frame for the class sizes

  h1            <- count (results, c("x1"))

  h2            <- count (results, c("x2"))
  colnames (h2) <- c     ("x1", "freq")

  h3            <- count (results, c("x3"))
  colnames (h3) <- c     ("x1", "freq")

  h4            <- count (results, c("x4"))
  colnames (h4) <- c     ("x1", "freq")

  h5            <- count (results, c("x5"))
  colnames (h5) <- c     ("x1", "freq")

  cSizes        <- rbind (h1, h2, h3, h4, h5)

# Graph with igraph

  gph    <- graph.data.frame (edges, directed=TRUE)

  layout <- layout.reingold.tilford (gph, root = 1)
  plot (gph,
        layout           = layout,
        edge.label       = edges$freq, 
        edge.curved      = FALSE,
        edge.label.cex   = .8,
        edge.label.color = "black",
        edge.color       = "grey",
        edge.arrow.mode  = 0,
        vertex.label     = cSizes$x1 , 
        vertex.shape     = "square",
        vertex.size      = cSizes$freq/20)

# The same idea, using ggparallel

  a <- c("x1", "x2", "x3", "x4", "x5")

  ggparallel (list (a), 
              data        = results, 
              method      = "hammock", 
              asp         = .7, 
              alpha       = .5, 
              width       = .5, 
              text.angle = 0)

Igraph के साथ किया

पूर्ण के साथ किया

फिर भी एक पत्रिका में साझा करने के लिए बहुत मुश्किल है, लेकिन मैं निश्चित रूप से इन बहुत उपयोगी पर एक त्वरित देखो पाया है।

स्टैक ओवरफ्लो पर इस सवाल से एक संभावित विकल्प भी है , लेकिन मुझे अभी तक इसे लागू करने का मौका नहीं मिला है; और यहाँ एक और संभावना ।

Comments

उदाहरण पोस्ट करने के लिए धन्यवाद। CV पर यह पोस्ट R में ParSets भूखंडों के लिए कुछ अच्छे कोड दिखाता है (खेद है कि पहले बताया जाना चाहिए)। Ggparallel package में मेरा फ़ॉरेस्ट बताता है कि यह किनारों के आस-पास काफ़ी उबड़-खाबड़ है (हालांकि आपके जैसे रैंडम डेटा ParSets के लिए अच्छा IMO नहीं दिखेंगे)।

— एंडी डब्ल्यू