Table Joining

Vorlesung “Datananalyse in der Biologie”

Herkunft der “nhanes”-Tabelle

Wir möchten nun nachvollziehen, wie die nhanes-Tabelle, mit der wir bisher immer angefangen haben, zustande gekommen ist.

Ich habe sie aus zwei Tabellen zusammengesetzt, die ich beide von der NHANES-Webseite (hier) herunter geladen habe: DEMO_J.XPT (demographics) und BMX_J.XPT (body measurements). Das “J” steht für den Durchgang (2017/18).

Beide Dateien liegen im XPT-Format vor, dem Export-Format von SAS (einem kommeriziellen Statistik-Paket, dass ähnliche Funktionalität wie R bereits stellt). Tidyverse hat eine Sammlung von Import-Filtern, um Daten von Fremd-Programmen zu laden, das Paket “haven”. Darin finden wir die Funktion read_xpt:

suppressPackageStartupMessages( {
  library( tidyverse )
  library( haven ) } )

read_xpt( "Downloads/DEMO_J.XPT" ) -> demo_j

demo_j
# A tibble: 9,254 × 46
    SEQN SDDSRVYR RIDSTATR RIAGENDR RIDAGEYR RIDAGEMN RIDRETH1 RIDRETH3 RIDEXMON
   <dbl>    <dbl>    <dbl>    <dbl>    <dbl>    <dbl>    <dbl>    <dbl>    <dbl>
 1 93703       10        2        2        2       NA        5        6        2
 2 93704       10        2        1        2       NA        3        3        1
 3 93705       10        2        2       66       NA        4        4        2
 4 93706       10        2        1       18       NA        5        6        2
 5 93707       10        2        1       13       NA        5        7        2
 6 93708       10        2        2       66       NA        5        6        2
 7 93709       10        2        2       75       NA        4        4        1
 8 93710       10        2        2        0       11        3        3        2
 9 93711       10        2        1       56       NA        5        6        2
10 93712       10        2        1       18       NA        1        1        2
# ℹ 9,244 more rows
# ℹ 37 more variables: RIDEXAGM <dbl>, DMQMILIZ <dbl>, DMQADFC <dbl>,
#   DMDBORN4 <dbl>, DMDCITZN <dbl>, DMDYRSUS <dbl>, DMDEDUC3 <dbl>,
#   DMDEDUC2 <dbl>, DMDMARTL <dbl>, RIDEXPRG <dbl>, SIALANG <dbl>,
#   SIAPROXY <dbl>, SIAINTRP <dbl>, FIALANG <dbl>, FIAPROXY <dbl>,
#   FIAINTRP <dbl>, MIALANG <dbl>, MIAPROXY <dbl>, MIAINTRP <dbl>,
#   AIALANGA <dbl>, DMDHHSIZ <dbl>, DMDFMSIZ <dbl>, DMDHHSZA <dbl>, …

Die Tabelle enthält 46 Spalten, die mit merkwürdigen Abkürzungen versehen sind. Deren Bedeutung entnehmen wir dem Codebuch für DEMO_J auf der Webseite.

Mit dem Tidyverse-Verb select können wir Spalten auswählen. Die restlichen Spalten werden verworfen:

demo_j %>% select( SEQN, RIAGENDR, RIDAGEYR )
# A tibble: 9,254 × 3
    SEQN RIAGENDR RIDAGEYR
   <dbl>    <dbl>    <dbl>
 1 93703        2        2
 2 93704        1        2
 3 93705        2       66
 4 93706        1       18
 5 93707        1       13
 6 93708        2       66
 7 93709        2       75
 8 93710        2        0
 9 93711        1       56
10 93712        1       18
# ℹ 9,244 more rows

Wir können select auch neue Namen für die Spalten mitgeben, im Format neuerName = alterName:

demo_j %>% 
select( 
  subjectId = SEQN, 
  gender_code = RIAGENDR, 
  age = RIDAGEYR, 
  ethnicity_code = RIDRETH3 ) -> demo_j_selected

demo_j_selected
# A tibble: 9,254 × 4
   subjectId gender_code   age ethnicity_code
       <dbl>       <dbl> <dbl>          <dbl>
 1     93703           2     2              6
 2     93704           1     2              3
 3     93705           2    66              4
 4     93706           1    18              6
 5     93707           1    13              7
 6     93708           2    66              6
 7     93709           2    75              4
 8     93710           2     0              3
 9     93711           1    56              6
