👨‍💻 ✊🏾 🔧 आर का उपयोग करके जियोकोडेड डेटा (ट्विटर) का गतिशील दृश्य 🏇🏼 🗨️ 🍷

"नया साल देश को पेस करता है"

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

डेटा संग्रह

जबकि मेरी पत्नी ने उत्सव की तैयारी की और मेरे बारे में याद नहीं किया, अजगर और ट्वीटस्ट्रीम का उपयोग करके हम एक आदिम स्थिति / फिल्टर ट्वीट पार्सर बनाते हैं।

import tweetstream stream = tweetstream.FilterStream('TWITTER_LOGIN', 'TWITTER_PASSWORD', track = keywords_list) for tweet in stream: if tweet['coordinates']: #      date-time  # ( API Twitter     ) try: timestamp = datetime.datetime.strptime(tweet['created_at'], '%Y-%m-%d %H:%M:%S') except ValueError: timestamp = datetime.datetime.strptime(tweet['created_at'][4:-10]+tweet['created_at'][-4:], '%b %d %H:%M:%S %Y') #  4  - ""    timestamp += datetime.timedelta(hours=4) #       timestamp = datetime.datetime.strftime(timestamp, '%Y-%m-%d %H:%M:%S') #     cursor.execute('INSERT INTO tweets(link, latitude, longitude, date) VALUES ("http://www.twitter.com/{0}/status/{1}", "{2}", "{3}", "{4}")'.format( tweet['user']['screen_name'], tweet['id'], str(tweet['coordinates']['coordinates'][0]), str(tweet['coordinates']['coordinates'][1]), str(tweet['created_at']) )) db.commit()

keywords_list - keywords_list सूची, हैश टैग और हैप्पी न्यू ईयर से संबंधित वाक्यांश। यह मत भूलो कि यह एपीआई कॉल आकृति विज्ञान को ध्यान में नहीं रखता है, इसलिए आपको कीवर्ड के लिए यथासंभव प्रासंगिक शब्द रूपों को जोड़ने का प्रयास करना चाहिए। मेरी सूची:

# फिर,
# SNovymGodom2013,
# NG2013,
# आने वाले 2013 के साथ,
# नया साल,
# नया साल मुबारक हो,
#NEW YEAR का ट्वीट,
नया साल मुबारक हो
आने पर,
नया साल मुबारक हो,
साँप की शुभ वर्ष
साँप की शुभ वर्ष
नया साल
नया साल।

यह सब है, पति या पत्नी ने अतिरिक्त काम करने वाले हाथों पर ध्यान आकर्षित किया, इसलिए हम पार्सर को लॉन्च करते हैं और बचाव के लिए दौड़ते हैं। अंत में, हम "एन्ट्रापी में वृद्धि" में योगदान करते हैं:

डेटा का अवलोकन

नए साल के पहले दिन ~~शुक्रवार से लेकर सोमवार तक~~ किसी के ध्यान में नहीं रहे। छुट्टी बीत चुकी है, पार्सर को बंद किया जा सकता है और "कैच" को देख सकते हैं। कुल 10 हजार ट्वीट। ट्विटर जियोटैग लोकप्रिय नहीं हैं। गतिशीलता के लिए, मैंने "लिंक - अक्षांश - देशांतर - समय टिकट" फॉर्म के .csv तालिका में एक डंप फेंक दिया। हम आर में तालिका लोड करते हैं:

 twits <- read.csv2('ny_tweets.csv', header=F) colnames(twits) <- c('Link', 'Longitude', 'Latitude', 'Timestamp') twits$Timestamp <- strptime(twits$Timestamp, format='%Y-%m-%d %H:%M:%S') twits$Latitude <- round(as.numeric(as.character(twits$Latitude)), digits=1) twits$Longitude <- round(as.numeric(as.character(twits$Longitude)), digits=1) twits$Longitude <- sapply(twits$Longitude, function(x){ if(x < (-169)){ x<-360+x } else {x} })

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

 library('ggplot2') p <- ggplot() p <- p + geom_histogram(aes(x=twits$Timestamp, fill = ..count..), binwidth = 3600) p <- p + ylab('') + xlab(' ( )') p <- p + theme(legend.position = 'none') p <- p + ggtitle(expression(' "" ')) p

