data.table ਦੇ ਆਲੇ-ਦੁਆਲੇ

ਇਹ ਨੋਟ ਉਹਨਾਂ ਲਈ ਦਿਲਚਸਪੀ ਵਾਲਾ ਹੋਵੇਗਾ ਜੋ R - data.table ਲਈ ਟੇਬਲਯੂਲਰ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਅਤੇ ਵੱਖ-ਵੱਖ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਇਸਦੀ ਵਰਤੋਂ ਦੀ ਲਚਕਤਾ ਨੂੰ ਦੇਖ ਕੇ ਖੁਸ਼ ਹੋ ਸਕਦੇ ਹਨ।

ਇੱਕ ਚੰਗੀ ਉਦਾਹਰਣ ਦੁਆਰਾ ਪ੍ਰੇਰਿਤ ਸਾਥੀ, ਅਤੇ ਉਮੀਦ ਕਰਦੇ ਹੋਏ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਉਸਦਾ ਲੇਖ ਪੜ੍ਹ ਲਿਆ ਹੈ, ਮੈਂ ਕੋਡ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਅਧਾਰ ਤੇ ਡੂੰਘਾਈ ਨਾਲ ਖੋਜ ਕਰਨ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰਦਾ ਹਾਂ ਡੇਟਾ.ਟੈਬਲ.