10     93712           1    18              1
# ℹ 9,244 more rows

Der Gender-Code

Die Gender-Spalte enthält Code-Zahlen, deren Bedeutung sich auch im Codebuch findet. 1 bedeutet männlich, 2 weiblich.

Wir können diese Code-Tabelle abschreiben:

tibble( 
  code = c( 1, 2 ),
  gender = c( "male", "female" ) ) -> gender_codes

gender_codes
# A tibble: 2 × 2
   code gender
  <dbl> <chr> 
1     1 male  
2     2 female

Nun können wir das neue Tidyverse-Verb left_join verwenden, um die Tabellen zusammen zu fügen:

left_join( demo_j_selected, gender_codes, by = c( "gender_code" = "code" ) )
# A tibble: 9,254 × 5
   subjectId gender_code   age ethnicity_code gender
       <dbl>       <dbl> <dbl>          <dbl> <chr> 
 1     93703           2     2              6 female
 2     93704           1     2              3 male  
 3     93705           2    66              4 female
 4     93706           1    18              6 male  
 5     93707           1    13              7 male  
 6     93708           2    66              6 female
 7     93709           2    75              4 female
 8     93710           2     0              3 female
 9     93711           1    56              6 male  
10     93712           1    18              1 male  
# ℹ 9,244 more rows

Alles zu “left_join”

Die Funktion left_join braucht min. drei Argumente, zwei Tabellen (genannt linke und rechte Tabelle), sowie einen sog. “Schlüssel”.

Die Grundregel für left_join lautet:

  • An jede Zeile der linken Tabelle (demo_j_selected) wird die passende Zeile aus der rechten Tabelle (gender_codes) angehängt werden.
  • Die “passende Zeile” erkennt man daran, dass dort der Wert der Schlüssel-Spalten (key columns) übereinstimmt.

Bei unserem Beispiel gilt also:

  • An jede Zeile der Tabelle demo_j_selected wird die passende Zeile aus der Tabelle gender_codes angehängt werden.
  • Die “passende Zeile” erkennt man daran, dass dort der Wert in der Spalte gender_code der linken Tabelle mit dem Wert in der SPalte code der rechten Tabelle übereinstimmt, weil unser Schlüssel-Argument c( "gender_code" = "code" ) lautet.
  • Im Ergebnis findet man nun alle 4 Spalten aus der linken Tabelle und fast alle Spalten aus der rechten Tabelle. Lediglich die Schlüsselspalte der rechten Tabelle (gender_codes$code) wurde weg gelassen. – Sie wird nicht mehr gebraucht, da sie ja dieselben Werte enthält wie demo_j_selected$gender_code.

Es gibt zwei Sonderregeln für den Fall, dass nicht genau eine Zeile passt

  • Wenn in der rechten Tabelle keine passende Zeile gefunden werden kann, wird NA in die hinzugefügten Felder gesetzt.
  • Wenn in der rechten Tabelle mehrere passende Zeilen gefunden werden, werden mehrere Kopien der Zeile aus der linken Tabelle angefertigt und jeder jeweils eine der gefundenen Zeilen aus der rechten Tabelle angefügt.

Der erste Fall könnte auftreten, falls ein Code in unserem Codebuch fehlt. Dann ist ein NA aber genau, was wir wollen, denn die Information, was der Code bedeutet, fehlt ja.

Der zweite Fall kann für Chaos sorgen, der er Probanden “verdoppeln” könnte. Daher ist wichtig, dass in unserer (rechten) Code-Tabelle kein Code zweimal auftaucht. Als Vorsichtsmaßnahme soltlen wir daher bei unserem left_join das Zusatz-Argument relationship = "many-to-one" angeben, dass eine Fehlermeldung bewirkt, falls es mehr als eine passende rechte Zeile gibt.

Für das Schlüssel-Argument ist noch zu sagen:

  • Die Anführunsgzeichen um die Spaltennamen dürfen nicht fehlen.
  • Oft hat man mehrere Schlüsselspalten, die alle in beiden Tabellen übereinstimmen sollen. Dann gibt man sie einfach an als c( "left_key_1"="right_key_1", "left_key_2"="right_key_2" ).
  • Wenn die Schlüsselspalte in beiden Tabellen gleicht heisst, kann man abgekürzt "key" schreiben statt c("key"="key").

