# Fitting Examples Using `fddm`

#### Kendal Foster and Henrik Singmann

#### July 01, 2024

Function `ddm()` fits the 5-parameter Ratcliff diffusion decision model (DDM) via maximum likelihood estimation. The model for each DDM parameter can be specified symbolically using R’s formula interface. With the exception of the drift rate (which is always estimated) all parameters can be either fixed or estimated. As maximum likelihood estimation is based on evaluating the probability density function (PDF), other vignettes in the `fddm` package address the properties of the function `dfddm()` that are used to evaluate the PDF. An overview of the mathematical details of the different PDF approximations is provided in the Math Vignette. An empirical validation of the implemented PDF methods is provided in the Validity Vignette. Timing benchmarks for the present PDF methods and comparison with existing methods are provided in the Benchmark Vignette.

Our implementation of the DDM has the following parameters: \(a \in (0, \infty)\) (threshold separation), \(v \in (-\infty, \infty)\) (drift rate), \(t_0 \in [0, \infty)\) (non-decision time/response time constant), \(w \in (0, 1)\) (relative starting point), \(sv \in (0, \infty)\) (inter-trial-variability of drift), and \(\sigma \in (0, \infty)\) (diffusion coefficient of the underlying Wiener Process).

# Introduction

This vignette contains examples of two different ways to use `fddm` in fitting the DDM to user-supplied real-world data. First, we will demonstrate the use of the `ddm()` function; we suggest this as the preferred method for most use cases. The `ddm()` function allows the user to specify which model parameters they want to be estimated and which model parameters they want to remain fixed. Should the user desire more minute control over the fitting procedure, we will show a second method of fitting the DDM that utilizes the exposed likelihood function, `dfddm()`. This method uses the `dfddm()` function to construct a log-likelihood function that will be supplied to an optimization routine to estimate each model parameter. The examples that we provide are meant for illustrative purposes, and as such, we will provide a sample analysis for each example.

We will load the `fddm::med_dec` dataset that is included in the `fddm` package, and we will use this dataset to fit the Ratcliff DDM in both fitting procedures. This dataset contains the accuracy condition reported in Trueblood et al. (2018), which investigates medical decision making among medical professionals (pathologists) and novices (i.e., undergraduate students). The task of participants was to judge whether pictures of blood cells show cancerous cells (i.e., blast cells) or non-cancerous cells (i.e., non-blast cells). The dataset contains 200 decisions per participant, based on pictures of 100 true cancerous cells and pictures of 100 true non-cancerous cells.

Before doing any fitting, we must first load the `fddm` package, read the data, and clean the data by removing any invalid responses from the data (i.e., have negative or non-numeric response times).

    library("fddm")
    data(med_dec, package = "fddm")
    med_dec <- med_dec[which(med_dec[["rt"]] >= 0), ]

As we will be demonstrating simple fitting procedures involving only one participant from the `fddm::med_dec` dataset, we subset the data to select the individual whose data will be used for these fitting procedures.

    onep <- med_dec[med_dec[["id"]] == "2" & med_dec[["group"]] == "experienced", ]
    str(onep)
    #> 'data.frame':    200 obs. of  9 variables:
    #>  $ id            : Factor w/ 37 levels "1","2","3","4",..: 2 2 2 2 2 2 2 2 2 2 ...
    #>  $ group         : Factor w/ 3 levels "experienced",..: 1 1 1 1 1 1 1 1 1 1 ...
    #>  $ block         : int  3 3 3 3 3 3 3 3 3 3 ...
    #>  $ trial         : int  1 2 3 4 5 6 7 8 9 10 ...
    #>  $ classification: Factor w/ 2 levels "blast","non-blast": 1 2 2 2 1 1 1 1 2 1 ...
    #>  $ difficulty    : Factor w/ 2 levels "easy","hard": 1 1 2 2 1 1 2 2 1 2 ...
    #>  $ response      : Factor w/ 2 levels "blast","non-blast": 1 2 1 2 1 1 1 1 2 1 ...
    #>  $ rt            : num  0.853 0.575 1.136 0.875 0.748 ...
    #>  $ stimulus      : Factor w/ 312 levels "blastEasy/AuerRod.jpg",..: 7 167 246 273 46 31 132 98 217 85 ...

We can see the structure of the data for this participant contains some identifying information (e.g., the ID number and experience level), the enumerated and paired responses and response times, and some information about the stimuli shown to the participant (e.g., the correct classification of the stimulus and the difficulty of correctly identifying the stimulus). We will leverage this extra information about the stimuli in our example fitting procedures.

# Fitting with `ddm()`

