डाटा तालिका वरिपरि

यो नोट 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)

धेरै कुराहरू एकैचोटि हुन्छन्:

• म्याट्रिक्सको दोस्रो आयाम पतन हुन्छ, अर्थात्, हामीले एकै समयमा सूची र भेक्टर दुवै पाउँछौं।
• यसरी सूची यी वर्गहरूबाट प्राप्त हुन्छ। यो ध्यानमा राख्नु पर्छ कि सूची तत्व म्याट्रिक्स-एरेको कक्षबाट एक (स्केलर) मानसँग मेल खान्छ।

सूची पनि भेक्टर भएकोले, यसमा केही भेक्टर प्रकार्यहरू लागू गर्न सकिन्छ।

डेटाफ्रेम

सूची, म्याट्रिक्स वा भेक्टरबाट तपाईं डाटाफ्रेममा जान सक्नुहुन्छ (?आधार::डेटा.फ्रेम).

कोड

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

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

is.list(df)

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

यसको बारेमा रोचक कुरा के हो भने डेटाफ्रेम सूचीबाट प्राप्त हुन्छ! डेटाफ्रेमका स्तम्भहरू सूचीका कक्षहरू हुन्। यो पछि महत्त्वपूर्ण हुनेछ जब हामी सूचीहरूमा लागू हुने प्रकार्यहरू प्रयोग गर्छौं।

डाटा.टेबल

DT प्राप्त गर्नुहोस् (?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 आधारमा रहेका अन्य सबै वस्तुहरू भन्दा फरक, DT हरू सन्दर्भद्वारा पास हुन्छन्। यदि तपाईंलाई नयाँ मेमोरी क्षेत्रमा प्रतिलिपि गर्न आवश्यक छ भने, तपाईंलाई प्रकार्य चाहिन्छ। data.table::प्रतिलिपि वा तपाईंले पुरानो वस्तुबाट चयन गर्नुपर्नेछ।

कोड

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)

यसले परिचयको अन्त्य गर्छ। DT भनेको R मा डेटा संरचनाहरूको विकासको निरन्तरता हो, जुन मुख्यतया डेटाफ्रेम वर्गका वस्तुहरूमा गरिएका कार्यहरूको विस्तार र प्रवेगको कारणले हुन्छ। एकै समयमा, अन्य आदिमहरूबाट प्राप्त उत्तराधिकार संरक्षित छ।

data.table गुणहरू प्रयोग गर्ने केही उदाहरणहरू

सूचीको रूपमा…

डेटाफ्रेम वा DT को पङ्क्तिहरूमा दोहोर्याउनु राम्रो विचार होइन, किनकि लूप कोड भाषामा छ। 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)))

भेक्टराइजेशन

यदि ठूलो DT को लाइनहरू मार्फत जान आवश्यक छ भने, उत्तम समाधान भेक्टराइजेसनको साथ प्रकार्य लेख्नु हुनेछ। तर यदि यसले काम गर्दैन भने, तपाईंले याद गर्नुपर्छ कि चक्र भित्र DT अझै पनि चक्र भन्दा छिटो छ। R, किनकि यो मा प्रदर्शन गरिएको छ C.

१०० हजार पङ्क्तिहरू भएको ठूलो उदाहरणमा यसलाई प्रयास गरौं। हामी भेक्टर स्तम्भमा समावेश गरिएका शब्दहरूबाट पहिलो अक्षर निकाल्नेछौं। 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))
		]
})

पङ्क्तिहरूमा पुनरावृत्ति सहित पहिलो पटक चलाउनुहोस्:

एकाइ: मिलिसेकेन्ड
न्यूनतम एक्सप्रेस
{ dt[, `:=`(first_l, unlist(strsplit(w, split = " ", fixed = T))[1]), by = 1:nrow(dt)] } ४३९.६२१७
lq औसत औसत uq अधिकतम नेभल
451.9998 460.1593 456.2505 460.9147 621.4042 100

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