Außerdem:

  • Wenn ein Spaltennamen in beiden Tabellen vorkommt, aber nicht Schlüssel ist, werden beide Spalten übernommen. Zur Unterscheidung werden den Spaltennamen die Suffixes .x und .y angehängt.

Aufgabe

Schreiben Sie aus dem Codebuch die Code-Tabelle für die Ethnien (RIDRETH3) ab. Verwenden Sie left_join, um die Ethnie-Codes durch aussagekräftige Bezeichnungen zu ersetzen.

Lösung

Hier ist die Code-Tabelle:

tibble(
  code = c( 1, 2, 3, 4, 6, 7 ),
  ethnicity = c( "Mexican", "other Hispanic", "NH White", "NH Black",
     "NH Asian", "other/multi" ) ) -> ethnicity_codes

ethnicity_codes
# A tibble: 6 × 2
   code ethnicity     
  <dbl> <chr>         
1     1 Mexican       
2     2 other Hispanic
3     3 NH White      
4     4 NH Black      
5     6 NH Asian      
6     7 other/multi   

Da man bei tibble die Daten spaltenweise angibt, kann man sich leicht vertun.

Die Funktion tribble erlaubt eine zeilenweise (rowwise) Angabe:

tribble(
  ~code, ~ethnicity,
  1, "Mexican",
  2, "other Hispanic",
  3, "NH White",
  4, "NH Black",
  6, "NH Asian",
  7, "other/multi" ) -> ethnicity_codes

ethnicity_codes
# A tibble: 6 × 2
   code ethnicity     
  <dbl> <chr>         
1     1 Mexican       
2     2 other Hispanic
3     3 NH White      
4     4 NH Black      
5     6 NH Asian      
6     7 other/multi   

Nun der left_join:

left_join( demo_j_selected, ethnicity_codes, 
    by = c( "ethnicity_code" = "code" ), relationship="many-to-one" )
# A tibble: 9,254 × 5
   subjectId gender_code   age ethnicity_code ethnicity  
       <dbl>       <dbl> <dbl>          <dbl> <chr>      
 1     93703           2     2              6 NH Asian   
 2     93704           1     2              3 NH White   
 3     93705           2    66              4 NH Black   
 4     93706           1    18              6 NH Asian   
 5     93707           1    13              7 other/multi
 6     93708           2    66              6 NH Asian   
 7     93709           2    75              4 NH Black   
 8     93710           2     0              3 NH White   
 9     93711           1    56              6 NH Asian   
10     93712           1    18              1 Mexican    
# ℹ 9,244 more rows

Beachten Sie, dass man diesen Befehl auch mit Pipes schreiben kann:

demo_j_selected %>%
left_join( ethnicity_codes, 
    by = c( "ethnicity_code" = "code" ), relationship="many-to-one" )
# A tibble: 9,254 × 5
   subjectId gender_code   age ethnicity_code ethnicity  
       <dbl>       <dbl> <dbl>          <dbl> <chr>      
 1     93703           2     2              6 NH Asian   
 2     93704           1     2              3 NH White   
 3     93705           2    66              4 NH Black   
 4     93706           1    18              6 NH Asian   
 5     93707           1    13              7 other/multi
 6     93708           2    66              6 NH Asian   
 7     93709           2    75              4 NH Black   
 8     93710           2     0              3 NH White   
 9     93711           1    56              6 NH Asian   
10     93712           1    18              1 Mexican    
# ℹ 9,244 more rows

Alles zusammen

read_xpt( "Downloads/DEMO_J.XPT") %>% 
select( 
  subjectId = SEQN, 
  gender_code = RIAGENDR, 
  age = RIDAGEYR, 
  ethnicity_code = RIDRETH3 ) %>%
left_join( gender_codes, 
    by = c( "gender_code" = "code" ), relationship="many-to-one" ) %>%
left_join( ethnicity_codes, 
    by = c( "ethnicity_code" = "code" ), relationship="many-to-one" ) %>%
select( -gender_code, -ethnicity_code ) -> demo

demo
# A tibble: 9,254 × 4
   subjectId   age gender ethnicity  
       <dbl> <dbl> <chr>  <chr>      
 1     93703     2 female NH Asian   
 2     93704     2 male   NH White   
 3     93705    66 female NH Black   
 4     93706    18 male   NH Asian   
 5     93707    13 male   other/multi
 6     93708    66 female NH Asian   
 7     93709    75 female NH Black   
 8     93710     0 female NH White   
 9     93711    56 male   NH Asian   
