Maszynka do czytania Twittera

Bardzo lubię Twittera, który w Polsce jest trochę niedowartościowany. Według mnie to najszybsze źródło informacji, a przy okazji - przyjemne i wygodne w zdobywaniu danych do przeróżnych analiz. Najnowsze dane do jakich dotarłem (nie szukałem długo - jakieś 2 minuty) mówią o tym, że w Polsce z FB korzysta jakieś pięć razy więcej użytkowników niż z Twittera. Niby mało, ale jak zobaczymy jest to wystarczająco. Analizowaliśmy już w oparciu o dane z Twittera wyniki Oscarów oraz aktywność podczas meczu piłki nożnej. Nie ma jednak prostego sposobu (nie znam, może raczej tak), aby w krótkim czasie dotrzeć to tego co aktualnie dzieje się na Twitterze. Przygotujemy sobie więc odpowiednie narzędzie.

Idea

Twitter w swojej dobroci udostępnia coś co nazywa się trendami. To najpopularniejsze hashtagi i słowa w danym momencie. Algorytm wybierający co jest w trendach nie jest powszechnie znany, trochę o tym pisze sam Twitter, trochę można znaleźć na Quorze, o mechanizmie dobrze opowiada wideo:

W skrócie i uproszczeniu - dla danej lokalizacji (bo trendy są podzielone na lokalizacje) trzeba zbadać jakie słowa (z tego co widać po trendach to też pary słów - bi-gramy) i hashtagi pojawiają się najczęściej w jakimś zadanym czasie. To co jest najpopularniejsze trafia do trendów. Tym nie będziemy się zajmować, skorzystamy z tego dobrodziejstwa wierząc, że Twitter wybiera dobrze. Idea całej maszynerii jest następująca:

• pobieramy cyklicznie trendy
• dla kilku ostatnich godzin określamy, które trendy mają znaczenie
• dla tych trendów pobieramy twitty
• analizujemy tak przygotowaną bazę

Zebranie trendów

Na początek potrzebujemy tokenu aplikacji twitterowej. Było o tym w poprzednim wpisie, gdzie odsyłałem tutaj. Na koniec uzyskania tokenu w poprzednim wpisie otrzymaliśmy plik twitter_token.rdata, z którego teraz będziemy korzystać. Przygotujemy prosty skrypt, który pobierze aktualną listę trendów i doda ją do popranych wcześniej danych. Oczywiście każdy trend będzie opatrzony datą i godziną pobrania. Taki skrypt powinien być uruchamiany cyklicznie - na przykład co 15 minut. Całość poniżej:

library(rtweet)
library(dplyr)

# token
load("twitter_token.rdata")

# poprzednio zapisane trendy
trends_all <- readRDS("trends.Rds")

# trends
woeid <- 23424923 # Polska

# pobranie aktualnych trendów dla określonej lokalizacji
trends <- get_trends(woeid)

# wybieramy tylko interesujące nas kolumny
trends <- trends %>%
    select(trend, query) %>%
   # oznaczamy kolejność twittów i dodajemy znacznik aktualnego czasu
    mutate(n = row_number(),
             check_time = Sys.time())

# dodajemy do poprzedniej listy
trends_all <- rbind(trends_all, trends)

# ...i zapisujemy
saveRDS(trends_all, file="trends.Rds")

Przy pierwszym uruchomieniu musimy zamiast

trends_all <- readRDS("trends.Rds")

przygotować pustą tabelkę na dane, czyli na przykład w konsoli R wykonać:

trends_all <- data.frame()
saveRDS(trends_all, file="trends.Rds")

Oczywiście ten kawałek można wstawić do gotowego skryptu - w ramach obsługi wyjątku kiedy plik trends.Rds nie istnieje.

Zebranie twittów

Mając zebrane trendy musimy zdecydować z których z nich będziemy pobierać twitty. Możemy brać po prostu najnowsze - wówczas zabawa z zapisywaniem historii trendów jest zbędna (po prostu pobieramy najnowsze trendy i z nich najnowsze twitty). Ja jednak stwierdziłem, że to nie da poprawnego obrazu i postanowiłem rankować trendy, a później przeglądać te najważniejsze. Trzeba wymyślić sposób rankowania. Poszedłem po linii najmniejszego oporu i zdecydowałem, że:

• im wyżej w trendach tym ważniejszy jest dany temat
• im dawniej temat był wysoko tym mniejsza jego ważność obecnie

