Oh, lasă -l afară | R-BLOGGERS

Uneori vrem să facem în mod repetat lucruri cu toate un rând, cu excepția unui rând dintr -un cadru de date, unde renunțăm sistematic pe fiecare rând pe rând și facem lucrurile. De exemplu, validarea încrucișată Jacknife este un fel de tehnică de bootstrap foarte de bază. ) Uneori vrem să facem acest lucru în cadrul grupurilor, poate mai ales atunci când grupurile pot fi mici.

În primul rând, o amintire rapidă despre una dintre convențiile lui R pentru a face referire la elementele vectorilor și cadrelor de date. Dacă avem

1
2

letters
#>  (1) "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"

Putem scrie de exemplu,

1
2

letters(2)
#> (1) "b"

pentru a obține al doilea element al letters vector. Dar putem scrie și noi

1
2

letters(-2)
#>  (1) "a" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"

Pentru a obține totul letters cu excepţia Al doilea element. La îndemână. Același lucru este valabil și pentru cadre de date. Pentru că acestea sunt două dimensiuni, scriem de exemplu df(2,5) pentru a indexa al 2 -lea rând și a 5 -a coloană a df. Dar putem aplica indici negativi la aceia și pentru a renunța, mai degrabă decât să păstreze un rând sau o coloană.

Acum, iată un mic cadru de date:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

library(tidyverse)

df <- tibble(var1 = rep(LETTERS(1:6), each = 2), 
             var2 = rep(c("Blue", "Green"), 6), 
             val = rpois(12, 4))

df
#> # A tibble: 12 × 3
#>    var1  var2    val
#>      
#>  1 A     Blue      2
#>  2 A     Green     8
#>  3 B     Blue      5
#>  4 B     Green     5
#>  5 C     Blue      4
#>  6 C     Green     6
#>  7 D     Blue      6
#>  8 D     Green     9
#>  9 E     Blue      4
#> 10 E     Green     1
#> 11 F     Blue      1
#> 12 F     Green     2

Să zicem că vrem să obținem mijloace de plecare pentru grupurile albastre și verzi. Putem face acest lucru folosind map() să se interezeze peste grupuri în timp ce renunțați la fiecare rând o dată în grupuri la rândul grupurilor? Putem.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

df |>
  group_by(var2) |>
  mutate(
    jk_mean = map_dbl(row_number(), (x) mean(val(-x)))
  )
#> # A tibble: 12 × 4
#> # Groups:   var2 (2)
#>    var1  var2    val jk_mean
#>         
#>  1 A     Blue      2     4  
#>  2 A     Green     8     4.6
#>  3 B     Blue      5     3.4
#>  4 B     Green     5     5.2
#>  5 C     Blue      4     3.6
#>  6 C     Green     6     5  
#>  7 D     Blue      6     3.2
#>  8 D     Green     9     4.4
#>  9 E     Blue      4     3.6
#> 10 E     Green     1     6  
#> 11 F     Blue      1     4.2
#> 12 F     Green     2     5.8

row_number() Funcția ne oferă un indice de rând unic, care map_dbl() Se aplică la orice vrem să facem în continuare, făcându -l o funcție anonimă Lambda (x). Valorile x sunt hrăniți pe rând mean(val(-x))și The val(-x) Partea scade elementul _X_TH din val de fiecare dată când calculați media.

Cu mutate() primim întregul cadru de date înapoi, unde jk_mean Coloana este valoarea mediei grupului atunci când acel rând este abandonat. Dacă dorim doar mijloacele de plecare și grupuri, nu putem folosi summarize() direct, pentru că primim mai mult de un rând pe grup înapoi. Deci folosim reframe() În schimb:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

df |>
  group_by(var2) |>
  reframe(
    jk_mean = map_dbl(row_number(), (x) mean(val(-x)))
  )
#> # A tibble: 12 × 2
#>    var2  jk_mean
#>       
#>  1 Blue      4  
#>  2 Blue      3.4
#>  3 Blue      3.6
#>  4 Blue      3.2
#>  5 Blue      3.6
#>  6 Blue      4.2
#>  7 Green     4.6
#>  8 Green     5.2
#>  9 Green     5  
#> 10 Green     4.4
#> 11 Green     6  
#> 12 Green     5.8

În cele din urmă, ce se întâmplă dacă, din anumite motive, dorim o listă de douăsprezece cadre de date stânga-out-out, din nou de grup? Pentru aceasta putem folosi map() de două ori peste:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

jk_list <- df |>
  group_split(var2) |>
  map((x) map(seq_len(nrow(x)), (i) x(-i, ))) |>
  flatten()

length(jk_list)
#> (1) 12

## First element of the list
jk_list((1))
#> # A tibble: 5 × 3
#>   var1  var2    val
#>     
#> 1 B     Blue      5
#> 2 C     Blue      4
#> 3 D     Blue      6
#> 4 E     Blue      4
#> 5 F     Blue      1

Aici folosim group_split() Pentru a obține o listă cu un cadru de date albastru și un cadru de date verzi. Apoi folosim o hartă în hartă pentru un fel de buclă cuibărită. Interiorul map() Ne oferă un vector de la 1 la orice este numărul de rânduri din cadrul de date al fiecărui grup. (Iată șase în fiecare caz.) Acest lucru va fi apelat i. Harta exterioară iterează acest lucru peste fiecare grup, oferindu -ne x(-i, )sau fiecare cadru de date grupat x cu rândul _i_th a scăzut în fiecare caz. Încheiem cu o listă cu 12 cadre de date noi. Fiecare are cinci rânduri în loc de cele șase inițial în grupul său, cu un rând diferit scăzut pe rând.