10     93712    18 male   Mexican    
# ℹ 9,244 more rows

Hier haben wir das Verb select in einer alternativen Form verwendet: Wenn man einem Spaltennamen ein Minus voranstellt, wird diese Spalte entfernt und alle anderen Spalten werden beibehalten. Damit haben wir die beiden Code-Spalten entfernt, da wir sie nun nicht mehr brauchen.

Die BMX-Tabelle

Nun laden wir noch die Body-Measures-Tabelle. Sie finden die Datei BMX_J.XPT auf der NHANES-Webseite, Bereich “Survey Data and Documentation”, Durchgang J (2017/18), Abschnitt “Examination Data”.

read_xpt( "Downloads/BMX_J.XPT" )
# A tibble: 8,704 × 21
    SEQN BMDSTATS BMXWT BMIWT BMXRECUM BMIRECUM BMXHEAD BMIHEAD BMXHT BMIHT
   <dbl>    <dbl> <dbl> <dbl>    <dbl>    <dbl>   <dbl>   <dbl> <dbl> <dbl>
 1 93703        1  13.7     3     89.6       NA      NA      NA  88.6    NA
 2 93704        1  13.9    NA     95         NA      NA      NA  94.2    NA
 3 93705        1  79.5    NA     NA         NA      NA      NA 158.     NA
 4 93706        1  66.3    NA     NA         NA      NA      NA 176.     NA
 5 93707        1  45.4    NA     NA         NA      NA      NA 158.     NA
 6 93708        1  53.5    NA     NA         NA      NA      NA 150.     NA
 7 93709        1  88.8    NA     NA         NA      NA      NA 151.     NA
 8 93710        1  10.2    NA     74.3       NA      NA      NA  NA      NA
 9 93711        1  62.1    NA     NA         NA      NA      NA 171.     NA
10 93712        1  58.9    NA     NA         NA      NA      NA 173.     NA
# ℹ 8,694 more rows
# ℹ 11 more variables: BMXBMI <dbl>, BMXLEG <dbl>, BMILEG <dbl>, BMXARML <dbl>,
#   BMIARML <dbl>, BMXARMC <dbl>, BMIARMC <dbl>, BMXWAIST <dbl>,
#   BMIWAIST <dbl>, BMXHIP <dbl>, BMIHIP <dbl>

Aufgabe

Selektieren Sie die Spalten mit der Probanden-ID, dem Körpergewicht in kg und der Körpergröße in cm. Benennen Sie die Spalten um zu “subjectId”, “weight” und “height”.

Fügen Sie diese Tabelle dann unserer fertig decodierten Tabelle von vorher hinzu, indem Sie die Probanden-ID-Nummer als Schlüssel verwenden.

Lösung

Hier ist die Tabelle mit den gewünschten Spalten:

read_xpt( "Downloads/BMX_J.XPT" ) %>%
select( subjectId = SEQN, height = BMXHT, weight = BMXWT  ) -> bmx

bmx
# A tibble: 8,704 × 3
   subjectId height weight
       <dbl>  <dbl>  <dbl>
 1     93703   88.6   13.7
 2     93704   94.2   13.9
 3     93705  158.    79.5
 4     93706  176.    66.3
 5     93707  158.    45.4
 6     93708  150.    53.5
 7     93709  151.    88.8
 8     93710   NA     10.2
 9     93711  171.    62.1
10     93712  173.    58.9
# ℹ 8,694 more rows

Nun fügen wir die beiden Tabellen zusammen:

left_join( demo, bmx, by="subjectId", relationship="one-to-one" ) -> nhanes

nhanes
# A tibble: 9,254 × 6
   subjectId   age gender ethnicity   height weight
       <dbl> <dbl> <chr>  <chr>        <dbl>  <dbl>
 1     93703     2 female NH Asian      88.6   13.7
 2     93704     2 male   NH White      94.2   13.9
 3     93705    66 female NH Black     158.    79.5
 4     93706    18 male   NH Asian     176.    66.3
 5     93707    13 male   other/multi  158.    45.4
 6     93708    66 female NH Asian     150.    53.5
 7     93709    75 female NH Black     151.    88.8
 8     93710     0 female NH White      NA     10.2
 9     93711    56 male   NH Asian     171.    62.1
