Tricot Data Types

[lilyclements]

I'm seeing two data structures from looking at Vignette 1 and Vignette 2 on gosset package. These data sets formats show the same information but in different structures: At the indiviudal level, and at the ID-variety-trait level

Two Data Structures

Data Structure One:
This data is in long format, at the ID-variety-trait level.

An example of this is the nicabean data in the gosset package. There are two datasets loaded in, this one is the trial data.

I can see four different "types" of data

1. ID variable (orange)
2. The variety being ranked (blue)
3. The trait being ranked (pink)
4. The ranking given for that variety and that trait (by that individual) (purple).

Data Structure Two:
This data is in wider format, at the ID level with multiple variables to show the variety and ranking.

An example of this is the cassava data in the gosset package

I can see four different "types" of data

1. ID variable (orange)
2. "Marker" variables. In here is just simply what A, B, C are associated to. (blue)
3. Demographic variables (green)
4. Ranking variables (purple). These are how the individual ranked things - we can see from their names it's things like "colour_pos" and "colour_neg". This is just showing which of the individual's A, B, C the user ranked top ("_pos") and bottom ("_neg").

For our "Ranking Variables", we want to run

trait_list <- getTraitList(dat, pattern = c("_pos", "_neg"))

(with "_pos", "_neg" as the name on the variables which denote whether that trait is ranked high or low).

Handing the Two Data Types

A summary our two vignettes in how they handle each of these data types. Both run a rank_* function initially depending on the data type. Note that this rank_* is performed for each of the traits, and outputs a list containing elements of type ranking object.

For Data Structure One:

Note that rank_numeric is run for each of the traits. This outputs a list containing elements of type ranking object.

For Data Structure Two:

Note that rank_tricot is run for each of the traits. This outputs a list containing elements of type ranking object.

trait_list = getTraitList(dat, pattern = c("_pos", "_neg"))

purrr::map(.x = trait_list,
           .f = ~rank_tricot(dat, 
                             items = c("option_a", "option_b", "option_c"), 
                             input = .x$string,
                             validate.rankings = TRUE))

[lilyclements]

From a brief conversation with David, my understanding is that we want to have the data at two levels for display:

The first is how we see cassava - we have the data frame at the ID and demographic level

1. ID variable (orange)
2. "Marker" variables. In here is just simply what A, B, C are associated to. (blue)
3. Demographic variables (green)
4. Ranking variables (purple). These are how the individual ranked things - we can see from their names it's things like "colour_pos" and "colour_neg". This is just showing which of the individual's A, B, C the user ranked top ("_pos") and bottom ("_neg").

The second is a manipulation of this, where we have two variables: id and variety, and then the rest of the columns are the trait's and their rankings.

1. ID variable (orange)
2. The variety being ranked (blue)
3. The ranking given for that variety and that trait (by that individual) (purple).

The data manipulation to turn the first into the second:

pivot_tricot <- function(data, id_var = "id",
                         option_cols = c("option_a", "option_b", "option_c"),
                         possible_ranks = c("A", "B", "C"),
                         trait_good = "_pos", trait_bad = "_neg",
                         na_value = "Not observed"){
  
  label_map <- setNames(option_cols, possible_ranks)
  
  data_options <- data %>% 
    mutate(id = data[[id_var]]) %>%
    pivot_longer(cols = all_of(option_cols),
                 names_to = "Label", values_to = "variable") %>%
    # Dynamically recode
    dplyr::mutate(Label = forcats::fct_recode(Label, !!!label_map))
  
  
  data_options_id <- data_options %>%
    dplyr::select(c(id, variety = Label, variable)) %>%
    unique()
  
  data_options <- data_options %>%
    tidyr::pivot_longer(cols = all_of( c(ends_with(trait_good), ends_with(trait_bad))),
                        names_to = "trait",
                        values_to = "variety") %>%
    dplyr::select(c(id, trait, variety)) %>%
    dplyr::mutate(rank = ifelse(grepl(trait_good, trait), 1, 3)) %>%
    dplyr::mutate(trait = sub("_.*", "", trait)) %>%
    dplyr::filter(!is.na(variety)) %>%
    dplyr::group_by(id, trait) %>%
    dplyr::mutate(variety = if (dplyr::n_distinct(variety) == 1) NA else variety) %>%
    dplyr::filter(!is.na(variety)) %>%
    dplyr::ungroup() %>%
    unique()
  
  rank_2 <- data_options %>%
    dplyr::group_by(id, trait) %>%
    dplyr::filter(variety != na_value) %>%
    dplyr::count() %>%
    dplyr::mutate(rank = 2) %>%
    dplyr::filter(n == 2)
  
  data_options <- data_options %>%
    dplyr::full_join(rank_2) %>%
    dplyr::group_by(id, trait) %>%
    dplyr::mutate(variety = ifelse(is.na(variety), setdiff(possible_ranks, variety)[1], variety)) %>%
    dplyr::ungroup() %>%
    dplyr::arrange(id, trait) %>%
    dplyr::full_join(data_options_id) %>%
    dplyr::select(c(id, trait, rank, variety = variable)) %>%
    tidyr::pivot_wider(names_from = trait, values_from = rank) %>%
    dplyr::filter(!is.na(variety))
  
  return(data_options)
}