The `ddm()` function fits the 5-parameter DDM to the user-supplied data via maximum likelihood estimation (MLE). Using R’s formula interface, the user can specify which model parameters should be estimated and which should remain fixed; however, the drift rate is always estimated. For the model parameters that the user wishes to be estimated, R’s formula interface allows each parameter to be fit with a single coefficient (i.e., `~ 1`) or with multiple coefficients (e.g., `~ condition1*condition2`). Should the user desire a model parameter to be fixed, this can be done by writing the model parameter equal to a scalar (e.g., `ndt = 0.39`). See the documentation for the `ddm()` function for more details regarding the formula notation. Since this example is simple, we only use formula notation for the drift rate and leave the other parameters to their default settings.

## Simple Fitting Routine

First we will show a quick fitting using only one participant from the `fddm::med_dec` dataset. Because we use an ANOVA approach in the analysis of this example, we set orthogonal sum-to-zero contrasts. This means that the “Intercept” coefficient will correspond to the grand mean, and the other coefficients will correspond to the differences from the grand mean.

    opc <- options(contrasts = c("contr.sum", "contr.poly"))

Now we can use the `ddm()` function to fit the DDM to the data. The first argument of the `ddm()` function is the formula indicating how the drift rate should be modeled. As the dataset contains both the correct identification of the cell (“classification” column of the dataset, with each row containing the text either “blast” or “non-blast”) and the difficulty of the identification (“difficulty” column of the dataset, with each row containing the text either “easy” or “hard”), we will incorporate this information into how we will model the drift rate. In this case, we will model the drift rate using the grand mean (labeled “Intercept”) with the additional coefficients corresponding to the differences from the grand mean, according to their classification (“blast” or “non-blast”), difficulty (“easy” or “hard”), and the interaction between classification and difficulty. The remaining arguments of the `ddm()` function contain the formulas (or scalars) for how the other model parameters should be modeled; by default, the boundary separation and non-decision time are estimated by a single coefficient each, and the initial bias and inter-trial variability in the drift rate are held fixed at 0.5 and 0, respectively. Following the model parameters, the remaining arguments are various optimization settings that we will leave as their default values for this example. Note that since we are using the default formulas and scalars for the model paramaters except the drift rate we are not required to explicitly write these formulas and scalars, but we do so in this example for illustrative purposes. We do, however, always need to include the `data` argument.

    fit0 <- ddm(drift = rt + response ~ classification*difficulty,
                boundary = ~ 1,
                ndt = ~ 1,
                bias = 0.5,
                sv = 0,
                data = onep)
    summary(fit0)
    #>
    #> Call:
    #> ddm(drift = rt + response ~ classification * difficulty, boundary = ~1, ndt = ~1, bias = 0.5,
    #>     sv = 0, data = onep)
    #>
    #> DDM fit with 3 estimated and 2 fixed distributional parameters.
    #> Fixed: bias = 0.5, sv = 0
    #>
    #> drift coefficients (identity link):
    #>                             Estimate Std. Error z value Pr(>|z|)
    #> (Intercept)                   -0.592      0.117   -5.07  3.9e-07 ***
    #> classification1               -2.645      0.117  -22.65  < 2e-16 ***
    #> difficulty1                    0.289      0.117    2.47    0.013 *
    #> classification1:difficulty1   -1.499      0.117  -12.83  < 2e-16 ***
    #> ---
    #> Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    #>
    #> boundary coefficients (identity link):
    #>             Estimate Std. Error
    #> (Intercept)     2.06       0.06
    #>
    #> ndt coefficients (identity link):
    #>             Estimate Std. Error
    #> (Intercept)    0.394       0.01

This output first shows the input to the function call and which parameters are held fixed; this information is useful to verify that the formula inputs to the `ddm()` function call were interpreted as intended by the user. The next line confirms that our model held two parameters fixed (the inital bias and the inter-trial variability in the drift rate) and estimated the other three model parameters. For the model of the drift rate that we input, we can see the estimates and summary statistics for the grand mean (called “Intercept” here) and each difference coefficient (one for the “classification” condition, one for the “difficulty” condition, and one for the interaction between the “classification” and “difficulty” conditions). Below this, we can see the single-coefficient estimates for the boundary separation and non-decision time (default behavior).

For each estimated coefficient, we get the estimate itself and the standard error of the estimate. For the boundary and non-decision time, we can see that the standard errors are pretty small relative to the estimates, so the estimates should be pretty accurate. For the drift rate coefficients, we get additional statistics about the significance of the coefficients- in this case, the grand mean and the differences from the grand mean. From this data, we can see that the effects of “classification”, “difficulty”, and their interaction all meet the common significance requirement P = .05.

We can reset the contrasts after fitting.

    options(opc) # reset contrasts

### Rudimentary Analysis