10     93712    18 male   Mexican      173.    58.9
# ℹ 9,244 more rows

Diesmal haben wir die Probanden-ID (subjectID, SEQN) als Schlüssel verwenden. Durch das relationship="one-to-one" weisen wir R an, zu überprüfen, dass die Probanden-IDs in beiden SPpalten eindeutig sind, also keine Probanden-ID mehrfach vorkommt, weder in der linken noch in der rechten Tabelle.

Nun haben wir die nhanes-Tabelle erstellt:

nhanes
# A tibble: 9,254 × 6
   subjectId   age gender ethnicity   height weight
       <dbl> <dbl> <chr>  <chr>        <dbl>  <dbl>
 1     93703     2 female NH Asian      88.6   13.7
 2     93704     2 male   NH White      94.2   13.9
 3     93705    66 female NH Black     158.    79.5
 4     93706    18 male   NH Asian     176.    66.3
 5     93707    13 male   other/multi  158.    45.4
 6     93708    66 female NH Asian     150.    53.5
 7     93709    75 female NH Black     151.    88.8
 8     93710     0 female NH White      NA     10.2
 9     93711    56 male   NH Asian     171.    62.1
10     93712    18 male   Mexican      173.    58.9
# ℹ 9,244 more rows

Weitere Joins

Der Vollständigkeit halber seien noch die anderen join-Verben aufgeführt

  • Bei left_join werden alle Zeilen der linken Tabelle beibehalten, und Zeilen aus der rechten Tabelle angefügt. Wenn die Zeile rechts fehlt, werden NAs angefügt.
  • Bei right_join sind die Rollen von linker und rechter Tabelle sind vertauscht: Alle Zeilen der rechten Tabelle werden beibehalten, aus der linken wird ausgewählt.
  • Bei inner_join werden nur die Zeilen zu den Schlüssel-Werten behalten, die in beiden Spalten vorkommen. NAs werden nie eingefügt, denn Zeilen, die in einer der Spalten fehlen, werden entfernt.
  • Bei full_join werden die Zeilen beider Tabellen behalten. Wenn der Schlüssel in einer der Tabellen fehlt, werden auf der jeweiligen Seite NAs ergänzt.
  • Bei einem semi_join werden gar keine Spalten angehängt. Statt dessen werden aus der linken Tabelle alle die Zeilen entfernt, die keine passende Zeile in der rechten Tabelle haben.
  • Auch bei einem anti_join werden keine Spalten angehängt. Hier werden aus der linken Tabelle alle Zeilen entfern, zu denen es eine passende Zeile in der rechten Tabelle gibt.

Meist kommt man aber mit dem left_join aus.

Hausaufgaben

Slack-Workspace

Bitte melden Sie sich auf unserem Slack-Workspace an. Dort können Sie jederzeit Fragen zu Vorlesung und Übung stellen.

Body-Measures-Tabelle

Laden Sie die Tabelle “BMX_J” von der NHANES-Webseite herunter und laden Sie sie in R. Selektieren Sie die Spalten mit der Probanden-ID, dem Körpergewicht in kg und der Körpergröße in cm. Benennen Sie die Spalten um zu “subjectId”, “weight” und “height”.

Fügen Sie diese Tabelle dann unserer fertig decodierten Tabelle von vorher (demo) hinzu, indem Sie die Probanden-ID-Nummer als Schlüssel für einen Table-Join verwenden.

Einkommensklassen

In der Tabelle DEMO_J finden Sie eine Spalte zum Haushaltseinkommen: INDHHIN2. Zählen Sie für jede Ethnie getrennt, wie viele Probanden in jede der Einkommensbereiche fallen. Stellen Sie Ihr Ergebnis in geeigneter Weise graphisch dar. Laden Sie Ihren Plot und Ihren Code auf Moodle hoch.

WHO-Gewichts-Kategorien nach Ethnie

Denken Sie bitte an die Hausaufgabe am Ende des Skripts zur Diskretisierung.

Lösung zur Aufgabe “Einkommensklassen”

Zunächst nehmen wir den Code von oben (“Alles zusammen”) und fügen im select-Befehl noch die neue Spalte INDHHIN2 hinzu.