ਜਾਣ-ਪਛਾਣ: data.table ਕਿੱਥੋਂ ਆਉਂਦੀ ਹੈ?

ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਦੂਰੋਂ ਹੀ ਜਾਣਨਾ ਸ਼ੁਰੂ ਕਰਨਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ, ਅਰਥਾਤ, ਡੇਟਾ ਸਟ੍ਰਕਚਰਜ਼ ਦੇ ਨਾਲ, ਜਿੱਥੋਂ data.table ਆਬਜੈਕਟ (ਇਸ ਤੋਂ ਬਾਅਦ DT ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਐਰੇ

ਕੋਡ

## arrays ---------

arrmatr <- array(1:20, c(4,5))

class(arrmatr)

typeof(arrmatr)

is.array(arrmatr)

is.matrix(arrmatr)

ਅਜਿਹੀ ਇੱਕ ਬਣਤਰ ਇੱਕ ਐਰੇ ਹੈ (?ਬੇਸ::ਐਰੇ). ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਾਂਗ, ਇੱਥੇ ਐਰੇ ਬਹੁ-ਆਯਾਮੀ ਹਨ। ਹਾਲਾਂਕਿ, ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਦੋ-ਅਯਾਮੀ ਐਰੇ ਮੈਟ੍ਰਿਕਸ ਕਲਾਸ ਤੋਂ ਵਿਸ਼ੇਸ਼ਤਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ (? ਅਧਾਰ::ਮੈਟ੍ਰਿਕਸ), ਅਤੇ ਇੱਕ ਇੱਕ-ਅਯਾਮੀ ਐਰੇ, ਜੋ ਕਿ ਮਹੱਤਵਪੂਰਨ ਵੀ ਹੈ, ਇੱਕ ਵੈਕਟਰ ਤੋਂ ਪ੍ਰਾਪਤ ਨਹੀਂ ਹੁੰਦਾ (?ਬੇਸ::ਵੈਕਟਰ).

ਇਹ ਸਮਝਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਵੀ ਵਸਤੂ ਵਿੱਚ ਮੌਜੂਦ ਡੇਟਾ ਦੀ ਕਿਸਮ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ ਅਧਾਰ::ਕਿਸਮ, ਜੋ ਕਿ ਅਨੁਸਾਰ ਅੰਦਰੂਨੀ ਕਿਸਮ ਦਾ ਵਰਣਨ ਵਾਪਸ ਕਰਦਾ ਹੈ ਆਰ ਅੰਦਰੂਨੀ - ਮੂਲ ਨਾਲ ਸੰਬੰਧਿਤ ਭਾਸ਼ਾ ਦਾ ਆਮ ਪ੍ਰੋਟੋਕੋਲ C.

ਕਿਸੇ ਵਸਤੂ ਦੀ ਸ਼੍ਰੇਣੀ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਕਮਾਂਡ ਹੈ ਅਧਾਰ::ਕਲਾਸ, ਵੈਕਟਰਾਂ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਵੈਕਟਰ ਕਿਸਮ ਵਾਪਸ ਕਰਦਾ ਹੈ (ਇਹ ਅੰਦਰੂਨੀ ਨਾਮ ਤੋਂ ਵੱਖਰਾ ਹੁੰਦਾ ਹੈ, ਪਰ ਤੁਹਾਨੂੰ ਡੇਟਾ ਕਿਸਮ ਨੂੰ ਸਮਝਣ ਦੀ ਵੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ)।

ਦੀ ਸੂਚੀ

ਇੱਕ ਦੋ-ਅਯਾਮੀ ਐਰੇ ਤੋਂ, ਜਿਸਨੂੰ ਮੈਟ੍ਰਿਕਸ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਤੁਸੀਂ ਸੂਚੀ ਵਿੱਚ ਜਾ ਸਕਦੇ ਹੋ (?ਬੇਸ::ਸੂਚੀ).

ਕੋਡ

## lists ------------------

mylist <- as.list(arrmatr)

is.vector(mylist)

is.list(mylist)

ਕਈ ਚੀਜ਼ਾਂ ਇੱਕੋ ਸਮੇਂ ਹੁੰਦੀਆਂ ਹਨ:

• ਮੈਟ੍ਰਿਕਸ ਦਾ ਦੂਸਰਾ ਆਯਾਮ ਸਮੇਟਦਾ ਹੈ, ਯਾਨੀ ਅਸੀਂ ਇੱਕੋ ਸਮੇਂ ਇੱਕ ਸੂਚੀ ਅਤੇ ਇੱਕ ਵੈਕਟਰ ਦੋਵੇਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ।
• ਇਸ ਤਰ੍ਹਾਂ ਸੂਚੀ ਇਹਨਾਂ ਸ਼੍ਰੇਣੀਆਂ ਤੋਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ। ਇਹ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇੱਕ ਸੂਚੀ ਤੱਤ ਐਰੇ ਮੈਟ੍ਰਿਕਸ ਦੇ ਇੱਕ ਸੈੱਲ ਤੋਂ ਇੱਕ (ਸਕੇਲਰ) ਮੁੱਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੋਵੇਗਾ।

ਕਿਉਂਕਿ ਇੱਕ ਸੂਚੀ ਇੱਕ ਵੈਕਟਰ ਵੀ ਹੈ, ਇਸ ਲਈ ਕੁਝ ਵੈਕਟਰ ਫੰਕਸ਼ਨ ਲਾਗੂ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।

ਡਾਟਾਫ੍ਰੇਮ

ਤੁਸੀਂ ਇੱਕ ਸੂਚੀ, ਮੈਟ੍ਰਿਕਸ ਜਾਂ ਵੈਕਟਰ ਤੋਂ ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਤੱਕ ਜਾ ਸਕਦੇ ਹੋ (?base::data.frame).

ਕੋਡ

## data.frames ------------

df <- as.data.frame(arrmatr)
df2 <- as.data.frame(mylist)

is.list(df)

df$V6 <- df$V1 + df$V2

ਇਸ ਬਾਰੇ ਦਿਲਚਸਪ ਕੀ ਹੈ: ਡੇਟਾਫ੍ਰੇਮ ਸੂਚੀ ਤੋਂ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ! ਡੇਟਾਫ੍ਰੇਮ ਕਾਲਮ ਸੂਚੀ ਸੈੱਲ ਹਨ। ਇਹ ਬਾਅਦ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੋਵੇਗਾ ਜਦੋਂ ਅਸੀਂ ਸੂਚੀਆਂ ਵਿੱਚ ਲਾਗੂ ਕੀਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।

ਡੇਟਾ.ਟੈਬਲ

ਡੀਟੀ ਪ੍ਰਾਪਤ ਕਰੋ (?data.table::data.table) ਤੋਂ ਹੋ ਸਕਦਾ ਹੈ ਡਾਟਾਫ੍ਰੇਮ, ਸੂਚੀ, ਵੈਕਟਰ ਜਾਂ ਮੈਟਰਿਕਸ। ਉਦਾਹਰਨ ਲਈ, ਇਸ ਤਰ੍ਹਾਂ (ਥਾਂ)

ਕੋਡ

## data.tables -----------------------
library(data.table)

data.table::setDT(df)

is.list(df)

is.data.frame(df)

is.data.table(df)

ਇਹ ਲਾਭਦਾਇਕ ਹੈ ਕਿ, ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਵਾਂਗ, ਇੱਕ DT ਇੱਕ ਸੂਚੀ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ।

ਡੀਟੀ ਅਤੇ ਮੈਮੋਰੀ

R ਬੇਸ ਵਿੱਚ ਹੋਰ ਸਾਰੀਆਂ ਵਸਤੂਆਂ ਦੇ ਉਲਟ, DTs ਹਵਾਲੇ ਦੁਆਰਾ ਪਾਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਇੱਕ ਨਵੇਂ ਮੈਮੋਰੀ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਕਾਪੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਦੀ ਲੋੜ ਹੈ data.table::copy ਜਾਂ ਤੁਹਾਨੂੰ ਪੁਰਾਣੀ ਵਸਤੂ ਤੋਂ ਚੋਣ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਕੋਡ

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)