For a quick analysis on the drift rate fits, we will do a two-way ANOVA because we are comparing the effect of two categorical variables (classification and density) on a quantitative continuous variable (drift rate). The two-way ANOVA will identify if the drift rate is significantly different among the various classifications and densities; this is a common practice for comparing the effects of categorical variables when two or more groups exist in the data. To be rigorous, we should check that: the data are independent both within groups and across groups; the data are approximately normally distributed, or there are enough observations per group so that we do not need to show normality; the variances across groups are equal; there are no significant outliers; and the data are evenly split among the groups. We will forgo formally verifying these checks for the sake of brevity. Note that the interaction between classification and difficulty is significant, so this term is included in the model.

We will use the `emmeans` package to do some simple post hoc comparisons across the groups that we modeled; this package has some useful functions to do ANOVA and related stuff. First, we’ll produce an ANOVA-like table that displays the degrees of freedom, F-value, and P-value for each main effect (categorical variable) and their interaction. If we want to show just the conditional main effects, then we can run the second line of code to produce two separate tables with the same summary statistics.

    emmeans::joint_tests(fit0)
    #>  model term                df1 df2 F.ratio p.value
    #>  classification              1 194 512.900  <.0001
    #>  difficulty                  1 194   6.100  0.0142
    #>  classification:difficulty   1 194 164.700  <.0001

    emmeans::joint_tests(fit0, by = "classification")
    #> classification = blast:
    #>  model term df1 df2 F.ratio p.value
    #>  difficulty   1 194  46.660  <.0001
    #>
    #> classification = non-blast:
    #>  model term df1 df2 F.ratio p.value
    #>  difficulty   1 194 137.870  <.0001

From these results, we can see that both of the categorical variables (classification and difficulty) and their interaction term have a significant effect on the drift rate, at the P = 0.05 level.

If we want to see the mean drift rate for each combination of classification and difficulty, the titular `emmeans` function call will display a table for each classification that contains the standard summary statistics for each difficulty. The following code shows the mean drift rate for each condition in addition to the standard errors, degrees of freedom, and the 95% confidence intervals.

    em1 <- emmeans::emmeans(fit0, "difficulty", by = "classification")
    em1
    #> classification = blast:
    #>  difficulty emmean    SE  df lower.CL upper.CL
    #>  easy       -4.447 0.294 194   -5.026   -3.868
    #>  hard       -2.027 0.198 194   -2.418   -1.636
    #>
    #> classification = non-blast:
    #>  difficulty emmean    SE  df lower.CL upper.CL
    #>  easy        3.840 0.273 194    3.302    4.378
    #>  hard        0.265 0.135 194   -0.002    0.531
    #>
    #> Confidence level used: 0.95

These means seem to be different; however, we need to formally compare them to be sure. To compare the means across the two difficulty groups (“easy” and “hard”), we can find the pairwise differences between the means (one difference for each classification). The first and second lines of code yield the same information, but the second line condenses the first line from two tables to one table. These tables include the differences between the means as well as the standard summary statistics: standard errors, degrees of freedom, T-statistic, and P-value.

    pairs(em1)
    #> classification = blast:
    #>  contrast    estimate    SE  df t.ratio p.value
    #>  easy - hard    -2.42 0.354 194  -6.831  <.0001
    #>
    #> classification = non-blast:
    #>  contrast    estimate    SE  df t.ratio p.value
    #>  easy - hard     3.58 0.304 194  11.742  <.0001

    update(pairs(em1), by = NULL, adjust = "holm")
    #>  contrast    classification estimate    SE  df t.ratio p.value
    #>  easy - hard blast             -2.42 0.354 194  -6.831  <.0001
    #>  easy - hard non-blast          3.58 0.304 194  11.742  <.0001
    #>
    #> P value adjustment: holm method for 2 tests

As we suspected, the differences between the means across the two difficulty groups (“easy” and “hard”) are indeed significantly different (at the P = 0.05 level).

# Fitting Manually with `dfddm()`

Although we strongly recommend using the `ddm()` function for fitting the DDM to data, we will also show an example of how to use the PDF to manually perform the optimization. Note that this method will be slower and less convenient than using the `ddm()` function, but it is possible if the user wants a particular likelihood function or optimization routine.

Our approach will be a straightforward maximum likelihood estimation (MLE). We are going to be fitting the parameters \(v\), \(a\), \(t_0\), \(w\), and \(sv\); however, we want to fit two distinct drift rates, one for the upper boundary (\(v_u\)) and one for the lower boundary (\(v_\ell\)). In order to make this distinction, we require the input of the truthful classification of each decision (i.e. what the correct response is for each entry).

Since we will be using the optimization function `stats::nlminb()`, we must write an objective function for it to optimize; this objective function will be the log-likelihood function that we discuss in the next section.