read_xpt( "Downloads/DEMO_J.XPT") %>% 
select( 
  subjectId = SEQN, 
  gender_code = RIAGENDR, 
  age = RIDAGEYR, 
  ethnicity_code = RIDRETH3,
  income_code = INDHHIN2 ) %>%   # <<<<<< Nur diese Zeile ist neu <<<<<<<<
left_join( gender_codes, 
    by = c( "gender_code" = "code" ), relationship="many-to-one" ) %>%
left_join( ethnicity_codes, 
    by = c( "ethnicity_code" = "code" ), relationship="many-to-one" ) %>%
select( -gender_code, -ethnicity_code ) -> demo0

demo0
# A tibble: 9,254 × 5
   subjectId   age income_code gender ethnicity  
       <dbl> <dbl>       <dbl> <chr>  <chr>      
 1     93703     2          15 female NH Asian   
 2     93704     2          15 male   NH White   
 3     93705    66           3 female NH Black   
 4     93706    18          NA male   NH Asian   
 5     93707    13          10 male   other/multi
 6     93708    66           6 female NH Asian   
 7     93709    75           2 female NH Black   
 8     93710     0          15 female NH White   
 9     93711    56          15 male   NH Asian   
10     93712    18           4 male   Mexican    
# ℹ 9,244 more rows

Um nicht mit dem Code oben durcheinander zu kommen, heisst die Tabelle diesmal demo0 statt demo.

Nun konstruieren wir die Code-Tabelle. Man kann sie einfach abtippen, aber hier ist ein Weg, wie man das erleichtern kann. Wir beschließen zunächst, die Codes 12 und 13 auszulassen, da sie nicht ins Schema passen. Also bleiben wir bei den Codes von 1 bis 10 sowie 14 und 15, und schreiben uns dazu jeweils die Tausender der unteren Grenzen der Intervalle:

tibble( 
  code = c( 1:10, 14, 15 ),
  from = 1000 * c( 0, 5, 10, 15, 20, 25, 35, 45, 55, 65, 75, 100 ) )
# A tibble: 12 × 2
    code   from
   <dbl>  <dbl>
 1     1      0
 2     2   5000
 3     3  10000
 4     4  15000
 5     5  20000
 6     6  25000
 7     7  35000
 8     8  45000
 9     9  55000
10    10  65000
11    14  75000
12    15 100000

Achtung: Hier habe ich in der Vorlesung einen Fehler gemacht. Ich habe die Codes 1 bis 10 einfach mal 5000 genommen, dabei aber nicht gemerkt, dass es ab Code 8 in 10,000en-Schritten weiter geht. Deshalbn habe ich sie diesmal abgetippt.

Nun brache ich die Obergrenzen. Die nehme ich aus den untergrenzen der Vorherigen Zeile. Hier hilft uns die Funktion lead, die alle Werte in einem vektor um einen Schritt nach links schiebt:

lead( 1:10 )
 [1]  2  3  4  5  6  7  8  9 10 NA

WIe man sieht, fällt der erste Wert weg und hinten wird ein NA angefügt.

Ich benutze das so:

tibble( 
  code = c( 1:10, 14, 15 ),
  from = 1000 * c( 0, 5, 10, 15, 20, 25, 35, 45, 55, 65, 75, 100 ) ) %>%
mutate( to = lead(from) - 1 )
# A tibble: 12 × 3
    code   from    to
   <dbl>  <dbl> <dbl>
 1     1      0  4999
 2     2   5000  9999
 3     3  10000 14999
 4     4  15000 19999
 5     5  20000 24999
 6     6  25000 34999
 7     7  35000 44999
 8     8  45000 54999
 9     9  55000 64999
10    10  65000 74999
11    14  75000 99999
12    15 100000    NA

Nun kann ich noch Labels anfügen, die wir später zur Beschriftung des Plots verwenden:

tibble( 
  code = c( 1:10, 14, 15 ),
  from = 1000 * c( 0, 5, 10, 15, 20, 25, 35, 45, 55, 65, 75, 100 ) ) %>%
mutate( to = lead(from) - 1 ) %>%
mutate( income_range = str_glue( "${from}-${to}" ) ) -> income_codes
income_codes
# A tibble: 12 × 4
    code   from    to income_range 
   <dbl>  <dbl> <dbl> <glue>       
 1     1      0  4999 $0-$4999     
 2     2   5000  9999 $5000-$9999  
 3     3  10000 14999 $10000-$14999
 4     4  15000 19999 $15000-$19999
 5     5  20000 24999 $20000-$24999
 6     6  25000 34999 $25000-$34999
 7     7  35000 44999 $35000-$44999
 8     8  45000 54999 $45000-$54999
 9     9  55000 64999 $55000-$64999