Idąc tym tropem postanowiłem nadać wagi zmieniające się z czasem - najnowsza lista trendów ma wagę 1, ta poprzednia - 1/2, jeszcze wcześniejsza - 1/3 i tak dalej, według schematu 1/n, gdzie n to n-ta historyczna chwila. Następnie liczymy scoring danego trednu jako iloczyn jego pozycji w danej chwili pozycja trendu i wagi tej chwili. To co jest najbliżej jedynki jest najważniejszym trendem (ma najlepszy scoring). Poniższy skrypt liczy które trendy są “najważniejsze”, a następnie dla 12 najważniejszych pobiera po 1000 najnowszych twittów i zapisuje je do pliku tweets.Rds:

library(tidyverse)
library(rtweet)

# token
load("twitter_token.rdata")

# które trendy nas interesują?
trends_all <- readRDS("trends.Rds")

# ile_jednostek max czasu (ile_jednostek * 15 minut temu)
ile_jednostek <- 8
min_time <- trends_all %>%
   select(check_time) %>%
   distinct() %>%
   arrange(desc(check_time)) %>%
   .[ile_jednostek, 1]

# wagi do scoringu
wagi <- data.frame(pos = 1:max(trends_all$n), waga = 1/1:max(trends_all$n))

# liczymy scoring
trends <- trends_all %>%
   filter(check_time >= min_time) %>%
   left_join(wagi, by = c("n" = "pos")) %>%
   mutate(score = n*waga) %>%
   group_by(trend) %>%
   # scoring
   summarise(score = sum(score)/sum(waga)) %>%
   ungroup() %>%
   # odległość scoringu od jedynki
   mutate(n = abs(1-score)) %>%
   arrange(n) %>%
   left_join(trends_all %>% select(trend, query), by="trend") %>%
   select(trend, query) %>%
   distinct()


# pobieramy twitty
tweets <- tibble()

# pierwsze 12 trendów - pobranie twittów
for(i in 1:12) {
   cat(paste0("\n", i, "/12 - ", as.character(trends[i, "trend"]), "\n"))
   trend_tweets <- search_tweets(as.character(trends[i, "query"]),
                                 n = 1000,
                                 include_rts = FALSE, retryonratelimit = TRUE,
                                 parse = TRUE)
   
   # warunek zabezpieczający przed błędami
   # czasem search_tweets() zwraca listę zamiast data.frame
   if("data.frame" %in% class(trend_tweets)) {
       trend_tweets$trend <- as.character(trends[i, "trend"])
       trend_tweets$query <- as.character(trends[i, "query"])
       tweets <- rbind(tweets, trend_tweets)
   }
}

# zapisujemy plik
saveRDS(tweets, file="tweets.Rds")

Powyższy powinien być wykonany tuż przed przygotowaniem raportu.

Przygotowanie raportu

Sam raport to już wyciągnięcie najbardziej interesujących nas informacji o twittach. I od nas zależy co uznamy, za ciekawe informacje. Na początek przygotujemy odpowiednie dodatki:

setwd("~/RProjects/TwitterTrends_Raport")

library(tidyverse)
library(lubridate)
library(tidytext)
library(wordcloud)
library(stringr)

# to przyda nam się do chmurki słów
pl_stop_words <- read_lines("polish_stopwords.txt")

theme_set(theme_minimal())

tweets <- readRDS("tweets.Rds")

i nieco oczyścimy dane wybierając tylko interesujące nas kolumny, upraszczając czasy twittów (niwelując sekundy) i wybierając ostatnie 12 godzin:

# potrzebne kolumny
tweets_an <- tweets %>%
   select(screen_name, user_id, created_at, text, trend,
          retweet_count, favorite_count, status_id, source) %>%
   distinct() %>%
   mutate(created_at = with_tz(created_at)) %>%
   mutate(created_at = make_datetime(year(created_at),
                                             month(created_at),
                                             day(created_at),
                                     hour(created_at),
                                             minute(created_at), 0))


# wyfiltrowanie zbednych twittów
tweets_an <- tweets_an %>%
   # boty i spamerzy
   filter(!source %in% c("Poland Trends")) %>%
   # tylko ostatnie 12 godzin
   filter(created_at >= Sys.time() - hours(12))

Teraz możemy sobie analizować do woli. Możemy na przykład sprawdzić jak w czasie zmienia się ilość twittów w poszczególnych trendach, jak wyglądają najpopularniejsze słowa użyte w twittach należących do danego trendu oraz które twitty były najpopularniejsze (miały najwięcej retwittów oraz polubień). Na początek przygotujemy tabelę z popularnością słów w podziale na trendy (z usunięciem stop words - polskich i angielskich):

