W tej sekcji rozwiniemy plik R Markdown naszej prezentacji. Tworzymy pusty plik o nazwie presentation.R i umieszczamy następujące nagłówki. Cudzysłowy nie są wymagane, chyba że chcesz dołączyć dwukropek w tytule. Jak pokazano w poprzedniej sekcji, używając lewych apostrofów („ ‘), możemy wykonać kod R. W takim przypadku aktualną datę umieszczamy automatycznie na pierwszej stronie. Na koniec wybraliśmy ioslides_presentation jako format wyjściowy. Zapraszam do eksperymentowania z innymi wynikami pokazanymi wcześniej:
—
title : „The Food Factory”
author : „Weekly Update”
date : „ r Sys.Date() ` „
output : ioslides_presentation
—
Poniższy kod konfiguruje domyślną konfigurację fragmentów kodu w naszej prezentacji. Unikamy pokazywania kodu w prezentacji za pomocą echo = FALSE i sprawiamy, że każdy obraz ma pełną szerokość, chyba że podano inaczej za pomocą out.width = ‘100%’:
“` {r setup, include = FALSE}
knitr ::opts_chunk$set(echo = FALSE, out.width = ‘100%’)
“`
Teraz musimy zebrać wszystkie zasoby, których potrzebujemy, aby nasza prezentacja działała. W szczególności musimy załadować funkcje, które opracowaliśmy wcześniej. Załaduj dane sales i client_messages i zastosuj tę samą transformację, którą widzieliśmy poprzednio, aby skonfigurować dane. Zwróć uwagę, że odnosiliśmy się do danych sprzedaży jako all_time zamiast sales, a aby uniknąć zmiany naszego kodu, abyśmy mogli nadal łatwo odwoływać się do naszych plików programistycznych, po prostu kopiujemy sales do obiektu all_time. Zachowaj ostrożność, jeśli masz duże ograniczenia pamięci w systemie:
“`{r load-fuctions-and-data, include=FALSE}
source(„../functions.R”)
sales <- readRDS(„../../results/sales.rds”)
cliet_messages <- readRDS(„../../results/clinet_messages.rds)
sales <- add_profits(sales)
all_time <- sales
max_date <- max(all_time$DATE)
this_week <- filter_n_days_back(all_time, 7, max_date)
last_week <- filter__n_days_back(all_time, 7, max_date – 7)
quatity_all <- proportions_table(all_time, „QUANTITY”)
continent_all <- proportions_table(all_time, „CONTINENT”)
protein_all <- proportions_table(all_time, „PROTEIN_SOURCE”)
quatity_last<- proportions_table(last_week, „QUANTITY”)
continent_last <- proportions_table(last_week, „CONTINENT”)
protein_last <- proportions_table(last_week, „PROTEIN_SOURCE”)
quatity_this <- proportions_table(this_week, „QUANTITY”)
continent_this <- proportions_table(this_week, „CONTINENT”)
protein_this <- proportions_table(this_week, „PROTEIN_SOURCE”)
Teraz, gdy nasze zasoby zostały skonfigurowane, możemy pracować nad kodem, który faktycznie pokaże naszą analizę w prezentacji. Zaczynamy od slajdów, które wykorzystują funkcje opracowane wcześniej, aby pokazać zmiany za pomocą pasków i linii. Zwróć uwagę, że w każdym przypadku określamy różne wysokości dla wykresów słupkowych i liniowych. Zwróć też uwagę, że w przypadku wykresów liniowych używamy szerokości 50%. To dlatego, że chcemy, aby były wyświetlane pionowo na slajdzie. 50% szerokość przy wysokości 10 zapewnia taki rozkład. W rzeczywistości możesz chcieć wybrać lepsze tytuły dla każdego slajdu, ale w tym przykładzie pozostaną one oczywiste. Zauważ, że pracując w ten sposób, unikamy umieszczania jakiegokolwiek kodu logicznego na naszych slajdach, a po prostu czytając tytuły funkcji, wiemy dokładnie, co zostanie pokazane. Pozwala to na łatwe przenoszenie rzeczy bez rozbijania ich z powodu zależności między fragmentami kodu, ponieważ wyodrębniliśmy to w oddzielnych plikach. Jeśli wypełnisz pliki prezentacji logiką R, szybko przekonasz się, że jest to bardzo zagmatwane, gdy trzeba je zmienić. Lepiej jest mieć tę logikę w rzeczywistym pliku .R, tak jak robimy to z naszym plikiem function.R. Nie wspominając już o tym, że jest również znacznie bardziej wielokrotnego użytku w ten sposób:
## Changes in quantity (1/2)
“` {r quantity-bars, fig.height = 2.5 }
difference_bars_absolute(quantity_last, quatity_this, „This week”, „Last week”)
difference_bars_absolute(quantity_all, quantity_thi, „This week”, „All-time”)
“`
## Changes in quantity (2/2)
“` {r quantity-lines, out.width = ‘50%’, fig.height = 10}
change_lines(quantity_last, quantity_this, „This week”, „Last week”, 0.2)
chage_lines(quantity_all, quantity_this, „This week”, „All-time”, 0.2)
“`
## Changes in continent (1/2)
“`{r cotinet-bars, fig.height = 2.5}
difference_bars_absolute(continet_last, continet_this, „This week”, „Last week”)
difference_bars_absolute(continent_all, continent_this, „This week”, „All-time”)
“`
## Changes in continet (2/2)
“` {r continet-lines, out.width = ‘50%’, fig.height = 10)
change_lines(continent_last, continent_this, „This week”, „Last week”, 0.3)
change_lines(continent_all, continent_this, „This week”, „All-time, 0.3)
“`
## Changes in protein source (1/2)
“`{r protein-source-bars, fig.height = 2.5}
difference_bars_absolute(protein_last, protein_this, „This week”, „Last week”)
difference_bars_absolute(protein_all, protein_this, „This week”, „All-time”)
“`
## Changes in continet (2/2)
“` {r protein-source-lines, out.width = ‘50%’, fig.height = 10)
change_lines(protein_last, protein_this, „This week”, „Last week”, 0.5)
change_lines(protein_all, protein_this, „This week”, „All-time, 0.5)
“`
Teraz dodamy wywołania funkcji do kodu, który opracowaliśmy w poprzednich rozdziałach. Jak widać, proces przebiega dokładnie tak samo, ponieważ w tym momencie wczytaliśmy już te zasoby we fragmencie kodu load-functions-and-data pokazanym wcześniej . Wszystko, co musimy zrobić, to wywołać funkcje, które tworzą dla nas wykresy. Jeśli nie pamiętasz, co robią te funkcje, sugerujemy cofnięcie się do odpowiednich rozdziałów i omówienie szczegółów ich tworzenia. Jak widać, ostatni slajd z tego fragmentu kodu wywołuje funkcję graph_client_messages_interactive() która tworzy interaktywną mapę. Wspaniałą rzeczą w tworzeniu prezentacji w ten sposób jest to, że możesz faktycznie bawić się mapą w prezentacji! Oczywiście zadziała to tylko wtedy, gdy używasz formatu wyjściowego, który wykorzystuje przeglądarkę internetową do wizualizacji (nie będzie działać na przykład z plikami PDF lub dokumentami Word), ale może to być fantastyczny sposób na dodanie potężnej zawartości do prezentacje, jeśli używasz przeglądarki internetowej do ich wizualizacji:
## Profit ratio vs contiet
“` {r sales-proft-rati-by-continent-and-protein-source }
graph_bars(sales, „CONTINENT”, „PROFIT_RATIO”, „PROTEIN_SOURCe”)
“`
## Cost vs proce
“` {r price-vs-cost}
graph_marginal_distributions(sales, „COST”, „PRICE”, „PROTEIN_SOURCE”, „CONTINENT”)
“`
## Price vs profit
“`{r price-vs-profit-ratio}
graph_marginal_distributions(sales, „PRICE”, „PROFIT_RATIO”, „PROTEIN_SOURCE”, „CONTINET”)
“`
## Historic pricing
“` {r date-vs-frequecy-profit-and-profit-ratio, fig.height = 1.8}
grpah_last_n_days(sales, 30, color = „PROTEIN_SOURCE”)
graph_last_n_days(sales, 30, „PROFIT”, „PROTEIN_SOURCE”)
graph_last_n_days(sales, 30, „PROFIT_RATIO”, „PROTEIN_SOURCE”)
## Top 5 customers’ preferences
“` {r top-customers-preferences}
subset <- filter_data(sales, 30, 5, „CLIENT_ID”)
graph_radar(subset, „CLIENT_ID”)
“`
## Customer message geolocations
“` {r customers-dynamic-map}
graph_client_messages_interactive(client_messages, sales)
“`
Na koniec chcemy pokazać najnowsze tweety przy użyciu rzeczywistych danych z Twittera na żywo. Ponieważ firma Food Factory, do której nawiązaliśmy w tym przykładzie, jest fikcyjna, tak naprawdę nie możemy uzyskać dla niej danych, ale nadal będziemy przeszukiwać Twittera pod kątem frazy The Food Factory i wyświetlać 5 najlepszych wyników, które otrzymamy. W rzeczywistości możesz pobrać tweety, które wspominają o konkretnym koncie, które Cię interesuje, i wykazać się większą kreatywnością podczas wykonywania zapytań. W tym przykładzie będzie to proste. Pierwszą rzeczą, którą musimy zrobić, jest identyfikacja z API Twittera, abyśmy mogli odzyskać dane. Jeśli nie pamiętasz, jak to zrobić, zajrzyj do wspomnianego rozdziału. Ponieważ chcemy wykonać ten fragment kodu, ale nie chcemy go wyświetlać ani jego wyników, po prostu stosujemy opcję include = FALSE. Zwróć uwagę, że trzymamy tytuł slajdu na górze kodu uwierzytelniającego jako znak dla siebie, że ten kod należy do logiki tego slajdu:
## Latest message from Twitter
“` {r twitter-setup, include = FALSE}
consumer_key <- „b9SGfRpz4b1rnHFtN2HtiQ9xl”
consumer_secret <- „YMifSUmCJ4dlgB8RVxKRNxILQw7Y4IBwDwBRkdz2Va1vcQjOP0”
access_token <- „171370802-RI14RBpMDaSFdVf5q9xrSWQKxtae4Wi3y76Ka4Lz”
access_secret <- „dHfbMtmpeA2QdOH5cYPXO5b4hF8Nj6LjxELfOMSwHoUB8”
setup_twitter_oauth(consumer_key, consumer_secret, access_token, access_secret)
“`
Następnie wstawiamy kolejny fragment kodu, który w rzeczywistości generuje dane wyjściowe, które chcemy pokazać na slajdzie. Pobieramy dane z Twittera za pomocą get_twitter_data(), które stworzyliśmy w poprzednim rozdziale i przekazujemy je przez funkcja, którą pokażemy dalej:
“`{r twitter-live-data, size == „footnotesize”, comment = „”}
format_tweets(get_twitter_data(„The Food Factory”, 5))
“`
Ta funkcja format_tweets() była konieczna do wydrukowania danych, które chcemy pokazać na slajdzie. Jeśli pamiętasz, dane, które otrzymujemy z funkcji get_twitter_data(), zawierają sporo metadanych wokół każdego tweeta, co jest bardzo przydatne podczas analizy, ale do tego slide, wolelibyśmy pokazać tylko nazwę użytkownika osoby, która napisała na Twitterze, sygnaturę czasową tweeta i rzeczywisty tweet. Musimy również skrócić długość tweeta, aby upewnić się, że będzie dobrze wyglądał w prezentacji. Mimo że jest to niewielka funkcja, kod może być nieco złożony, jeśli wcześniej nie widziałeś tych funkcji, więc zrobimy to krok po kroku. Funkcja format_tweets() otrzymuje pojedynczy argument, czyli dane, które otrzymaliśmy z funkcji get_twitter_data() i wiemy, że struktura danych zawiera interesujące nas zmienne creates, text i screenName. Ponieważ jest to kod wektorowy, nie trzeba użyć pętli for, aby wydrukować każdy tweet niezależnie. Możemy po prostu bezpośrednio użyć tablic wartości. Jeśli nie pamiętasz, do czego odnosi się kod wektorowy :
format_tweets <- function(data) {
write(paste (
data$screenName , „ („ , datat$created, „) : \n”,
iconv(enc2utf8(substr(data$text, 1, 65)) , sub = „”),
„(…) \n”, sep = „”
), stdout () )
}
Pierwszą rzeczą, jaką możesz zauważyć, jest to, że nie używamy funkcji print(). Używamy funkcji write() przekazanej w wywołaniu funkcji stdout() Oznacza to, że napiszemy obiekt na standardowe wyjście. Możesz myśleć o tym jako o głupim wywołaniu funkcji print(), w którym R nie wykona za nas żadnego przetwarzania i po prostu pokaże dokładnie, co mu powiemy. To pozwala uniknąć drukowania numerowanych wierszy, które zwykle otrzymujemy podczas korzystania z funkcji drukowania. Pamiętasz te [1], [2]. … na początku wyjścia w poprzednim kodzie? Ta technika write(…, stdout() ) pozwala ich uniknąć. Zwykle tego nie chcesz, ale w tym konkretnym przypadku jest to przydatne ze względów estetycznych. Następnie używamy funkcji paste(), tak jak robiliśmy, aby złożyć wszystko, co chcemy wydrukować. W tym przypadku zaczynamy od nazw ekranów, po których następuje nawias zawierający znacznik czasu (zawarty w data$created), a następnie kombinacja wskazująca nowy wiersz. Kombinacja \n, gdy jest używana wewnątrz funkcji write(), mówi R, aby faktycznie wprowadził nowy wiersz w tym miejscu, tak jakbyś nacisnął klawisz powrotu (klawisz Enter na klawiaturze). Następnie przekazujemy rzeczywisty tweet (data$text) do funkcji substr(), dzięki czemu możemy uzyskać znaki od 1 do 65. Zrobiliśmy to ponownie ze względów estetycznych, ponieważ nie chcę, aby bardzo długie tweety zajmowały więcej niż jedną linię. Dane wyjściowe są wysyłane do funkcji enc2utf8(), która ustawia kodowanie łańcucha na UTF-8, a dane wyjściowe są przekazywane przez funkcję iconv() z parametrem sub = „”, który usunie wszystkie niewymienialne znaki. Na koniec umieściliśmy ciąg znaków ”(…) \n”, aby pokazać, że tweet został prawdopodobnie obcięty, oraz kolejny symbol nowej linii. Podczas korzystania z funkcji iconv() zdarza się, że będzie ona próbowała konwertować znaki jeden po drugim, a gdy nie będzie mogła przekonwertować znaku, zastąpi go wysyłanym przez nas ciągiem znaków sub. Musimy to zrobić, ponieważ możemy otrzymać znaki z języków takich jak chiński lub arabski, których wyjście zawierałoby reprezentację Unicode, co nie miałoby sensu dla osób, które nie są zaznajomione z tego typu problemami z kodowaniem. Staramy się stworzyć przyjazną dla użytkownika prezentację.
Jeśli ponownie skompilujesz tę prezentację, wiadomości pobrane z Twittera będą się różnić od pokazanych tutaj, ponieważ zostaną pobrane w tym momencie
Teraz możesz skompilować swoją prezentację dowolną z metod wymienionych wcześniej, a jeśli wszystko pójdzie dobrze, powinieneś zobaczyć plik presentation.html w swoim katalogu. Jeśli otworzysz ten plik w przeglądarce internetowej, powinieneś zobaczyć slajdy podobne do pokazanych poniżej. Możesz także otworzyć prezentację na żywo bezpośrednio w repozytorium tej książki. Pamiętaj, aby bawić się interaktywną mapą!
Sesson info ——————————————————-
setting value
version R bersion 3.4.2 (2017 – 09 – 28
system x84_64, linux-gnu
ui X11
language (EN)
collate en_US.UTF-8
tz America/Mexico City
date 2017-10-30
Packages ———————————————————–
package * versin date source
assertthat 0.2.0 2017-04-11 CRAN (R 3.3.2)
base * 3.4.2. 2017-10-28 local
base64enc 0.1-3 2015-07-28 CRAN (R 3.3.2)
bindr 0.1 2016-11-13 CRAN (R 3.3.2)
[…truncated…]
Podsumowanie
Omówiliśmy zalety automatyzacji zadań oraz tworzenia treści. Pokazaliśmy, jak zintegrować potoki automatyzacji do tworzenia treści, jak pisać dokumenty R Markdown, które zapewniają dynamiczną zawartość, oraz jak używać tych dokumentów do tworzenia ładnie wyglądających i wydajnych dokumentów i prezentacji. Pokazaliśmy, jak zintegrować różne zasoby języka R, aby tworzyć treści, które mogą być aktualizowane automatycznie. Jeśli chcesz opracować dokumenty, które są bardziej techniczne lub obszerne, pakiet bookdow może być dla Ciebie dobrą opcją. Jego celem jest ułatwienie tworzenia długich dokumentów, takich jak książki, za pomocą R Markdown. Prawdę mówiąc, ta książka została napisana przy użyciu bookdown, a proces był naprawdę przyjemny. W następnym rozdziale rozpoczniemy nowy przykład koncentrujący się na ocenie transakcji kryptowalutowych. Zaczniemy od zbudowania zorientowanego obiektowo systemu, który symuluje platformę handlową i automatycznie ocenia wyniki traderów. Następnie pokażemy, jak sprawić, by nasze algorytmy działały szybciej, używając równoległości i delegacji, a na koniec w ostatnim rozdziale pokażemy, jak tworzyć strony internetowe zawierające interaktywne pulpity nawigacyjne, wszystko z poziomu R.