सब कुछ उम्मीद के मुताबिक दिखता है, जो सुखद है। हम जा सकते हैं।

नक्शा प्रस्तुत करना

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

 #    # countries -    ,    library('maps') full_map <- map_data('world') table(full_map$region) need.map <- subset(full_map, region %in% countries & long>-25 & long<190 & lat>25) #   p <- ggplot() p <- p + geom_polygon(aes(x=need.map$long, y=need.map$lat, group = need.map$group), colour='white', fill='grey20', alpha=.5) #  ""     " " # cities -  dataframe  "  -  - " p <- p + geom_point(aes(cities$Long, cities$Lat), colour='skyblue', size=1.5) #    , ,     ,   p <- p + theme(axis.line=element_blank(),axis.text.x=element_blank(), axis.text.y=element_blank(),axis.ticks=element_blank(), axis.title.x=element_blank(), axis.title.y=element_blank(), legend.position = 'none', text=element_text(family='mono', size=20, face='bold', colour='dodgerblue3') ) p <- p + scale_x_continuous(limits = c(-15, 190)) p <- p + scale_y_continuous(limits = c(30, 82)) p <- p + ggtitle(expression('#HappyNewYear in Russian Twitter - 2013'))

मैं किसी भी तरह तस्वीर को पुनर्जीवित करना और जानकारी जोड़ना चाहता हूं। घड़ी को फ्रेम में लगाएं। यहां एक घड़ी के साथ एक दिलचस्प विकल्प है: R में ggplot2 (और ffmpeg) के साथ एक एनिमेटेड घड़ी बनाएं । लेकिन वहां ध्रुवीय समन्वय प्रणाली का उपयोग किया जाता है, जो हमारे लिए उपयुक्त नहीं है, क्योंकि यह एक सबग्राफ बनाने के रूप में अतिरिक्त शरीर आंदोलनों की आवश्यकता होगी। अपनी खुद की "बाइक" बनाना है। हम केंद्र और व्यास में सर्कल के निर्देशांक की गणना के लिए फ़ंक्शन लेते हैं ( यहां झांकते हैं ):

 draw.circle <- function(center,diameter=1, npoints = 100){ r = diameter / 2 tt <- seq(0,2*pi,length.out = npoints) xx <- center[1] + r * cos(tt) yy <- center[2] + r * sin(tt) * roundcoef return(data.frame(x = xx, y = yy)) }

अब हम तीन हलकों के लिए बिंदुओं की गणना करते हैं: एक सफेद पृष्ठभूमि, एक ग्रे "शीर्ष" पृष्ठभूमि और समय के लिए एक सर्कल में 12 अंक।

 curtime <- c(as.numeric(format(frame.time, '%H')), as.numeric(format(frame.time, '%M'))) clock.center <- c(180, 35) circdat <- draw.circle(clock.center, diameter=20) circdat2 <- draw.circle(clock.center, diameter=19.7) circdat3 <- draw.circle(clock.center, diameter=18, npoints=13)

हम तीरों की स्थिति पर विचार करते हैं:

 arrow.r = c(5.5,8.8) #   if(curtime[1]>=12){curtime[1]=curtime[1]-12} hourval <- pi*(.5 - (curtime[1]+(curtime[2]/60))/6) minval <- pi*(.5 - curtime[2]/30) hour.x <- clock.center[1] + arrow.r[1] * cos(hourval) hour.y <- clock.center[2] + arrow.r[1] * sin(hourval) minute.x <- clock.center[1] + arrow.r[2] * cos(minval) minute.y <- clock.center[2] + arrow.r[2] * sin(minval)

घड़ी खींचें (फ़ंक्शन geom_polygon, geom_segment, geom_point):

 #  :     p <- p + geom_polygon(aes(x=circdat$x,y=circdat$y), colour='grey100', fill='grey100', alpha = .5) p <- p + geom_polygon(aes(x=circdat2$x,y=circdat2$y), colour='grey80', fill='grey80', alpha = .5) p <- p + geom_point(aes(circdat3$x, circdat3$y), colour='skyblue') #  , , ""   p <- p + geom_segment(aes(x=clock.center[1], y=clock.center[2], xend=hour.x, yend=hour.y), size=3, colour='dodgerblue3') p <- p + geom_segment(aes(x=clock.center[1], y=clock.center[2], xend=minute.x, yend=minute.y), size=1.5, colour='dodgerblue4') p <- p + geom_point(aes(clock.center[1], clock.center[2]), colour='blue4')

