Ova napomena će biti zanimljiva za one koji koriste biblioteku za obradu tabelarnih podataka za R — data.table, i možda će biti radosni da vide fleksibilnost njenog korišćenja na raznim primerima.
Inspirisan dobrim primerom , i nadajući se da ste već pročitali njegovu članku, predlažem da dublje istražimo optimizaciju koda i performansi na osnovu data.table.
Uvod: odakle dolazi data.table?
Najbolje je započeti upoznavanje sa bibliotekom malo izdaleka, a to su strukture podataka iz kojih može biti kreiran objekat data.table (u daljem tekstu, DT).
Niz
Kod
## arrays ---------
arrmatr <- array(1:20, c(4,5))
class(arrmatr)
typeof(arrmatr)
is.array(arrmatr)
is.matrix(arrmatr)
Jedna od takvih struktura je niz (?base::array). Kao i u drugim jezicima, nizovi su višedimenzionalni. Međutim, zanimljivo je da, na primer, dvodimenzionalni niz počinje da nasleđuje osobine od klase matrice (?base::matrix), dok jednodimenzionalni niz, što je takođe važno, ne nasleđuje od vektora (?base::vector).
U tom smislu, važno je razumeti da tip podataka koji se sadrži u nekom objektu treba proveriti funkcijom base::typeof, koja vraća unutrašnji opis tipa prema R Internals — opštem protokolu jezika koji se odnosi na izvornik C.
Još jedna komanda za određivanje klase objekta, base::class, vraća vektorski tip u slučaju vektora (razlikuje se imenom od unutrašnjeg, ali omogućava i razumevanje tipa podataka).
Lista
Iz dvodimenzionalnog niza, tj. matrice, može se preći na listu (?base::list).
Kod
## lists ------------------
mylist <- as.list(arrmatr)
is.vector(mylist)
is.list(mylist)
U tom trenutku događa se nekoliko stvari odjednom:
- Druga dimenzija matrice se smanjuje, što znači da dobijamo istovremeno i listu i vektor.
- Lista, dakle, nasleđuje od ovih klasa. Važno je napomenuti da će elementu liste odgovarati jedno (skalrno) vrednost iz ćelije matrice-niza.
Zahvaljujući tome što je lista takođe i vektor, mogu se primeniti neke funkcije za vektore.
Dataframe
Može se preći na dataframe (?base::data.frame).
Kod
## data.frames ------------
df <- as.data.frame(arrmatr)
df2 <- as.data.frame(mylist)
is.list(df)
df$V6 <- df$V1 + df$V2
Što je interesantno: dataframe nasleđuje od liste! Kolone datafrema su ćelije liste. Ovo će biti važno kasnije, kada budemo koristili funkcije primenjene na liste.
data.table
DT (?data.table::data.table) se može dobiti iz datafrema, liste, vektora ili matrice. Na primer, ovako (in place).
Kod
## data.tables -----------------------
library(data.table)
data.table::setDT(df)
is.list(df)
is.data.frame(df)
is.data.table(df)
Korisno je to što, kao i dataframe, DT nasleđuje osobine liste.
DT i memorija
Za razliku od svih ostalih objekata u R bazi, DT se prenose po referenci. Ako želite napraviti kopiju u novu memorijsku oblast, potrebna vam je funkcija data.table::copy ili morate izabrati iz starog objekta.
Kod
df2 <- df
df[V1 == 1, V2 := 999]
data.table::fsetdiff(df, df2)
df2 <- data.table::copy(df)
df[V1 == 2, V2 := 999]
data.table::fsetdiff(df, df2)
Ovdje se uvod bliži završetku. DT predstavlja nastavak razvoja struktura podataka u R-u, koji se pretežno odvija kroz proširenje i ubrzanje operacija izvedenih nad objektima klase data.frame. U tom procesu se čuva nasljeđivanje od drugih primitiva.
Neki primjeri korištenja svojstava data.table
Kao lista…
Iteriranje po redovima data frame-a ili DT-a nije najbolja ideja, jer je kod petlje na jeziku R mnogo sporiji C, a prolazak kroz petlju po kolonama, kojih obično ima daleko manje, je sasvim moguće. Kada prolazite kroz kolone, sjetite se da je svaka kolona element liste, koji obično sadrži vektor. Operacije nad vektorima su dobro vektorizovane u osnovnim funkcijama jezika. Također možete koristiti operatore izbora koji su svojstveni listama i vektorima: `[[`, `$`.
Kod
## operations on data.tables ------------
#using list properties
df$'V1'[1]
df[['V1']]
df[[1]][1]
sapply(df, class)
sapply(df, function(x) sum(is.na(x)))
Vektorizacija
Ako postoji potreba da prođete kroz redove velikog DT-a, najbolje rješenje bi bilo napisati funkciju s vektorizacijom. Ali ako to ne uspije, trebate imati na umu da je ciklus unutar DT još uvijek brži od ciklusa u R, jer se izvršava na C.
Pokušajmo s većim primjerom od 100K redova. Izaći ćemo prvu slova iz reči koje se nalaze u vektoru-koloni w.
Ažurirano
Kod
library(magrittr)
library(microbenchmark)
## Veći primjer ----
rown <- 100000
dt %
.[, d := 1 + b + c + rnorm(nrow(.))]
# vektorizacija
microbenchmark({
dt[
, first_l := unlist(strsplit(w, split = ' ', fixed = T))[1]
, by = 1:nrow(dt)
]
})
# drugi
first_l_f %
do.call(rbind, .) %>%
`[`(,1)
}
dt[, first_l := NULL]
microbenchmark({
dt[
, first_l := .(first_l_f(w))
]
})
# treći
first_l_f2 %
unlist %>%
matrix(nrow = 3) %>%
`[`(1,)
}
dt[, first_l := NULL]
microbenchmark({
dt[
, first_l := .(first_l_f2(w))
]
})
Prvi prolaz s iteracijom po redovima:
Jedinična: milisekunde
expr min
{ dt[, `:=`(first_l, unlist(strsplit(w, split = " ", fixed = T))[1]), by = 1:nrow(dt)] } 439.6217
lq mean median uq max neval
451.9998 460.1593 456.2505 460.9147 621.4042 100
Drugi prolaz, gdje se vektorizacija vrši kroz pretvaranje liste u matricu i uzimanje elemenata na isječku s indeksom 1 (to je zapravo vektorizacija). Ispravka: vektorizacija na razini funkcije strsplit, koja može prihvatiti vektor kao ulaz. Ispostavilo se da je procedura pretvaranja liste u matricu mnogo teža od same vektorizacije, ali u tom slučaju je ipak mnogo brža od nevktorizirane verzije.
Jedinična: milisekunde
expr min lq mean median uq max neval
{ dt[, `:=`(first_l, .(first_l_f(w)))] } 93.07916 112.1381 161.9267 149.6863 185.9893 442.5199 100
Ubrzanje po medijani u 3 puta.
Treći prolaz, gdje je izmijenjen obrazac pretvaranja u matricu.
Jedinična: milisekunde
expr min lq mean median uq max neval
{ dt[, `:=`(first_l, .(first_l_f2(w)))] } 32.60481 34.13679 40.4544 35.57115 42.11975 222.972 100
Ubrzanje po medijani u 13 puta.
Ovo se mora isprobati, što više eksperimenata — to bolje.
Još jedan primjer vektorizacije, gdje imamo tekst, ali je prilagođen realnim uvjetima: različita dužina riječi, različit broj riječi. Potrebno je izvući prva 3 riječi. Ovako:

Ovdje prethodna funkcija više ne radi, jer su vektori različitih dužina, a mi smo zadali veličinu matrice. Prepravimo ovo, pretražujući internet.
Kod
# fourth
rown <- 100000
words <-
sapply(
seq_len(rown)
, function(x){
nwords <- rbinom(1, 10, 0.5)
paste(
sapply(
seq_len(nwords)
, function(x){
paste(sample(letters, rbinom(1, 10, 0.5), replace = T), collapse = '')
}
)
, collapse = ' '
)
}
)
dt <-
data.table(
w = words
, a = sample(letters, rown, replace = T)
, b = runif(rown, -3, 3)
, c = runif(rown, -3, 3)
, e = rnorm(rown)
) %>%
.[, d := 1 + b + c + rnorm(nrow(.))]
first_l_f3 <- function(sd, n)
{
l <- strsplit(sd, split = ' ', fixed = T)
maxl <- max(lengths(l))
sapply(l, "length<-", maxl) %>%
`[`(n,) %>%
as.character
}
microbenchmark({
dt[
, (paste0('w_', 1:3)) := lapply(1:3, function(x) first_l_f3(w, x))
]
})
dt[
, (paste0('w_', 1:3)) := lapply(1:3, function(x) first_l_f3(w, x))
]
Jedinična: milisekunde
expr min lq mean median
{ dt[, `:=`((paste0(«w_», 1:3)), strsplit(w, split = " ", fixed = T))] } 851.7623 916.071 1054.5 1035.199
uq max neval
1178.738 1356.816 100
Skripta je izvršena prosječnom brzinom od 1 sekunde. Nije loše.
Povezano jednom lancem…
S DT objektima možemo raditi koristeći chaining. To izgleda kao dodatak sintakse zagrada s desne strane, u suštini, šećer.
Kod
# chaining
res1 <- dt[a == 'a'][sample(.N, 100)]
res2 <- dt[, .N, a][, N]
res3 <- dt[, coefficients(lm(e ~ d))[1], a][, .(letter = a, coef = V1)]
Teče kroz cijevi…
Slične operacije se mogu izvršiti kroz piping, izgleda slično, ali funkcionalno je bogatije, jer možemo koristiti bilo koje metode, a ne samo DT. Izdvojimo koeficijente logističke regresije za naše sintetičke podatke s nizom filtara na DT.
Kod
# piping
samplpe_b <- dt[a %in% head(letters), sample(b, 1)]
res4 <-
dt %>%
.[a %in% head(letters)] %>%
.[,
{
dt0 <- .SD[1:100]
quants <-
dt0[, c] %>%
quantile(seq(0.1, 1, 0.1), na.rm = T)
.(q = quants)
}
, .(cond = b > samplpe_b)
] %>%
glm(
cond ~ q -1
, family = binomial(link = "logit")
, data = .
) %>%
summary %>%
.[[12]]
Statistika, mašinsko učenje i ostalo unutar DT
Možete koristiti lambda funkcije, ali ponekad je bolje stvarati ih odvojeno, napisati cijeli pipeline analize podataka, i naprijed — one rade unutar DT. Primjer je obogaćen svim navedenim karakteristikama, plus nekoliko korisnih stvari iz arsenala DT (kao što je pristup samom DT unutar DT putem linka, ponekad umetnutih neproporcionalno, ali da to bude).
Kod
# function
rm(lm_preds)
lm_preds <- function(
sd, by, n
)
{
if(
n < 100 |
!by[['a']] %in% head(letters, 4)
)
{
res <-
list(
low = NA
, mean = NA
, high = NA
, coefs = NA
)
} else {
lmm <-
lm(
d ~ c + b
, data = sd
)
preds <-
stats::predict.lm(
lmm
, sd
, interval = "prediction"
)
res <-
list(
low = preds[, 2]
, mean = preds[, 1]
, high = preds[, 3]
, coefs = coefficients(lmm)
)
}
res
}
res5 <-
dt %>%
.[e < 0] %>%
.[.[, .I[b > 0]]] %>%
.[, `:=` (
low = as.numeric(lm_preds(.SD, .BY, .N)[[1]])
, mean = as.numeric(lm_preds(.SD, .BY, .N)[[2]])
, high = as.numeric(lm_preds(.SD, .BY, .N)[[3]])
, coef_c = as.numeric(lm_preds(.SD, .BY, .N)[[4]][1])
, coef_b = as.numeric(lm_preds(.SD, .BY, .N)[[4]][2])
, coef_int = as.numeric(lm_preds(.SD, .BY, .N)[[4]][3])
)
, a
] %>%
.[!is.na(mean), -'e', with = F]
# plot
plo <-
res5 %>%
ggplot +
facet_wrap(~ a) +
geom_ribbon(
aes(
x = c * coef_c + b * coef_b + coef_int
, ymin = low
, ymax = high
, fill = a
)
, size = 0.1
, alpha = 0.1
) +
geom_point(
aes(
x = c * coef_c + b * coef_b + coef_int
, y = mean
, color = a
)
, size = 1
) +
geom_point(
aes(
x = c * coef_c + b * coef_b + coef_int
, y = d
)
, size = 1
, color = 'black'
) +
theme_minimal()
print(plo)
Zaključak
Nadam se da sam uspeo da stvorim celovitu, ali, naravno, ne potpunu sliku objekta kao što je data.table, počinjući od njegovih osobina vezanih za nasleđivanje iz R klasa, pa sve do njegovih specifičnih karakteristika i okruženja elemenata tidyverse. Nadam se da će vam ovo pomoći da bolje istražite i primenite ovu biblioteku za rad i zabavu.