## Log-likelihood Function

By default `stats::nlminb()` finds the minimum of the objective function instead of the maximum, so we will simply negate our likelihood function. In addition, we will employ the common practice of using the log-likelihood as this tends to be more stable while still maintaining the same minima (negated maxima) as the regular likelihood function. Note that our log-likelihood function depends on the number of response times, the number of responses, and the number of truthful classifications all being equal.

As we are using the optimization function `stats::nlminb()`, the first argument to our log-likelihood function needs to be a vector of the initial values of the six parameters that are being optimized: \(v_u\), \(v_\ell\), \(a\), \(t_0\), \(w\), and \(sv\). The rest of the arguments will be the other necessary inputs to `dfddm()` that are not optimized: the vector of response times, the vector of responses, the vector of the truthful classifications, and the allowable error tolerance for the density function (optional). Details on all of these inputs can be found in the `dfddm()` documentation.

Upon being called, the log-likelihood function first separates the input response times and responses by their truthful classification to yield two new response time vectors and two new response vectors. The response times and responses are then input into separate density functions using a separate \(v\) parameter, \(v_u\) or \(v_\ell\). These separate densities are then combined, and the log-likelihood function heavily penalizes any combination of parameters that returns a log-density of \(-\infty\) (equivalent to a regular density of \(0\)). Lastly, the actual log-likelihood is returned as the negative of the sum of all of the log-densities.

    ll_fun <- function(pars, rt, resp, truth, err_tol) {
      v <- numeric(length(rt))

      # the truth is "upper" so use vu
      v[truth == "upper"] <- pars[[1]]
      # the truth is "lower" so use vl
      v[truth == "lower"] <- pars[[2]]

      dens <- dfddm(rt = rt, response = resp, a = pars[[3]], v = v, t0 = pars[[4]],
                    w = pars[[5]], sv = pars[[6]], err_tol = 1e-6, log = TRUE)

      return( ifelse(any(!is.finite(dens)), 1e6, -sum(dens)) )
    }

## Simple Fitting Routine

First we will fit the DDM to only one participant from the `fddm::med_dec` dataset. To the single participant’s data we add a column each for converting the responses and their respective classifications to either “upper” or “lower”.

    onep[["resp"]] <- ifelse(onep[["response"]] == "blast", "upper", "lower")
    onep[["truth"]] <- ifelse(onep[["classification"]] == "blast", "upper", "lower")
    str(onep)
    #> 'data.frame':    200 obs. of  11 variables:
    #>  $ id            : Factor w/ 37 levels "1","2","3","4",..: 2 2 2 2 2 2 2 2 2 2 ...
    #>  $ group         : Factor w/ 3 levels "experienced",..: 1 1 1 1 1 1 1 1 1 1 ...
    #>  $ block         : int  3 3 3 3 3 3 3 3 3 3 ...
    #>  $ trial         : int  1 2 3 4 5 6 7 8 9 10 ...
    #>  $ classification: Factor w/ 2 levels "blast","non-blast": 1 2 2 2 1 1 1 1 2 1 ...
    #>  $ difficulty    : Factor w/ 2 levels "easy","hard": 1 1 2 2 1 1 2 2 1 2 ...
    #>  $ response      : Factor w/ 2 levels "blast","non-blast": 1 2 1 2 1 1 1 1 2 1 ...
    #>  $ rt            : num  0.853 0.575 1.136 0.875 0.748 ...
    #>  $ stimulus      : Factor w/ 312 levels "blastEasy/AuerRod.jpg",..: 7 167 246 273 46 31 132 98 217 85 ...
    #>  $ resp          : chr  "upper" "lower" "upper" "lower" ...
    #>  $ truth         : chr  "upper" "lower" "lower" "lower" ...

We pass the data and log-likelihood function with the necessary additional arguments to an optimization function. As we are using the optimization function `stats::nlminb()` for this example, we must input as the first argument the initial values of our DDM parameters that we want optimized. These are input in the order: \(v_u\), \(v_\ell\), \(a\), \(t_0\), \(w\), and \(sv\); we also need to define upper and lower bounds for each parameters.

    fit <- nlminb(c(0, 0, 1, 0, 0.5, 0), objective = ll_fun,
                  rt = onep[["rt"]], resp = onep[["resp"]], truth = onep[["truth"]],
                  # limits:   vu,   vl,   a,  t0, w,  sv
                  lower = c(-Inf, -Inf, .01,   0, 0,   0),
                  upper = c( Inf,  Inf, Inf, Inf, 1, Inf))
    fit
    #> $par
    #> [1]  5.6813 -2.1887  2.7909  0.3764  0.4010  2.2813
    #>
    #> $objective
    #> [1] 42.47
    #>
    #> $convergence
    #> [1] 0
    #>
    #> $iterations
    #> [1] 131
    #>
    #> $evaluations
    #> function gradient
    #>      157      932
    #>
    #> $message
    #> [1] "relative convergence (4)"