एकाइ: मिलिसेकेन्ड
expr min lq मतलब median uq max neval
{ dt[, `:=`(पहिलो_l, .(पहिलो_l_f(w)))] } ९३.०७९१६ ११२.१३८१ १६१.९२६७ 149.6863 185.9893 442.5199 100

मध्यका अनुसार प्रवेग in 3 पटक.

तेस्रो रन, जहाँ म्याट्रिक्स रूपान्तरण योजना परिवर्तन गरिएको थियो।

एकाइ: मिलिसेकेन्ड
expr min lq मतलब median uq max neval
{ dt[, `:=`(पहिलो_l, .(पहिलो_l_f2(w)))] } ३२.६०४८१ ३४.१३६७९ ४०.४५४४ 35.57115 42.11975 222.972 100

मध्यका अनुसार प्रवेग in 13 पटक.

तपाईंले यो कुरामा प्रयोग गर्नुपर्छ, जति धेरै त्यति राम्रो।

भेक्टराइजेसनको अर्को उदाहरण, जहाँ पाठ पनि छ, तर यो वास्तविक अवस्थाको नजिक छ: शब्दहरूको फरक लम्बाइ, शब्दहरूको फरक संख्या। पहिलो ३ शब्दहरू प्राप्त गर्न आवश्यक छ। यसरी:

यहाँ अघिल्लो प्रकार्यले काम गर्दैन, किनकि भेक्टरहरू फरक लम्बाइका छन्, र हामीले म्याट्रिक्स साइज निर्दिष्ट गरेका छौं। इन्टरनेटमा वरिपरि खोजेर यसलाई पुन: गरौं।

कोड

# 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 न्यूनतम lq माध्य मध्यक

{ dt[, `:=`((paste0(“w_”, 1:3)), strsplit(w, विभाजन = " ", स्थिर = T))] } ८५१.७६२३ ९१६.०७१ १०५४.५ 1035.199
uq अधिकतम नेभल
1178.738 1356.816 100

स्क्रिप्टले औसत १ सेकेन्डको गतिमा काम गर्‍यो। नराम्रो होइन।

एउटै चेनद्वारा जोडिएको...

तपाईं चेनिङ प्रयोग गरेर DT वस्तुहरूसँग काम गर्न सक्नुहुन्छ। यो दायाँतिर कोष्ठक सिन्ट्याक्स संलग्न गरेको जस्तो देखिन्छ, मूल रूपमा चिनी।

कोड

# 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 मात्र होइन। 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 भित्र तथ्याङ्क, मेसिन लर्निङ र अन्य कुराहरू

तपाईं ल्याम्ब्डा प्रकार्यहरू प्रयोग गर्न सक्नुहुन्छ, तर कहिलेकाहीँ तिनीहरूलाई छुट्टै सिर्जना गर्नु, सम्पूर्ण डेटा विश्लेषण पाइपलाइन लेख्नु र अगाडि बढ्नु राम्रो हुन्छ - तिनीहरू DT भित्र काम गर्छन्। उदाहरण माथिका सबै सुविधाहरूले समृद्ध छ, साथै DT शस्त्रागारबाट धेरै उपयोगी चीजहरू (जस्तै सन्दर्भद्वारा DT भित्र 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 जस्तो वस्तुको पूर्ण, तर निश्चित रूपमा पूर्ण नभएको तस्वीर सिर्जना गर्न सक्षम भएँ, जुन R वर्गहरूबाट उत्तराधिकारसँग सम्बन्धित यसको गुणहरूबाट सुरु हुन्छ र tidyverse तत्वहरूबाट यसको आफ्नै सुविधाहरू र वातावरणको साथ समाप्त हुन्छ। मलाई आशा छ कि यसले तपाईंलाई यो पुस्तकालयलाई राम्रोसँग बुझ्न र कामको लागि लागू गर्न मद्दत गर्नेछ र मनोरञ्जन.

धन्यवाद!

पूर्ण कोड

कोड

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