आर का उपयोग कर ब्लॉग के बीच लिंक नेटवर्क मैपिंग?

Question

मुझे ब्लॉग के बीच एक लिंक मैप बनाने और विज़ुअलाइज़ करने के बारे में कोई सलाह चाहिए ताकि उनके बीच "सोशल नेटवर्क" को प्रतिबिंबित किया जा सके।

यहाँ है कि कैसे मैं यह कर की सोच रहा हूँ: एक (या अधिक) ब्लॉग मुख पृष्ठ के साथ

1. आरंभ और (उस पृष्ठ पर सभी लिंक
2. सभी लिंक आंतरिक लिंक निकाल दें इकट्ठा यही है, अगर मैं www.website.com से शुरू करता हूं। तो मैं आकार "www.website.com/***" से सभी लिंक को हटाना चाहता हूं)। लेकिन सभी बाहरी लिंक स्टोर करें।
3. इन लिंक में से प्रत्येक पर जाएं (मान लीजिए कि आपने पहले से उनका दौरा नहीं किया है), और चरण 1 दोहराएं।
4. तब तक जारी रखें जब तक (पहले कहें) एक्स पहले पृष्ठ से कूदता है।
5. एकत्रित डेटा प्लॉट करें।

मैं कल्पना है कि आदेश आर में यह करने के लिए में, एक, igraph की तरह कुछ के साथ संयुक्त (आपका जवाब here के लिए धन्यवाद शेन) RCurl/एक्सएमएल का प्रयोग करेंगे।

लेकिन चूंकि मुझे उनमें से किसी के साथ अनुभव नहीं है, तो क्या कोई ऐसा व्यक्ति है जो मुझे सही करने के लिए तैयार हो सकता है अगर मैं किसी भी महत्वपूर्ण कदम को याद करता हूं, या इस कार्य को अनुमति देने के लिए कोड का कोई उपयोगी स्निपेट संलग्न करता हूं?

ps: इस प्रश्न के लिए मेरी प्रेरणा यह है कि एक सप्ताह में मैं "ब्लॉगिंग और आर" पर उपयोग 2010 पर एक बात कर रहा हूं, और मैंने सोचा कि यह दर्शकों को कुछ मजा देने का एक अच्छा तरीका हो सकता है और साथ ही उन्हें इस तरह कुछ करने के लिए प्रेरित करें।

बहुत बहुत धन्यवाद!

ताल

Answer 1

एनबी: यह उदाहरण लिंक प्राप्त करने का एक बहुत ही बुनियादी तरीका है और इसलिए अधिक मजबूत होने के लिए इसे tweaked की आवश्यकता होगी। :)

मुझे नहीं पता कि यह कोड कितना उपयोगी है, लेकिन उम्मीद है कि यह आपको दिशा में जाने का निर्देश दे सकता है (बस इसे कॉपी करें और इसे आर में पेस्ट करें, यह इंस्टॉल करने के बाद एक स्वयं निहित उदाहरण है संकुल RCurl और एक्सएमएल):

library(RCurl) 
library(XML) 

get.links.on.page <- function(u) { 
    doc <- getURL(u) 
    html <- htmlTreeParse(doc, useInternalNodes = TRUE) 
    nodes <- getNodeSet(html, "//html//body//a[@href]") 
    urls <- sapply(nodes, function(x) x <- xmlAttrs(x)[[1]]) 
    urls <- sort(urls) 
    return(urls) 
} 

# a naieve way of doing it. Python has 'urlparse' which is suppose to be rather good at this 
get.root.domain <- function(u) { 
    root <- unlist(strsplit(u, "/"))[3] 
    return(root) 
} 

# a naieve method to filter out duplicated, invalid and self-referecing urls. 
filter.links <- function(seed, urls) { 
    urls <- unique(urls) 
    urls <- urls[which(substr(urls, start = 1, stop = 1) == "h")] 
    urls <- urls[grep("http", urls, fixed = TRUE)] 
    seed.root <- get.root.domain(seed) 
    urls <- urls[-grep(seed.root, urls, fixed = TRUE)] 
    return(urls) 
} 

# pass each url to this function 
main.fn <- function(seed) { 
    raw.urls <- get.links.on.page(seed) 
    filtered.urls <- filter.links(seed, raw.urls) 
    return(filtered.urls) 
} 

### example ### 
seed <- "http://www.r-bloggers.com/blogs-list/" 
urls <- main.fn(seed) 

# crawl first 3 links and get urls for each, put in a list 
x <- lapply(as.list(urls[1:3]), main.fn) 
names(x) <- urls[1:3] 
x 

आप को कॉपी करें और आर में पेस्ट, और फिर एक्स को देखें, तो मुझे लगता है कि यह समझ बनाने के लिए होगा।

किसी भी तरह से, शुभकामनाएं दोस्त! टोनी ब्रेयल

Answer 2

ताल,

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

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

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

मेरे पास आर में इसके लिए कोई कोड नहीं है, लेकिन मेरे पास generated code that performs a very similar process in Python using Google's SocialGraph API है।

शुभकामनाएं!