## Fitting the Entire Dataset

Here we will run a more rigorous fitting on the entire `fddm::med_dec` dataset to obtain parameter estimates for each participant in the study. To do this, we define a function to run the data fitting for us; we want it to output a dataframe containing the parameter estimates for each individual in the data. The inputs will be the dataset, the allowable error tolerance for the density function, how the “upper” response is presented in the dataset, and indices of the columns in the dataset containing: identification of the individuals in the dataset, the response times, the responses, and the truthful classifications.

After some data checking, the fitting function will extract the unique individuals from the dataset and run the parameter optimization for the responses and response times for each individual. The optimizations themselves are initialized with random initial parameter values to aid in the avoidance of local minima in favor of global minima. Moreover, the optimization will run 5 times for each individual, with 5 different sets of random initial parameter values. The value of the minimized log-likelihood function will be compared across all 5 runs, and the smallest such value will indicate the best fit. The parameter estimates, convergence code, and minimized value of the log-likelihood function produced by this best fit will be saved for that individual.

    rt_fit <- function(data, id_idx = NULL, rt_idx = NULL, response_idx = NULL,
                       truth_idx = NULL, response_upper = NULL) {

      # Format data for fitting
      if (all(is.null(id_idx), is.null(rt_idx), is.null(response_idx),
          is.null(truth_idx), is.null(response_upper))) {
        df <- data # assume input data is already formatted
      } else {
        if(any(data[,rt_idx] < 0)) {
          stop("Input data contains negative response times; fit will not be run.")
        }
        if(any(is.na(data[,response_idx]))) {
          stop("Input data contains invalid responses (NA); fit will not be run.")
        }

        nr <- nrow(data)
        df <- data.frame(id = character(nr),
                         rt = double(nr),
                         response = character(nr),
                         truth = character(nr),
                         stringsAsFactors = FALSE)

        if (!is.null(id_idx)) { # relabel identification tags
          for (i in seq_along(id_idx)) {
            idi <- unique(data[,id_idx[i]])
            for (j in seq_along(idi)) {
              df[["id"]][data[,id_idx[i]] == idi[j]] <- paste(
                df[["id"]][data[,id_idx[i]] == idi[j]], idi[j], sep = " ")
            }
          }
          df[["id"]] <- trimws(df[["id"]], which = "left")
        }

        df[["rt"]] <- as.double(data[,rt_idx])

        df[["response"]] <- "lower"
        df[["response"]][data[,response_idx] == response_upper] <- "upper"

        df[["truth"]] <- "lower"
        df[["truth"]][data[,truth_idx] == response_upper] <- "upper"
      }

      # Preliminaries
      ids <- unique(df[["id"]])
      nids <- max(length(ids), 1) # if inds is null, there is only one individual
      ninit_vals <- 5

      # Initilize the output dataframe
      cnames <- c("ID", "Convergence", "Objective",
                  "vu_fit", "vl_fit", "a_fit", "t0_fit", "w_fit", "sv_fit")
      out <- data.frame(matrix(ncol = length(cnames), nrow = nids))
      colnames(out) <- cnames
      temp <- data.frame(matrix(ncol = length(cnames)-1, nrow = ninit_vals))
      colnames(temp) <- cnames[-1]

      # Loop through each individual and starting values
      for (i in 1:nids) {
        out[["ID"]][i] <- ids[i]

        # extract data for id i
        dfi <- df[df[["id"]] == ids[i],]
        rti <- dfi[["rt"]]
        respi <- dfi[["response"]]
        truthi <- dfi[["truh"]]

        # starting value for t0 must be smaller than the smallest rt
        min_rti <- min(rti)

        # create initial values for this individual
        init_vals <- data.frame(vu = rnorm(n = ninit_vals, mean = 4, sd = 2),
                                vl = rnorm(n = ninit_vals, mean = -4, sd = 2),
                                a  = runif(n = ninit_vals, min = 0.5, max = 5),
                                t0 = runif(n = ninit_vals, min = 0, max = min_rti),
                                w  = runif(n = ninit_vals, min = 0, max = 1),
                                sv = runif(n = ninit_vals, min = 0, max = 5))

        # loop through all of the starting values
        for (j in 1:ninit_vals) {
          mres <- nlminb(init_vals[j,], ll_fun,
                         rt = rti, resp = respi, truth = truthi,
                         # limits:   vu,   vl,   a,  t0, w,  sv
                         lower = c(-Inf, -Inf, .01,   0, 0,   0),
                         upper = c( Inf,  Inf, Inf, Inf, 1, Inf))
          temp[["Convergence"]][j] <- mres[["convergence"]]
          temp[["Objective"]][j] <- mres[["objective"]]
          temp[j, -c(1, 2)] <- mres[["par"]]
        }

        # determine best fit for the individual
        min_idx <- which.min(temp[["Objective"]])
        out[i, -1] <- temp[min_idx,]
      }
      return(out)
    }