ਇਹ ਜਾਣ-ਪਛਾਣ ਸਮਾਪਤ ਕਰਦਾ ਹੈ। ਡੀਟੀ ਆਰ ਵਿੱਚ ਡੇਟਾ ਢਾਂਚੇ ਦੇ ਵਿਕਾਸ ਦੀ ਇੱਕ ਨਿਰੰਤਰਤਾ ਹੈ, ਜੋ ਮੁੱਖ ਤੌਰ 'ਤੇ ਡੇਟਾਫ੍ਰੇਮ ਕਲਾਸ ਦੀਆਂ ਵਸਤੂਆਂ 'ਤੇ ਕੀਤੇ ਗਏ ਕਾਰਜਾਂ ਦੇ ਵਿਸਥਾਰ ਅਤੇ ਪ੍ਰਵੇਗ ਦੇ ਕਾਰਨ ਵਾਪਰਦਾ ਹੈ। ਉਸੇ ਸਮੇਂ, ਹੋਰ ਆਦਿਮ ਤੋਂ ਵਿਰਾਸਤ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ.

data.table ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਕੁਝ ਉਦਾਹਰਣਾਂ

ਇੱਕ ਸੂਚੀ ਵਾਂਗ...

ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਜਾਂ ਡੀਟੀ ਦੀਆਂ ਕਤਾਰਾਂ ਉੱਤੇ ਦੁਹਰਾਉਣਾ ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਭਾਸ਼ਾ ਵਿੱਚ ਲੂਪ ਕੋਡ R ਬਹੁਤ ਹੌਲੀ C, ਪਰ ਕਾਲਮਾਂ ਨੂੰ ਲੂਪ ਕਰਨਾ ਕਾਫ਼ੀ ਸੰਭਵ ਹੈ, ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਬਹੁਤ ਛੋਟੇ ਹੁੰਦੇ ਹਨ। ਕਾਲਮਾਂ ਵਿੱਚੋਂ ਲੰਘਦੇ ਹੋਏ, ਯਾਦ ਰੱਖੋ ਕਿ ਹਰੇਕ ਕਾਲਮ ਇੱਕ ਸੂਚੀ ਦਾ ਇੱਕ ਤੱਤ ਹੁੰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਵੈਕਟਰ ਹੁੰਦਾ ਹੈ। ਅਤੇ ਵੈਕਟਰਾਂ ਉੱਤੇ ਓਪਰੇਸ਼ਨ ਭਾਸ਼ਾ ਦੇ ਬੁਨਿਆਦੀ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਚੰਗੀ ਤਰ੍ਹਾਂ ਵੈਕਟਰਾਈਜ਼ਡ ਹੁੰਦੇ ਹਨ। ਤੁਸੀਂ ਸੂਚੀਆਂ ਅਤੇ ਵੈਕਟਰਾਂ ਲਈ ਆਮ ਚੋਣ ਓਪਰੇਟਰ ਵੀ ਵਰਤ ਸਕਦੇ ਹੋ: `[[`, `$`.