Hvala!
Kompletan kod
Kod
## load libs ----------------
library(data.table)
library(ggplot2)
library(magrittr)
library(microbenchmark)
## arrays ---------
arrmatr <- array(1:20, c(4,5))
class(arrmatr)
typeof(arrmatr)
is.array(arrmatr)
is.matrix(arrmatr)
## lists ------------------
mylist <- as.list(arrmatr)
is.vector(mylist)
is.list(mylist)
## data.frames ------------
df <- as.data.frame(arrmatr)
is.list(df)
df$V6 <- df$V1 + df$V2
## data.tables -----------------------
data.table::setDT(df)
is.list(df)
is.data.frame(df)
is.data.table(df)
df2 <- df
df[V1 == 1, V2 := 999]
data.table::fsetdiff(df, df2)
df2 <- data.table::copy(df)
df[V1 == 2, V2 := 999]
data.table::fsetdiff(df, df2)
## operations on data.tables ------------
#using list properties
df$'V1'[1]
df[['V1']]
df[[1]][1]
sapply(df, class)
sapply(df, function(x) sum(is.na(x)))
## Bigger example ----
rown <- 100000
dt <-
data.table(
w = sapply(seq_len(rown), function(x) paste(sample(letters, 3, replace = T), collapse = ' '))
, a = sample(letters, rown, replace = T)
, b = runif(rown, -3, 3)
, c = runif(rown, -3, 3)
, e = rnorm(rown)
) %>%
.[, d := 1 + b + c + rnorm(nrow(.))]
# vectorization
# zero - for loop
microbenchmark({
for(i in 1:nrow(dt))
{
dt[
i
, first_l := unlist(strsplit(w, split = ' ', fixed = T))[1]
]
}
})
# first
microbenchmark({
dt[
, first_l := unlist(strsplit(w, split = ' ', fixed = T))[1]
, by = 1:nrow(dt)
]
})
# second
first_l_f <- function(sd)
{
strsplit(sd, split = ' ', fixed = T) %>%
do.call(rbind, .) %>%
`[`(,1)
}
dt[, first_l := NULL]
microbenchmark({
dt[
, first_l := .(first_l_f(w))
]
})
# third
first_l_f2 <- function(sd)
{
strsplit(sd, split = ' ', fixed = T) %>%
unlist %>%
matrix(nrow = 3) %>%
`[`(1,)
}
dt[, first_l := NULL]
microbenchmark({
dt[
, first_l := .(first_l_f2(w))
]
})
# fourth
rown <- 100000
words <-
sapply(
seq_len(rown)
, function(x){
nwords <- rbinom(1, 10, 0.5)
paste(
sapply(
seq_len(nwords)
, function(x){
paste(sample(letters, rbinom(1, 10, 0.5), replace = T), collapse = '')
}
)
, collapse = ' '
)
}
)
dt <-
data.table(
w = words
, a = sample(letters, rown, replace = T)
, b = runif(rown, -3, 3)
, c = runif(rown, -3, 3)
, e = rnorm(rown)
) %>%
.[, d := 1 + b + c + rnorm(nrow(.))]
first_l_f3 <- function(sd, n)
{
l <- strsplit(sd, split = ' ', fixed = T)
maxl <- max(lengths(l))
sapply(l, "length<-", maxl) %>%
`[`(n,) %>%
as.character
}
microbenchmark({
dt[
, (paste0('w_', 1:3)) := lapply(1:3, function(x) first_l_f3(w, x))
]
})
dt[
, (paste0('w_', 1:3)) := lapply(1:3, function(x) first_l_f3(w, x))
]
# chaining
res1 <- dt[a == 'a'][sample(.N, 100)]
res2 <- dt[, .N, a][, N]
res3 <- dt[, coefficients(lm(e ~ d))[1], a][, .(letter = a, coef = V1)]
# piping
samplpe_b <- dt[a %in% head(letters), sample(b, 1)]
res4 <-
dt %>%
.[a %in% head(letters)] %>%
.[,
{
dt0 <- .SD[1:100]
quants <-
dt0[, c] %>%
quantile(seq(0.1, 1, 0.1), na.rm = T)
.(q = quants)
}
, .(cond = b > samplpe_b)
] %>%
glm(
cond ~ q -1
, family = binomial(link = "logit")
, data = .
) %>%
summary %>%
.[[12]]
# function
rm(lm_preds)
lm_preds <- function(
sd, by, n
)
{
if(
n < 100 |
!by[['a']] %in% head(letters, 4)
)
{
res <-
list(
low = NA
, mean = NA
, high = NA
, coefs = NA
)
} else {
lmm <-
lm(
d ~ c + b
, data = sd
)
preds <-
stats::predict.lm(
lmm
, sd
, interval = "prediction"
)
res <-
list(
low = preds[, 2]
, mean = preds[, 1]
, high = preds[, 3]
, coefs = coefficients(lmm)
)
}
res
}
res5 <-
dt %>%
.[e < 0] %>%
.[.[, .I[b > 0]]] %>%
.[, `:=` (
low = as.numeric(lm_preds(.SD, .BY, .N)[[1]])
, mean = as.numeric(lm_preds(.SD, .BY, .N)[[2]])
, high = as.numeric(lm_preds(.SD, .BY, .N)[[3]])
, coef_c = as.numeric(lm_preds(.SD, .BY, .N)[[4]][1])
, coef_b = as.numeric(lm_preds(.SD, .BY, .N)[[4]][2])
, coef_int = as.numeric(lm_preds(.SD, .BY, .N)[[4]][3])
)
, a
] %>%
.[!is.na(mean), -'e', with = F]
# plot
plo <-
res5 %>%
ggplot +
facet_wrap(~ a) +
geom_ribbon(
aes(
x = c * coef_c + b * coef_b + coef_int
, ymin = low
, ymax = high
, fill = a
)
, size = 0.1
, alpha = 0.1
) +
geom_point(
aes(
x = c * coef_c + b * coef_b + coef_int
, y = mean
, color = a
)
, size = 1
) +
geom_point(
aes(
x = c * coef_c + b * coef_b + coef_int
, y = d
)
, size = 1
, color = 'black'
) +
theme_minimal()
print(plo)
Izvor: habr.com