We run the fitting, and the dataframe of the fitting results is output below.

    fit <- rt_fit(med_dec, id_idx = c(2,1), rt_idx = 8, response_idx = 7,
                  truth_idx = 5, response_upper = "blast")
    fit
    #>                  ID Convergence Objective  vu_fit vl_fit  a_fit t0_fit  w_fit    sv_fit
    #> 1     experienced 2           0   154.157  2.8197 -1.789 2.6092 0.4151 0.4993 5.805e+00
    #> 2     experienced 6           0   119.675  2.2293 -3.222 2.3638 0.3739 0.5930 5.380e+00
    #> 3     experienced 7           0    74.397  4.4904 -3.516 1.3876 0.4535 0.4499 1.945e+00
    #> 4     experienced 9           0   162.764  0.6516 -3.852 2.5723 0.4724 0.4730 5.316e+00
    #> 5    experienced 12           0   122.762  4.7043 -7.756 2.1233 0.3871 0.5431 4.559e+00
    #> 6    experienced 14           0   107.097  3.6965 -3.611 1.5003 0.4060 0.5481 1.785e+00
    #> 7    experienced 16           0   316.742  2.9963 -1.849 2.0504 0.5071 0.4397 2.766e-01
    #> 8    experienced 17           0   238.977 -0.2403 -1.071 2.2852 0.4859 0.4117 2.462e+00
    #> 9   inexperienced 3           0    90.848  3.7673 -7.795 1.2960 0.4461 0.6715 3.366e-09
    #> 10  inexperienced 4           0   186.478  4.1851 -4.733 1.5964 0.4145 0.4630 7.141e-01
    #> 11  inexperienced 5           0   182.976  4.4138 -5.838 2.8352 0.4174 0.3807 5.718e+00
    #> 12  inexperienced 8           0   219.081  7.8418 -5.258 2.0509 0.1464 0.6034 7.728e-01
    #> 13 inexperienced 10           0    70.452  5.2446 -2.507 1.4830 0.4132 0.4507 3.113e+00
    #> 14 inexperienced 11           0   268.962  2.7451 -6.407 2.4425 0.1317 0.5135 1.300e+00
    #> 15 inexperienced 13           0   129.581  4.1853 -1.410 2.0976 0.3946 0.6284 4.207e+00
    #> 16 inexperienced 15           0    83.415  5.1404 -4.400 1.2326 0.3726 0.5849 1.310e-06
    #> 17 inexperienced 18           0   119.633  5.7843 -4.078 1.4366 0.5222 0.4980 1.559e+00
    #> 18 inexperienced 19           0   233.401  5.1779 -5.116 2.6755 0.3876 0.4712 3.926e+00
    #> 19         novice 1           0   169.743  3.0226 -4.149 1.6938 0.3987 0.4472 1.132e+00
    #> 20         novice 2           0   234.286  3.7082 -3.963 1.7176 0.5541 0.3470 1.930e-07
    #> 21         novice 3           0   157.031  3.4400 -5.270 1.3439 0.4973 0.5263 1.046e-07
    #> 22         novice 4           0    89.457  1.6851 -2.987 1.3713 0.3775 0.4943 1.274e+00
    #> 23         novice 5           0   173.613  5.7977 -4.220 1.4204 0.5130 0.4725 2.484e-07
    #> 24         novice 6           0   142.353  1.1484 -7.070 1.5024 0.4409 0.5888 8.112e-01
    #> 25         novice 7           0   372.724  3.4230 -3.075 2.4687 0.4413 0.3790 1.454e-09
    #> 26         novice 8           0    77.527  4.7222 -4.558 1.4522 0.1090 0.6044 8.038e-01
    #> 27         novice 9           0    62.579  3.9037 -5.967 1.2418 0.3777 0.4889 1.193e+00
    #> 28        novice 10           0   100.287  2.3905 -2.887 1.2963 0.4663 0.4521 1.270e+00
    #> 29        novice 11           0    77.262  6.0510 -3.817 1.4512 0.3841 0.6106 2.072e+00
    #> 30        novice 12           0    85.624  2.9257 -6.923 1.4676 0.3523 0.3428 1.690e-08
    #> 31        novice 13           0    84.946  5.5457 -3.333 1.4569 0.3979 0.6826 1.265e+00
    #> 32        novice 14           0    72.945  2.6446 -3.811 1.6538 0.3755 0.4775 4.044e+00
    #> 33        novice 15           0   149.422 -0.4502 -2.575 1.9703 0.4065 0.4891 3.531e+00
    #> 34        novice 16           0   150.412  3.1162 -6.877 1.7086 0.3357 0.6148 1.435e+00
    #> 35        novice 17           0   264.390  1.9109 -6.410 2.3208 0.1914 0.4617 1.132e+00
    #> 36        novice 18           0   104.866  4.0025 -4.419 1.3891 0.4650 0.4954 1.399e+00
    #> 37        novice 19           0   209.592  2.3514 -2.459 2.1568 0.4349 0.5002 2.472e+00
    #> 38        novice 20           0   234.731  4.2355 -2.872 2.0437 0.0000 0.5734 6.434e-01
    #> 39        novice 21           0     8.786  1.7282 -3.505 1.0759 0.4179 0.5128 1.384e+00
    #> 40        novice 22           0    57.884  1.1921 -8.413 1.3349 0.3313 0.5455 2.219e+00
    #> 41        novice 23           0   112.185  7.2287 -6.775 1.3942 0.4165 0.5527 1.358e+00
    #> 42        novice 24           0    98.604  5.6601 -5.381 1.6113 0.3361 0.6214 1.385e+00
    #> 43        novice 25           0   101.399  2.0585 -1.042 1.5317 0.4189 0.4984 2.184e+00
    #> 44        novice 26           0   187.189  2.1009 -5.083 1.6987 0.4637 0.3486 6.712e-01
    #> 45        novice 27           0    64.849 -1.0787 -3.232 1.2238 0.5150 0.4185 1.101e+00
    #> 46        novice 28           0   143.266  2.7803 -4.497 1.6261 0.1316 0.4763 9.851e-01
    #> 47        novice 29           0    -8.025  3.2007 -4.635 0.9979 0.3695 0.5096 1.222e+00
    #> 48        novice 30           0   131.602  2.8358 -6.339 1.5847 0.3331 0.5513 1.135e+00
    #> 49        novice 31           0   232.037  0.6035 -5.002 1.8749 0.4700 0.4490 1.079e+00
    #> 50        novice 32           0   101.678  6.9262 -4.443 1.3497 0.5102 0.4355 1.523e+00
    #> 51        novice 33           0   111.875  4.3309 -5.634 1.2291 0.3395 0.5337 1.006e-07
    #> 52        novice 34           0    99.261  4.6055 -3.604 1.2717 0.4964 0.5752 5.818e-01
    #> 53        novice 35           0   176.715  2.0342 -5.026 2.1075 0.5099 0.4705 3.545e+00
    #> 54        novice 36           0    92.863  0.5312 -3.345 1.3239 0.5260 0.4143 1.049e+00
    #> 55        novice 37           0   101.640  7.3614 -4.053 1.4562 0.3345 0.6031 9.149e-01