10    10  65000 74999 $65000-$74999
11    14  75000 99999 $75000-$99999
12    15 100000    NA $1e+05-$NA   

Hier haben wir die Funtion str_glue benutzt, in der man einen String vorgeben kann, indem dann die Teile, die in geschweifte Klammern eigefügt sind, durch die entsprechenden Spalten ersetzt werden. Mann kann auch Rechnungen in die Klammern schreiben.

Leider ist die letzte Zeile (Zeile 12) komisch geworden; das bessern wir manuell aus, mit str_replace, das ein “Suchen und Ersetzen” in einem String-Vektor oder einer Spalte vornehmen kann:

income_codes %>%
mutate( income_range = str_replace( income_range, fixed("$1e+05-$NA"), "above $100000" ) )
# A tibble: 12 × 4
    code   from    to income_range 
   <dbl>  <dbl> <dbl> <chr>        
 1     1      0  4999 $0-$4999     
 2     2   5000  9999 $5000-$9999  
 3     3  10000 14999 $10000-$14999
 4     4  15000 19999 $15000-$19999
 5     5  20000 24999 $20000-$24999
 6     6  25000 34999 $25000-$34999
 7     7  35000 44999 $35000-$44999
 8     8  45000 54999 $45000-$54999
 9     9  55000 64999 $55000-$64999
10    10  65000 74999 $65000-$74999
11    14  75000 99999 $75000-$99999
12    15 100000    NA above $100000

Hier nochmal der gesamte Code, um die Code-Tabelle zu erzeugen:

tibble( 
  code = c( 1:10, 14, 15 ),
  from = 1000 * c( 0, 5, 10, 15, 20, 25, 35, 45, 55, 65, 75, 100 ) ) %>%
mutate( to = lead(from) - 1 ) %>%
mutate( income_range = str_glue( "${from}-${to}" ) ) %>%
mutate( income_range = str_replace( income_range, fixed("$1e+05-$NA"), "above $100000" ) ) %>%
mutate( income_range = fct_inorder( income_range ) ) -> income_codes

Hier ist noch neu das fct_inorder in der letzten Zeile hinzugekommen. Es bedeutet: 1. Wandle die Spalte income_range in einen Faktor um, d.h. einen Vektor, indem nur eine vorgegebene begrenzte Liste von Strings vorkommen dürfen, weise jedem String eine Nummer zu und 2. weise die Nummern so zu, dass die zugelassenen Wörter in der Reihenfolge durchnummeriert werden, in der sie in der Spalte vorkommen.

Der erste Punkt ist allen Funktionen, die mit fct_ beginnen gemein, der zweite ist spezifisch für fct_inorder (hier “in order”, d.h. “in der Reihenfolge” wie angegeben).

Zweck der Sache ist, eine Reihenfolge festzulegen, in der diese Faktor-Levels dann z.B. in Plots anreordnet werden. Ohne das fct_inorder würde ggplot die Levels nämlich “lexikographisch” sortieren, d.h. alphabetisch, zusammen mit merkwürdigen Regeln, falls es (wie hier) keine Buchstaben sind.

Diese Code-Tabelle zu erzeugen war etwas kompliziert; man hätte sie aber auch einfach abtippen können, wie weiter oben gezeigt. Nun geht es aber weiter wie wir es bereits in der Vorlesung gesehen haben.

Zuerst “joinen” wir die Code-Tabelle, genauso wie weiter oben in diesem Skript:

demo0 %>%
left_join( income_codes, by=c("income_code"="code") ) 
# A tibble: 9,254 × 8
   subjectId   age income_code gender ethnicity     from    to income_range 
       <dbl> <dbl>       <dbl> <chr>  <chr>        <dbl> <dbl> <fct>        
 1     93703     2          15 female NH Asian    100000    NA above $100000
 2     93704     2          15 male   NH White    100000    NA above $100000
 3     93705    66           3 female NH Black     10000 14999 $10000-$14999
 4     93706    18          NA male   NH Asian        NA    NA <NA>         
 5     93707    13          10 male   other/multi  65000 74999 $65000-$74999
 6     93708    66           6 female NH Asian     25000 34999 $25000-$34999
 7     93709    75           2 female NH Black      5000  9999 $5000-$9999  
 8     93710     0          15 female NH White    100000    NA above $100000
 9     93711    56          15 male   NH Asian    100000    NA above $100000