यहाँ क्या हुआ (मानचित्र पर "गतिविधि" पर परीक्षण डेटा भी हैं, लेकिन केवल मास्को और इसके वातावरण में):

फ्रेम ड्रा करें

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

 start.date <- '2012-12-31 00:00:00' finish.date <- '2013-01-01 12:00:00' seconds.in.frame <- 30 start.date <- strptime(start.date, format='%Y-%m-%d %H:%M:%S') finish.date <- strptime(finish.date, format='%Y-%m-%d %H:%M:%S') frames <- as.numeric(difftime(finish.date, start.date, units='secs'))/seconds.in.frame for(i in 1:frames){ frame.time <- start.date + i*seconds.in.frame frame.twits <- subset(twits, Timestamp <= frame.time & Timestamp > frame.time - ma.period) ...

अगला, हम आकस्मिक तालिका "अक्षांश - देशांतर" बनाते हैं (मुझे याद है कि अक्षांश और देशांतर मान पहले एक से दसवें तक चक्कर लगाते हुए निरंतर से परिवर्तित हो गए थे)। और हम 3 कॉलम के डेटाफ़्रेम में आकस्मिकता तालिका का "विस्तार" करते हैं: अक्षांश, देशांतर, आवृत्ति (किसी दिए गए बिंदु पर ट्वीट्स की संख्या)। हम उन पंक्तियों को हटा देते हैं जिनमें आवृत्ति शून्य होती है या निर्देशांक स्थापित सीमाओं से परे जाते हैं।

  ... frame.twits <- melt(table(frame.twits$Latitude, frame.twits$Longitude)) colnames(frame.twits) <- c('Lat', 'Long', 'Volume') frame.twits$Lat <- as.numeric(as.character(frame.twits$Lat)) frame.twits$Long <- as.numeric(as.character(frame.twits$Long)) frame.twits <- frame.twits[frame.twits$Volume>0 & frame.twits$Long>=-25 & frame.twits$Long<=190 & frame.twits$Lat>=25 & frame.twits$Lat<=85,] ...

संख्यात्मक चर के लिए अक्षांश और देशांतर को परिवर्तित करना आवश्यक है, क्योंकि "पतन-विस्तार" डेटा के बाद, वे श्रेणीबद्ध (आर शब्दावली में कारक) में परिवर्तित हो जाते हैं।
यह डॉट्स के रंगों की गिनती करने के लिए बनी हुई है। ऐसा करने के लिए, प्रारंभिक चक्र में, पूरे भविष्य की "फिल्म" के लिए एक बिंदु पर ट्वीट्स की अधिकतम संभव मात्रा की गणना की जाती है। यह अधिकतम ( max.color ) के लिए लिया जाता है, और अन्य सभी बिंदुओं के लिए रंगों की गणना इसके सापेक्ष की जाती है (लघुगणक - पैमाने को "संरेखित" करने के लिए):

  ... frame.colors <- round(1 + (8*log(frame.twits$Volume)/max.color), digits=0) ...

अब आप डॉट्स (यदि कोई हो) आकर्षित कर सकते हैं:

  ... if(nrow(frame.twits)>0){ p <- p + geom_point(aes(frame.twits$Long,frame.twits$Lat, size=frame.twits$Volume * 5), colour=twits.colors[frame.colors], alpha = .75) } ...

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

 twit.texts$x <- rnorm(nrow(twit.texts), mean = 100, sd = 30) twit.texts$y <- rnorm(nrow(twit.texts), mean = 56, sd = 15) twit.texts$size <- rnorm(nrow(twit.texts), mean = 10, sd = 2)

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

  ... twit.texts$opacity <- as.numeric(by(twit.texts, 1:nrow(twit.texts), function(row){ if(frame.time < row$t.start | frame.time > row$t.end){ row$opacity <- 0 } else { row$opacity <- 0.7 * (1 - (abs(as.numeric(difftime(row$Timestamp, frame.time, unit='sec'))) / (row$t.delta * seconds.in.frame / 2))) } })) p <- p + geom_text(aes(x=twit.texts$x, y=twit.texts$y, label=iconv(twit.texts$Text,to='UTF-8')), colour=twit.texts$color, size=twit.texts$size, alpha = twit.texts$opacity) ...

टेक्स्ट आउटपुट को geom_text का उपयोग करके आयोजित किया जाता है।
अब यह सब है। आप फ्रेम को बचा सकते हैं और लूप को बंद कर सकते हैं।

  ... f.name <- as.character(i) repeat{ if(nchar(f.name) < nchar(as.character(frames))){ f.name <- paste('0', f.name, sep='') } else { break }} ggsave(p, file=paste('frames/img', f.name, '.png', sep=''), width=6.4, height=3.6, scale = 3, dpi=100) }