### Rudimentary Analysis

To show some basic results of our fitting, we will plot the fitted values of \(v_u\) and \(v_\ell\) grouped by the experience level of the participant to demonstrate how these parameters differ among novices, inexperienced professionals, and experienced professionals.

    library("reshape2")
    library("ggplot2")

    fitp <- data.frame(fit[, c(1, 4, 5)]) # make a copy to manipulate for plotting
    colnames(fitp)[-1] <- c("vu", "vl")

    for (i in seq_along(unique(fitp[["ID"]]))) {
      first <- substr(fitp[["ID"]][i], 1, 1)
      if (first == "n") {
        fitp[["ID"]][i] <- "novice"
      } else if (first == "i") {
        fitp[["ID"]][i] <- "inexperienced"
      } else {
        fitp[["ID"]][i] <- "experienced"
      }
    }

    fitp <- melt(fitp, id.vars = "ID", measure.vars = c("vu", "vl"),
                 variable.name = "vuvl", value.name = "estimate")

    ggplot(fitp, aes(x = factor(ID, levels = c("novice", "inexperienced", "experienced")),
                     y = estimate,
                     color = factor(vuvl, levels = c("vu", "vl")))) +
      geom_point(alpha = 0.4, size = 4) +
      labs(title = "Parameter Estimates for vu and vl",
           x = "Experience Level", y = "Parameter Estimate",
           color = "Drift Rate") +
      theme_bw() +
      theme(panel.border = element_blank(),
            plot.title = element_text(size = 23),
            plot.subtitle = element_text(size = 16),
            axis.text.x = element_text(size = 16),
            axis.text.y = element_text(size = 16),
            axis.title.x = element_text(size = 20,
                                        margin = margin(10, 5, 5, 5, "pt")),
            axis.title.y = element_text(size = 20),
            legend.title = element_text(size = 20),
            legend.text = element_text(size = 16))