ਕੋਡ

## 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)))

ਵੈਕਟੋਰਾਈਜ਼ੇਸ਼ਨ

ਜੇਕਰ ਇੱਕ ਵੱਡੇ ਡੀਟੀ ਦੀਆਂ ਲਾਈਨਾਂ ਵਿੱਚੋਂ ਲੰਘਣ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲ ਵੈਕਟਰਾਈਜ਼ੇਸ਼ਨ ਨਾਲ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖਣਾ ਹੋਵੇਗਾ। ਪਰ ਜੇ ਇਹ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਤਾਂ ਤੁਹਾਨੂੰ ਯਾਦ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਚੱਕਰ ਅੰਦਰ ਡੀਟੀ ਅਜੇ ਵੀ ਚੱਕਰ ਨਾਲੋਂ ਤੇਜ਼ ਹੈ R, ਕਿਉਂਕਿ ਇਹ ਇਸ 'ਤੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ C.

ਚਲੋ ਇਸਨੂੰ 100K ਕਤਾਰਾਂ ਦੇ ਨਾਲ ਇੱਕ ਵੱਡੀ ਉਦਾਹਰਨ 'ਤੇ ਅਜ਼ਮਾਓ। ਅਸੀਂ ਵੈਕਟਰ ਕਾਲਮ ਵਿੱਚ ਸ਼ਾਮਲ ਸ਼ਬਦਾਂ ਵਿੱਚੋਂ ਪਹਿਲਾ ਅੱਖਰ ਕੱਢਾਂਗੇ w.

ਅੱਪਡੇਟ

ਕੋਡ

library(magrittr)
library(microbenchmark)

## 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

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))
		]
})

ਪਹਿਲਾਂ ਕਤਾਰਾਂ ਉੱਤੇ ਦੁਹਰਾਓ ਚਲਾਓ:

ਯੂਨਿਟ: ਮਿਲੀਸਕਿੰਟ
expr ਮਿੰਟ
{ dt[, `:=`(first_l, unlist(strsplit(w, split = " ", fixed = T))[1]), by = 1:nrow(dt)] } 439.6217
lq ਦਾ ਮਤਲਬ ਮੱਧਮ uq ਅਧਿਕਤਮ ਨੇਵਲ ਹੈ
451.9998 460.1593 456.2505 460.9147 621.4042 100

ਦੂਜੀ ਰਨ, ਜਿੱਥੇ ਸੂਚੀ ਨੂੰ ਇੱਕ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ ਬਦਲ ਕੇ ਅਤੇ ਸੂਚਕਾਂਕ 1 ਦੇ ਨਾਲ ਟੁਕੜੇ 'ਤੇ ਤੱਤ ਲੈ ਕੇ ਵੈਕਟਰਾਈਜ਼ੇਸ਼ਨ ਹੁੰਦੀ ਹੈ (ਬਾਅਦ ਵਿੱਚ ਵੈਕਟਰਾਈਜ਼ੇਸ਼ਨ ਆਪਣੇ ਆਪ ਹੈ)। ਸੁਧਾਰ: ਫੰਕਸ਼ਨ ਪੱਧਰ 'ਤੇ ਵੈਕਟਰਾਈਜ਼ੇਸ਼ਨ strsplit, ਜੋ ਇੱਕ ਵੈਕਟਰ ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਸੂਚੀ ਨੂੰ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ ਬਦਲਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਆਪਣੇ ਆਪ ਵਿੱਚ ਵੈਕਟਰਾਈਜ਼ੇਸ਼ਨ ਨਾਲੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮੁਸ਼ਕਲ ਹੈ, ਪਰ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਇਹ ਗੈਰ-ਵੈਕਟੋਰਾਈਜ਼ਡ ਸੰਸਕਰਣ ਨਾਲੋਂ ਬਹੁਤ ਤੇਜ਼ ਹੈ।