10     93712    18           4 male   Mexican      15000 19999 $15000-$19999
# ℹ 9,244 more rows

Dann gruppieren wir nach Ethnie und Einkommensklasse und zählen:

demo0 %>%
left_join( income_codes, by=c("income_code"="code") ) %>%
group_by( ethnicity, income_range ) %>%
summarise( n=n() ) 
`summarise()` has grouped output by 'ethnicity'. You can override using the
`.groups` argument.
# A tibble: 78 × 3
# Groups:   ethnicity [6]
   ethnicity income_range      n
   <chr>     <fct>         <int>
 1 Mexican   $0-$4999         52
 2 Mexican   $5000-$9999      32
 3 Mexican   $10000-$14999    79
 4 Mexican   $15000-$19999    83
 5 Mexican   $20000-$24999    77
 6 Mexican   $25000-$34999   148
 7 Mexican   $35000-$44999   162
 8 Mexican   $45000-$54999   103
 9 Mexican   $55000-$64999    88
10 Mexican   $65000-$74999    64
# ℹ 68 more rows

Da wir Prozent-Werte pro Ethnie haben wollen, müssen wir nochmal gruppieren und durch sum(n) teilen. Das hatten wir schonmal, im vorigen Skript:

demo0 %>%
left_join( income_codes, by=c("income_code"="code") ) %>%
group_by( ethnicity, income_range ) %>%
summarise( n=n() ) %>%
group_by( ethnicity ) %>%
mutate( percent = n / sum(n) * 100 ) -> income_data
`summarise()` has grouped output by 'ethnicity'. You can override using the
`.groups` argument.
income_data
# A tibble: 78 × 4
# Groups:   ethnicity [6]
   ethnicity income_range      n percent
   <chr>     <fct>         <int>   <dbl>
 1 Mexican   $0-$4999         52    3.80
 2 Mexican   $5000-$9999      32    2.34
 3 Mexican   $10000-$14999    79    5.78
 4 Mexican   $15000-$19999    83    6.07
 5 Mexican   $20000-$24999    77    5.63
 6 Mexican   $25000-$34999   148   10.8 
 7 Mexican   $35000-$44999   162   11.9 
 8 Mexican   $45000-$54999   103    7.53
 9 Mexican   $55000-$64999    88    6.44
10 Mexican   $65000-$74999    64    4.68
# ℹ 68 more rows

Hier nun der Plot

income_data %>%
ggplot( aes( x=ethnicity, y=percent, fill=income_range ) ) +
  geom_col()

Das fct_inorder weiter oben hat sicher gestellt, dass hier die Farben in einer sinnvollen Reihenfolge sind.

Wirklich schön ist der Plot aber nicht.

Schöner wäre es, wenn die Einkommensklassen nebeneinander angeordnet wären und jede Ethnie ihre eigene Facette bekäme. Das ist schnell gemacht:

income_data %>%
ggplot( aes( x=income_range, y=percent ) ) +
  geom_col() + 
  facet_grid( rows = "ethnicity") 

Nun hängen wir noch eine Zeile an, um die Beschriftung der x-Achse zu drehen:

income_data %>%
ggplot( aes( x=income_range, y=percent ) ) +
  geom_col() + 
  facet_grid( rows = "ethnicity") +
  theme(axis.text.x = element_text(angle = 90, vjust = 0.5, hjust=1))

Letzter Schönheitsfehler ist hier noch, dass es irreführend ist, dass die Balken bei $25k-$35k plötzlich größer werden, was aber nur daran liegt, dass dieser Balken eine Spanne von $10k abdeckt, der links davon aber nur $5k.

Man könnte dazu die Breite der Balken proportional zur Breite ihrer Spanne machen, und die Anzahl der Probanden im jeweiligen Einkommensinterval nicht durch die Höhe sondern durch die Fläche der Balken darstellen. Das nennt man die Histogramm-Regel. Sie ist aber hier schwierig umzusetzen, u.a., weil wir nicht wissen, wie weit der vorletzte Balken (“above $100000”) geht.

Also lassen wir es dabei bewenden.