Before we begin analysis of this plot, note that the drift rate corresponding to the upper threshold should always be positive, and the drift rate corresponding to the lower threshold should always be negative. Since there are a few fitted values that switch this convention, the novice participants show evidence of consistently responding incorrectly to the stimulus. In contrast, both the inexperienced and experienced participants show a clean division of drift rates around zero.

In addition, we notice that the more experienced participants tend to have higher fitted drift rates in absolute value. A more extreme drift rate means that the participant receives and processes information more efficiently than a more mild drift rate. The overall pattern is that the novices are on average the worst at receiving information, the experienced professionals are the best, and the inexperienced professionals are somewhere in the middle. This pattern indicates that experienced professionals are indeed better at their job than untrained undergraduate students!

#

#### R Session Info

    sessionInfo()
    #> R version 4.4.1 (2024-06-14)
    #> Platform: x86_64-pc-linux-gnu
    #> Running under: Linux Mint 21.3
    #>
    #> Matrix products: default
    #> BLAS:   /usr/lib/x86_64-linux-gnu/blas/libblas.so.3.10.0
    #> LAPACK: /usr/lib/x86_64-linux-gnu/lapack/liblapack.so.3.10.0
    #>
    #> locale:
    #>  [1] LC_CTYPE=en_US.UTF-8       LC_NUMERIC=C               LC_TIME=en_US.UTF-8
    #>  [4] LC_COLLATE=C               LC_MONETARY=en_US.UTF-8    LC_MESSAGES=en_US.UTF-8
    #>  [7] LC_PAPER=en_US.UTF-8       LC_NAME=C                  LC_ADDRESS=C
    #> [10] LC_TELEPHONE=C             LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C
    #>
    #> time zone: Europe/London
    #> tzcode source: system (glibc)
    #>
    #> attached base packages:
    #> [1] stats     graphics  grDevices utils     datasets  methods   base
    #>
    #> other attached packages:
    #> [1] ggforce_0.4.2         ggplot2_3.5.1         reshape2_1.4.4        microbenchmark_1.4.10
    #> [5] RWiener_1.3-3         rtdists_0.11-5        fddm_1.0-2
    #>
    #> loaded via a namespace (and not attached):
    #>  [1] sass_0.4.9         utf8_1.2.4         generics_0.1.3     stringi_1.8.4      lattice_0.22-6
    #>  [6] digest_0.6.35      magrittr_2.0.3     estimability_1.5.1 evaluate_0.24.0    grid_4.4.1
    #> [11] mvtnorm_1.2-5      fastmap_1.2.0      plyr_1.8.9         jsonlite_1.8.8     Matrix_1.7-0
    #> [16] ggnewscale_0.4.10  Formula_1.2-5      survival_3.7-0     fansi_1.0.6        scales_1.3.0
    #> [21] tweenr_2.0.3       codetools_0.2-20   jquerylib_0.1.4    cli_3.6.2          rlang_1.1.4
    #> [26] expm_0.999-9       polyclip_1.10-6    gsl_2.1-8          munsell_0.5.1      splines_4.4.1
    #> [31] withr_3.0.0        cachem_1.1.0       yaml_2.3.8         tools_4.4.1        dplyr_1.1.4
    #> [36] colorspace_2.1-0   vctrs_0.6.5        R6_2.5.1           emmeans_1.10.2     lifecycle_1.0.4
    #> [41] stringr_1.5.1      MASS_7.3-61        pkgconfig_2.0.3    pillar_1.9.0       bslib_0.7.0
    #> [46] gtable_0.3.5       glue_1.7.0         Rcpp_1.0.12        highr_0.11         xfun_0.45
    #> [51] tibble_3.2.1       tidyselect_1.2.1   knitr_1.47         msm_1.7.1          xtable_1.8-4
    #> [56] farver_2.1.2       htmltools_0.5.8.1  labeling_0.4.3     rmarkdown_2.27     compiler_4.4.1
    #> [61] evd_2.3-7

# References

Trueblood, Jennifer S., William R. Holmes, Adam C. Seegmiller, Jonathan Douds, Margaret Compton, Eszter Szentirmai, Megan Woodruff, Wenrui Huang, Charles Stratton, and Quentin Eichbaum. 2018. “The Impact of Speed and Bias on the Cognitive Processes of Experts and Novices in Medical Image Decision-Making.” Cognitive Research: Principles and Implications 3 (1): 28. https://doi.org/10.1186/s41235-018-0119-2.