F.name "शून्य" की लंबाई समायोजित की जाती है ताकि सभी नाम वर्णों की संख्या से एक मुखौटा के नीचे "फिट" हों।

हम वीडियो एकत्र करते हैं

अंतिम क्लिप बनाने के लिए, ffmpeg का उपयोग किया गया था :
ffmpeg -f image2 -i img%04d.png -q:v 0 -vcodec mpeg4 -r 24 happynewyear.mp4
हालांकि, सब कुछ इतना सरल नहीं है। पूरा वीडियो एकत्र नहीं किया गया है - ggplot2 से प्राप्त .png फ़ाइलों में अलग-अलग रंग की गहराई होती है। शायद इस समस्या को कुछ और सही तरीके से हल किया जा सकता है, लेकिन मैंने पायथन इमेजिंग लाइब्रेरी का उपयोग किया:

 import os from PIL import Image path = u'/path/to/frames/' dirList=os.listdir(path) for filename in dirList: if filename[-3:] == 'png': im = Image.open(path + filename).convert('RGB') im.save(path + filename)

अब सभी फ्रेम एक वीडियो में एकत्र किए गए हैं। वीडियो तैयार है, आप YouTube पर अपलोड कर सकते हैं। कुछ YouTube प्रभाव जोड़ें (क्योंकि यदि बंदूक दीवार पर लटकी हुई है, तो आपको समय-समय पर इसे शूट करने की आवश्यकता है)।
अंतिम:

इस पाठ में, मैंने आर-स्क्रिप्ट के सभी हिस्सों का वर्णन नहीं किया है, लेकिन कोड के उद्धरणों का हिस्सा समस्या के सिद्धांत के अनुसार व्यवस्थित किया जाता है, न कि कार्य के तर्क के अनुसार। इसलिए, एप्लिकेशन में मैं कम संख्या के साथ पूर्ण कोड के लिए एक लिंक पोस्ट करता हूं: pastebin.com

संभावित विकास विकल्प

दिनांक के रूप में जोड़ें जब आप कई दिनों के समय अंतराल की कल्पना करना चाहते हैं तो 12 घंटे की डायल बहुत जानकारीपूर्ण नहीं होती है।
एक हिस्टोग्राम के साथ एक बार जोड़ें या समय में प्रत्येक क्षण डेटा की कुल मात्रा पर संभावना घनत्व के ग्राफ की तरह कुछ।

सामुदायिक प्रश्न

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

धन्यवाद!

उपयोगी लिंक

आर में अच्छे दिखने वाले नक्शे कैसे आकर्षित करें - नक्शे खींचने के लिए नक्शे और ggplot2 का उपयोग करना;
R में ggplot2 (और ffmpeg) के साथ एक एनिमेटेड घड़ी बनाएं - R पर एनिमेटेड एनालॉग घड़ी;
Ggplot2 वाले मानचित्र पर सरल डेटा खनन और प्लॉटिंग डेटा - आर में ओएसएम मानचित्रों का उपयोग।

आर का उपयोग करके जियोकोडेड डेटा (ट्विटर) का गतिशील दृश्य