# chmurki słów
words <- tweets_an %>%
   # bez linków
   mutate(text = gsub(" ?(f|ht)tp(s?)://(.*)[.][a-z]+", "", text)) %>%
   unnest_tokens(word, text, token="words") %>%
   count(word, trend) %>%
   ungroup() %>%
   # usuniecie z chmurki slowa - trendu (oczywiscie ono dominuje)
   filter(word != str_to_lower(str_replace_all(trend, "#", ""))) %>%
   # bez stop words
   filter(!word %in% pl_stop_words) %>%
    filter(!word %in% stop_words$word)

Teraz poskładajmy wszystko w całość w ramach jednej pętli idącej po kolei trend po trendzie:

trends <- unique(words$trend)

for(i in 1:length(trends)) {
   # zbiór twittów z tagu
   tweets_an_trend <- tweets_an %>% filter(trend == trends[i]) 

   # liczba twittów w czasie
   tweets_an_trend %>%
      count(created_at) %>%
      ungroup() %>%
      ggplot() +
      geom_point(aes(created_at, n), color="darkgreen", alpha = 0.3, size = 3) +
      expand_limits(y = 0) + labs(x="Czas", y="Liczba twittów")

   # chmurka słów
   tmp <- filter(words, trend == trends[i])
   wordcloud(tmp$word, tmp$n,
             min.freq = mean(tmp$n)+sd(tmp$n),
             colors = RColorBrewer::brewer.pal(12, "Paired"))

   # najpopularniejsze twitty
   tweets_an_trend %>%
      select(screen_name, text, status_id, created_at,
             retweet_count, favorite_count) %>%
      mutate(text = gsub("\n", " ", text)) %>%
      mutate(score = retweet_count + favorite_count) %>%
      top_n(10, wt = score) %>%
      arrange(desc(score), desc(created_at)) %>%
      mutate(link = paste0("[",
                           format(created_at, "%Y-%m-%d @ %H:%M"),
                           "](https://twitter.com/",
                           screen_name,
                           "/status/",
                           status_id,")")) %>%
      select(Twitt=text, Czas=link, Autor=screen_name,
             RTs=retweet_count, FAVs=favorite_count)

}

Wynik powyższego fragmentu kodu zamieszczam na końcu wpisu.

Automatyzacja

No fajnie, fajnie, ale z całego opisu wynika, że tu trzeba kliknąć, tam co 15 minut coś uruchomić, potem zapisać plik, coś wygenerować. Masakra, co to za automat?! Otóż można to wszystko zautomatyzować. Wystarczy:

• przygotować w sumie cztery pliki: skrypt do pobierania trendów, skrytp do pobierania twittów, szablon raportu (na przykład w postaci dokumentu Rmarkdown) oraz skrypt renderujący dokument Rmarkdown
• do unixowego crona lub windowsowego Harmonogramu zadań (czy jak to się tam nazywa) dodać uruchomienie skryptu do pobierania trendów
• przed przeglądem raportu uruchomić skrypt do pobrania twittów oraz renderujący raport
• gotowy raport można oglądać w przeglądarce (jeśli renderujemy go do HTMLa) lub np. w PDFie
• uruchomienie przeglądarki można również zawrzeć w skrypcie

W takiej konfiguracji na przykład co 15 minut w tle pobierają nam się trendy, a jeśli chcemy przeczytać raport - klikamy na ikonkę, maszyna się mieli (pobiera twitty i buduje raport) i otwiera na koniec przeglądarkę z wynikiem. Można też razem z pobraniem trendów przygotować ich scoring, pobrać twitty, a sam raport zbudować jako aplikację R/Shiny, która po uruchomieniu na początek wczytuje twitty, a póżniej robi z nimi co zechcemy. Jak takową zbuduję to nie omieszkam poinformować. Tymczasem - poniżej efekt działania maszynki aktualny na 2017-06-20, 13:32. Zwróćcie uwagę co pojawia się na polskim Twitterze - w moim odczuciu polski Twitter to polityka o prawicowym odcieniu oraz tzw. gimbaza. Może właśnie dlatego nie jest tak popularny?

Wynik działania skryptu

TREND: egzaminzawodowy

TREND: W Polsce

TREND: Calais

TREND: TeenChoice

TREND: POLSWE

TREND: AmberGold

TREND: Paryża

TREND: KPRM

TREND: Dawidowicza

TREND: Sejmu

TREND: Trybunał Konstytucyjny

TREND: Krajowej Rady Sądownictwa