Working with the GBIF Backbone

## Custom install & load function
install.load.package <- function(x) {
  if (!require(x, character.only = TRUE)) {
    install.packages(x, repos = "http://cran.us.r-project.org")
  }
  require(x, character.only = TRUE)
}
## names of packages we want installed (if not installed yet) and loaded
package_vec <- c(
  "rgbif",
  "knitr" # for rmarkdown table visualisations
)
## executing install & load for each package
sapply(package_vec, install.load.package)

## rgbif knitr 
##  TRUE  TRUE

options(gbif_user = "my gbif username")
options(gbif_email = "my registred gbif e-mail")
options(gbif_pwd = "my gbif password")

The ways in which we record and report species identities is arguably more varied than recorded species identities themselves. For example, while the binomial nomenclature is widely adopted across scientific research, the same species may be still be referred to via different binomial names with descriptor or subspecies suffixes. In addition, particularly when dealing with citizen science data, species names may not always be recorded according to the binomial nomenclature but rather via vernacular names.

The GBIF Backbone Taxonomy circumvents these issues on the data-management side as it assigns unambiguous keys to taxonomic units of interest - these are known as taxonKeys.

Matching between what you require and how GBIF indexes its data is therefore vital to ensure you retrieve the data you need accurately and in full. To discover data themselves, we first need to discover their corresponding relevant identifiers.

Finding the taxonKeys

To identify the relevant taxonKeys for our study organism (Lagopus muta), we will use the name_backbone(...) function to match our binomial species name to the GBIF backbone as follows:

sp_name <- "Lagopus muta"
sp_backbone <- name_backbone(name = sp_name)

Let’s look at the output of this function call:

knitr::kable(sp_backbone)

The data frame / tibble returned by the name_backbone(...) function contains important information regarding the confidence and type of match achieved between the input species name and the GBIF backbone. In addition, it lists all relevant taxonKeys. Of particular to most use-cases are the following columns:

• usageKey: The taxonKey by which this species is indexed in the GBIF backbone.
• matchType: This can be either:
  • EXACT: binomial input matched 1-1 to backbone
  • FUZZY: binomial input was matched to backbone assuming misspelling
  • HIGHERRANK: binomial input is not a species-level name, but indexes a higher-rank taxonomic group
  • NONE: no match could be made

Let’s extract the usageKey of Lagopus muta in the GBIF backbone for later use in this workshop.

sp_key <- sp_backbone$usageKey
sp_key

## [1] 5227679

Resolving Taxonomic Names

Not all species identities are as straightforwardly matched to the GBIF backbone and there is more information stored in the GBIF backbone which may be relevant to users. Here, I would like to spend some time delving further into these considerations.

Matching Input to Backbone

To widen the backbone matching, we can set verbose = TRUE in the name_backbone(...) function. Doing so for Lagopus muta, we obtain the following:

sp_backbone <- name_backbone(name = sp_name, verbose = TRUE)
knitr::kable(sp_backbone)

Seems like, even with widened backbone matching, Lagopus muta is precise enough of a specification for there to be one direct match.

To demonstrate how this widened backbone matching can result in multiple matches, let’s consider Calluna vulgaris - the common heather and my favourite plant:

sp_backbone2 <- name_backbone(name = "Calluna vulgaris", verbose = TRUE)
knitr::kable(t(sp_backbone2))

Here, you can see how fuzzy matching has resulted in an erroneous match with a different plant: Carlina vulgaris - the thistle - also a neat plant, but not the one I was after here.

Competing Name Matches

By horribly misspelling our binomial input, we can coerce an output of match type FUZZY (a match achieved with deviations to the supplied string) or HIGHERRANK (a match indexing the Genus itself):

knitr::kable(name_backbone("Lagopus mut", verbose = TRUE))

To truly see how competing name identifiers can cause us to struggle identifying the correct usageKey we must turn away from Lagopus muta. Instead, let us look at Glocianus punctiger - a species of weevil:

knitr::kable(name_backbone("Glocianus punctiger", verbose = TRUE))

Here, we find that there exist two competing identifiers for Glocianus punctiger in the GBIF backbone in accordance with their competing descriptors. To query data for all Glocianus punctiger records, we should thus always use the keys 11356251 and 4464480.

Matching Names and Backbone for several Species

The above use of name_backbone(...) can be executed for multiple species at once using instead the name_backbone_checklist(...) function. So let’s do so for our target species as well as my favourite plant:

checklist_df <- name_backbone_checklist(c(sp_name, "Calluna vulgaris"))
knitr::kable(checklist_df)

Name Suggestions and Lookup

To catch other commonly used or relevant names for a species of interest, you can use the name_suggest(...) function. This is particularly useful when data mining publications or data sets for records which can be grouped to the same species although they might be recorded with different names:

sp_suggest <- name_suggest(sp_name)$data
knitr::kable(t(head(sp_suggest)))

To trawl GBIF mediated data sets for records of a specific species, one may use the name_lookup(...) function:

sp_lookup <- name_lookup(sp_name)$data
knitr::kable(head(sp_lookup))

Here, we see clearly that Lagopus muta is recorded slightly differently in the datasets mediated by GBIF, but are indexed just fine for GBIF to find them for us.

Lastly, to gain a better understanding of the variety of vernacular names by which our species is know, we can use the name_usage(..., data = "vernacularnames") function as follows:

sp_usage <- name_usage(key = sp_key, data = "vernacularNames")$data
knitr::kable(head(sp_usage))

name_usage(...) can be tuned to output different information and its documentation gives a good overview of this. Simply call ?name_usage to look for yourself.