ਯੂਨਿਟ: ਮਿਲੀਸਕਿੰਟ
expr min lq ਮਤਲਬ ਮੱਧਮ uq ਅਧਿਕਤਮ ਨੇਵਲ
{ dt[, `:=`(first_l, .(first_l_f(w))] } 93.07916 112.1381 161.9267 149.6863 185.9893 442.5199 100

ਵਿੱਚ ਮੱਧਮ ਦੁਆਰਾ ਪ੍ਰਵੇਗ 3 ਵਾਰ.

ਤੀਜੀ ਦੌੜ, ਜਿੱਥੇ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ ਪਰਿਵਰਤਨ ਯੋਜਨਾ ਨੂੰ ਬਦਲਿਆ ਗਿਆ ਸੀ।

ਯੂਨਿਟ: ਮਿਲੀਸਕਿੰਟ
expr min lq ਮਤਲਬ ਮੱਧਮ uq ਅਧਿਕਤਮ ਨੇਵਲ
{ dt[, `:=`(first_l, .(first_l_f2(w))] } 32.60481 34.13679 40.4544 35.57115 42.11975 222.972 100

ਵਿੱਚ ਮੱਧਮ ਦੁਆਰਾ ਪ੍ਰਵੇਗ 13 ਵਾਰ.

ਤੁਹਾਨੂੰ ਇਸ ਮਾਮਲੇ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਜਿੰਨਾ ਜ਼ਿਆਦਾ, ਇਹ ਬਿਹਤਰ ਹੋਵੇਗਾ.

ਵੈਕਟਰਾਈਜ਼ੇਸ਼ਨ ਦੇ ਨਾਲ ਇੱਕ ਹੋਰ ਉਦਾਹਰਨ, ਜਿੱਥੇ ਟੈਕਸਟ ਵੀ ਹੈ, ਪਰ ਇਹ ਅਸਲ ਸਥਿਤੀਆਂ ਦੇ ਨੇੜੇ ਹੈ: ਸ਼ਬਦਾਂ ਦੀ ਵੱਖ-ਵੱਖ ਲੰਬਾਈ, ਸ਼ਬਦਾਂ ਦੀ ਵੱਖਰੀ ਸੰਖਿਆ। ਤੁਹਾਨੂੰ ਪਹਿਲੇ 3 ਸ਼ਬਦ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ:

ਇੱਥੇ ਪਿਛਲਾ ਫੰਕਸ਼ਨ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਕਿਉਂਕਿ ਵੈਕਟਰ ਵੱਖ-ਵੱਖ ਲੰਬਾਈ ਦੇ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਅਸੀਂ ਮੈਟਰਿਕਸ ਦਾ ਆਕਾਰ ਸੈੱਟ ਕਰਦੇ ਹਾਂ। ਆਓ ਇੰਟਰਨੈੱਟ 'ਤੇ ਆਲੇ-ਦੁਆਲੇ ਖੋਦਣ ਦੁਆਰਾ ਇਸਨੂੰ ਦੁਬਾਰਾ ਕਰੀਏ।

ਕੋਡ

# 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))
	]

ਯੂਨਿਟ: ਮਿਲੀਸਕਿੰਟ
expr min lq ਮਤਲਬ ਮੱਧਮਾਨ

{dt[, `:=`((ਪੇਸਟ0(“w_”, 1:3)), strsplit(w, split = "", fixed = T))] } 851.7623 916.071 1054.5 1035.199
uq ਅਧਿਕਤਮ ਨੇਵਲ
1178.738 1356.816 100

ਸਕ੍ਰਿਪਟ 1 ਸਕਿੰਟ ਦੀ ਔਸਤ ਰਫ਼ਤਾਰ ਨਾਲ ਚੱਲੀ। ਭੈੜਾ ਨਹੀਂ.

ਇੱਕ ਚੇਨ ਨਾਲ ਜੁੜਿਆ...

ਤੁਸੀਂ ਚੇਨਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੀਟੀ ਵਸਤੂਆਂ ਨਾਲ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਸੱਜੇ ਪਾਸੇ ਬਰੈਕਟ ਸੰਟੈਕਸ ਨੂੰ ਜੋੜਨ ਵਾਂਗ ਜਾਪਦਾ ਹੈ, ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਖੰਡ।

ਕੋਡ

# 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)]

ਪਾਈਪਾਂ ਰਾਹੀਂ ਵਹਿਣਾ ...

ਉਹੀ ਓਪਰੇਸ਼ਨ ਪਾਈਪਿੰਗ ਦੁਆਰਾ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਇਹ ਸਮਾਨ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਪਰ ਕਾਰਜਸ਼ੀਲ ਤੌਰ 'ਤੇ ਵਧੇਰੇ ਅਮੀਰ ਹੈ, ਕਿਉਂਕਿ ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਨਾ ਕਿ ਸਿਰਫ਼ ਡੀਟੀ. ਆਓ DT 'ਤੇ ਕਈ ਫਿਲਟਰਾਂ ਦੇ ਨਾਲ ਸਾਡੇ ਸਿੰਥੈਟਿਕ ਡੇਟਾ ਲਈ ਲੌਜਿਸਟਿਕ ਰੀਗਰੈਸ਼ਨ ਗੁਣਾਂਕ ਪ੍ਰਾਪਤ ਕਰੀਏ।

ਕੋਡ

# 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]]

DT ਦੇ ਅੰਦਰ ਅੰਕੜੇ, ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ

ਤੁਸੀਂ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਕਈ ਵਾਰ ਉਹਨਾਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਬਣਾਉਣਾ ਬਿਹਤਰ ਹੁੰਦਾ ਹੈ, ਪੂਰੇ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਪਾਈਪਲਾਈਨ ਨੂੰ ਲਿਖੋ, ਅਤੇ ਅੱਗੇ ਵਧੋ - ਉਹ ਡੀਟੀ ਦੇ ਅੰਦਰ ਕੰਮ ਕਰਦੇ ਹਨ। ਉਦਾਹਰਨ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ ਭਰਪੂਰ ਹੈ, ਨਾਲ ਹੀ ਡੀਟੀ ਆਰਸਨਲ ਦੀਆਂ ਕਈ ਉਪਯੋਗੀ ਚੀਜ਼ਾਂ (ਜਿਵੇਂ ਕਿ ਇੱਕ ਲਿੰਕ ਰਾਹੀਂ ਡੀਟੀ ਦੇ ਅੰਦਰ ਡੀਟੀ ਨੂੰ ਐਕਸੈਸ ਕਰਨਾ, ਕਈ ਵਾਰ ਕ੍ਰਮਵਾਰ ਨਹੀਂ, ਪਰ ਇਸ ਤਰ੍ਹਾਂ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ)।

ਕੋਡ

# 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)

ਸਿੱਟਾ

ਮੈਂ ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਮੈਂ ਇੱਕ ਸੰਪੂਰਨ, ਪਰ, ਬੇਸ਼ੱਕ, ਸੰਪੂਰਨ ਨਹੀਂ, data.table ਵਰਗੀ ਇੱਕ ਵਸਤੂ ਦੀ ਤਸਵੀਰ ਬਣਾਉਣ ਦੇ ਯੋਗ ਸੀ, ਆਰ ਕਲਾਸਾਂ ਤੋਂ ਵਿਰਾਸਤ ਨਾਲ ਜੁੜੀਆਂ ਇਸਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸ ਦੀਆਂ ਆਪਣੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਵਾਤਾਵਰਣ ਦੇ ਨਾਲ ਖਤਮ ਹੁੰਦਾ ਹੈ। . ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਤੁਹਾਨੂੰ ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਕੰਮ ਲਈ ਬਿਹਤਰ ਢੰਗ ਨਾਲ ਸਿੱਖਣ ਅਤੇ ਵਰਤਣ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ ਮਨੋਰੰਜਨ.

ਤੁਹਾਡਾ ਧੰਨਵਾਦ!

ਪੂਰਾ ਕੋਡ

ਕੋਡ

## 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)

ਸਰੋਤ: www.habr.com