pivot_tricot(data = cassava)
pivot_tricot(data = breadwheat, id_var = "participant_name",
                option_cols = c("variety_a", "variety_b", "variety_c"),
                possible_ranks = c("A", "B", "C"), "_best", "_worst") 

[lilyclements]

In terms of tidying, I came across the complete and decode variables which look useful for this (in the PlackettLuce package)

However, the complete variable does not work as we would like it to since it requires a data frame (so does not work with our tidyverse), and can return in a list if we have NAs. There could be some modification needed here.

decode is a way of decoding our options to our variables, but seems to not fit into this sort of tidying structure

[lilyclements]

We can do that we save the trait columns (purple) as a select when the data is defined

[lilyclements]

For nicabean, it is simply a pivot_wider

data(nicabean)
trial <- nicabean$trial
pivot_wider(trial, names_from = trait, values_from = rank)

[lilyclements]

Note that in this format, we can run ranking_numeric instead of ranking_tricot, and get the same output:

Their Vignette Code

library("gosset")
library("ClimMobTools")
library("PlackettLuce")
library("ggplot2")
library("patchwork")

data("cassava", package = "gosset")
dat = cassava
keep = unlist(lapply(dat[1:ncol(dat)], function(x) sum(is.na(x))))
keep = keep == 0
dat = dat[, keep]
names(dat)

# extract list of traits from the data
trait_list = getTraitList(dat, pattern = c("_pos", "_neg"))

# trait names extracted from the function 
traits = unlist(lapply(trait_list, function(x) x$trait_label))

# clean trait names and put them title case
traits = gsub("(^|[[:space:]])([[:alpha:]])", "\\1\\U\\2", traits, perl = TRUE)
pack = c("option_a", "option_b", "option_c")
items = sort(unique(unlist(dat[pack])))
check = "Obasanjo-2"
ov = which(traits %in% "Overall")

dat <- dat %>% arrange(id)
r <- trait_list %>%
  purrr::map(~ {
    gosset::rank_tricot(
      data = dat, 
      id = "id",
      items = c("option_a", "option_b", "option_c"), 
      input = .x$string, 
      validate.rankings = FALSE
    )
  })
names(r) <- traits

Instead reshaping it with our code, and creating the rankings object

pivot_cassava <- pivot_tricot(data = cassava)
data_book$import_data(data_tables=list(pivot_cassava=pivot_cassava))
data_book$add_column_selection(data_name="pivot_cassava", name="all_trait_vars", column_selection=list(C0=list(operation="base::match", parameters=list(x=c("colour", "stretchability", "taste", "overall")))), and_or="|")

pivot_cassava <- data_book$get_data_frame("pivot_cassava")
traits <- data_book$get_column_selection(data_name = "pivot_cassava", name = "all_trait_vars") #get_object (all_trial_vars)
traits <- traits$conditions$C0$parameters$x
pivot_cassava <- pivot_cassava %>% tidyr::pivot_longer(cols = all_of(traits), names_to = "trait", values_to = "rank")
pivot_cassava <- pivot_cassava  %>% dplyr::group_by(id, trait) %>% dplyr::filter(!anyNA(rank))
rankings_list <- traits %>%
  purrr::map(~ {
    pivot_cassava %>%
      dplyr::filter(trait == .x) %>%
      gosset::rank_numeric(data = ., 
                           items = "variety", 
                           input = "rank", 
                           id = "id", 
                           group = FALSE,
                           ascending = FALSE)
  })
names(rankings_list) <- traits



# In the correct order, we can now do rank_numeric, and do away with rank_tricot and now everything can just follow that rank_numeric style. Easy easy.
# So let's look at vignette 2 with rank_numeric style, not rank_tricot, but all works the same since they're both "rankings" objects

class(r$Colour[1])
class(rankings_list[[1]][1])