First thing first: Import and explore data
Labels containing specification .iat in variable
blockcode identify IAT blocks.
data("raw_data")
# explore the dataframe
str(raw_data)
#> 'data.frame': 84726 obs. of 6 variables:
#> $ Participant: int 4 4 4 4 4 4 4 4 4 4 ...
#> $ latency : int 2592 628 808 783 2059 1114 608 663 771 676 ...
#> $ correct : int 1 1 1 1 1 1 1 1 1 1 ...
#> $ trialcode : Factor w/ 32 levels "age","alert",..: 31 5 3 20 3 20 5 3 20 3 ...
#> $ blockcode : Factor w/ 13 levels "demo","practice.iat.Milkbad",..: 4 4 4 4 4 4 4 4 4 4 ...
#> $ response : Factor w/ 46 levels "","0","1","19",..: 43 43 43 43 43 43 43 43 43 43 ...
# explore the levels of the blockcode variable to identify the IAT blocks
levels(raw_data$blockcode)
#> [1] "demo" "practice.iat.Milkbad"
#> [3] "practice.iat.Milkgood" "practice.sc_dark.Darkbad"
#> [5] "practice.sc_dark.Darkgood" "practice.sc_milk.Milkbad"
#> [7] "practice.sc_milk.Milkgood" "test.iat.Milkbad"
#> [9] "test.iat.Milkgood" "test.sc_dark.Darkbad"
#> [11] "test.sc_dark.Darkgood" "test.sc_milk.Milkbad"
#> [13] "test.sc_milk.Milkgood"
Once the IAT blocks have been identified, it is possible to clean the
IAT data by using the clean_iat() function. Since the data
set also includes respondents’ demographic information
(demo in the blockcode variable), it is
possible to extract and store these information in a separate data
frame:
iat_cleandata <- clean_iat(raw_data, sbj_id = "Participant",
block_id = "blockcode",
mapA_practice = "practice.iat.Milkbad",
mapA_test = "test.iat.Milkbad",
mapB_practice = "practice.iat.Milkgood",
mapB_test = "test.iat.Milkgood",
latency_id = "latency",
accuracy_id = "correct",
trial_id = "trialcode",
trial_eliminate = c("reminder", "reminder1"),
demo_id = "blockcode",
trial_demo = "demo")
Since also the demographic data has been specified,
clean_iat() results in a list of 3 elements:
str(iat_cleandata)
#> List of 3
#> $ data_keep :Classes 'iat_clean' and 'data.frame': 19440 obs. of 8 variables:
#> ..$ participant : int [1:19440] 4 4 4 4 4 4 4 4 4 4 ...
#> ..$ latency : int [1:19440] 1282 1299 1435 1089 967 648 967 615 729 642 ...
#> ..$ correct : int [1:19440] 1 1 1 1 1 1 1 1 1 1 ...
#> ..$ block_original: chr [1:19440] "practice.iat.Milkbad" "practice.iat.Milkbad" "practice.iat.Milkbad" "practice.iat.Milkbad" ...
#> ..$ condition : chr [1:19440] "MappingA" "MappingA" "MappingA" "MappingA" ...
#> ..$ block_pool : chr [1:19440] "practice" "practice" "practice" "practice" ...
#> ..$ block : chr [1:19440] "practice_MappingA" "practice_MappingA" "practice_MappingA" "practice_MappingA" ...
#> ..$ trial_id : Factor w/ 32 levels "age","alert",..: 20 6 20 6 20 6 20 6 20 23 ...
#> $ data_eliminate:'data.frame': 64638 obs. of 6 variables:
#> ..$ Participant: int [1:64638] 4 4 4 4 4 4 4 4 4 4 ...
#> ..$ latency : int [1:64638] 2592 628 808 783 2059 1114 608 663 771 676 ...
#> ..$ correct : int [1:64638] 1 1 1 1 1 1 1 1 1 1 ...
#> ..$ trialcode : Factor w/ 32 levels "age","alert",..: 31 5 3 20 3 20 5 3 20 3 ...
#> ..$ blockcode : Factor w/ 13 levels "demo","practice.iat.Milkbad",..: 4 4 4 4 4 4 4 4 4 4 ...
#> ..$ response : Factor w/ 46 levels "","0","1","19",..: 43 43 43 43 43 43 43 43 43 43 ...
#> $ demo :'data.frame': 3726 obs. of 6 variables:
#> ..$ participant: int [1:3726] 4 4 4 4 4 4 4 4 4 4 ...
#> ..$ latency : int [1:3726] 53047 53047 53047 53047 21554 21554 11266 11266 11266 11266 ...
#> ..$ correct : int [1:3726] 1 1 1 1 1 1 1 1 1 1 ...
#> ..$ trialcode : Factor w/ 32 levels "age","alert",..: 19 1 21 8 22 4 10 11 12 13 ...
#> ..$ blockcode : Factor w/ 13 levels "demo","practice.iat.Milkbad",..: 1 1 1 1 1 1 1 1 1 1 ...
#> ..$ response : Factor w/ 46 levels "","0","1","19",..: 33 15 41 34 16 20 1 1 1 1 ...
data_keep is a data.frame with class
iat_clean. It contains the data set for the
compute_iat() function.
data_eliminate is a data.frame that
contains all the discarded blocks and trials.
demo is a data.frame that contains all the
trials identified as demo in the blockcode
variable.
Store the first data_keep element in a data frame for
the compute_iat() function.
iat_data <- iat_cleandata[[1]]
head(iat_data)
#> participant latency correct block_original condition block_pool
#> 60914 4 1282 1 practice.iat.Milkbad MappingA practice
#> 60915 4 1299 1 practice.iat.Milkbad MappingA practice
#> 60916 4 1435 1 practice.iat.Milkbad MappingA practice
#> 60917 4 1089 1 practice.iat.Milkbad MappingA practice
#> 60918 4 967 1 practice.iat.Milkbad MappingA practice
#> 60919 4 648 1 practice.iat.Milkbad MappingA practice
#> block trial_id
#> 60914 practice_MappingA goodright
#> 60915 practice_MappingA darkright
#> 60916 practice_MappingA goodright
#> 60917 practice_MappingA darkright
#> 60918 practice_MappingA goodright
#> 60919 practice_MappingA darkright
Compute IAT D score
Once that IAT data have been cleaned with the
clean_iat() function, it is possible to compute the
D score by using the compute_iat() function.
This function only takes two arguments. The first argument is the
data frame with class iat_clean, the second argument is a
character specifying the D score algorithm for the computation.
To compute multiple D score algorithms at the same time, use
themulti_dscore() function.
dscore <- compute_iat(iat_data, Dscore = "d3")
str(dscore)
#> Classes 'dscore' and 'data.frame': 162 obs. of 23 variables:
#> $ participant : int 4 6 8 11 14 17 18 19 20 21 ...
#> $ n_trial : int 120 120 120 120 120 120 120 120 120 120 ...
#> $ nslow10000 : num 0 0 0 0 0 0 0 0 0 0 ...
#> $ nfast400 : num 0 0 0 0.01 0.07 0.04 0 0.05 0 0 ...
#> $ nfast300 : num 0 0 0 0 0 0 0 0 0 0 ...
#> $ accuracy.practice_MappingA: num 1 0.95 0.7 0.9 0.95 0.9 0.95 0.95 0.85 0.9 ...
#> $ accuracy.practice_MappingB: num 1 1 0.85 0.95 1 1 1 0.85 1 0.85 ...
#> $ accuracy.test_MappingA : num 1 0.9 1 0.95 0.9 0.925 0.95 0.95 0.8 0.9 ...
#> $ accuracy.test_MappingB : num 1 1 0.85 0.95 1 0.95 1 0.975 0.975 0.9 ...
#> $ accuracy.MappingA : num 1 0.917 0.9 0.933 0.917 ...
#> $ accuracy.MappingB : num 1 1 0.85 0.95 1 ...
#> $ RT_mean.MappingA : num 1037 1179 954 1297 852 ...
#> $ RT_mean.MappingB : num 788 596 926 731 604 ...
#> $ mean_practice_MappingA : num 1070 1224 1504 1608 821 ...
#> $ mean_test_MappingA : num 1021 1157 679 1141 867 ...
#> $ mean_practice_MappingB : num 889 611 1108 702 637 ...
#> $ mean_test_MappingB : num 737 589 836 745 587 ...
#> $ d_practice_d3 : num -0.647 -1.274 -0.584 -1.114 -0.514 ...
#> $ d_test_d3 : num -0.878 -1.226 0.508 -0.816 -0.672 ...
#> $ dscore_d3 : num -0.762 -1.25 -0.038 -0.965 -0.593 ...
#> $ cond_ord : chr "MappingA_First" "MappingB_First" "MappingB_First" "MappingA_First" ...
#> $ legendMappingA : chr "practice.iat.Milkbad_and_test.iat.Milkbad" "practice.iat.Milkbad_and_test.iat.Milkbad" "practice.iat.Milkbad_and_test.iat.Milkbad" "practice.iat.Milkbad_and_test.iat.Milkbad" ...
#> $ legendMappingB : chr "practice.iat.Milkgood_and_test.iat.Milkgood" "practice.iat.Milkgood_and_test.iat.Milkgood" "practice.iat.Milkgood_and_test.iat.Milkgood" "practice.iat.Milkgood_and_test.iat.Milkgood" ...
The compute_iat() function results in a
data.frame with class dscore containing a
number of rows equal to the number of participants. The columns contain
the D score and otehr useful information on the performance of
each respondent (see the documentation of the compute_iat()
function for further details). The IAT_rel(),
descript_d(), d_point(), and
d_density() functions require the object resulting from
function compute_iat().
The IAT D is computed as such that positive scores indicate slower
response times in condition identified by Mapping B.
IAT descriptive statistics and reliability
The descriptive statistics of the D scores computed on the
practice and test blocks, and the actual D scores can be easily
obtained with the descript_d() function:
descript_d(dscore) # Data frame containing IAT Ds
#> Mean SD Min Max
#> D-score -0.56 0.54 -1.59 1.29
#> D-practice -0.59 0.64 -1.59 1.26
#> D-test -0.54 0.56 -1.59 1.32
By specifying latex = TRUE, function
descript_d() print the results in LaTeX code:
descript_d(dscore, # Data frame containing IAT Ds
latex = TRUE) # obtain the code for latex tables
#> % latex table generated in R 4.5.1 by xtable 1.8-4 package
#> % Fri Aug 22 18:02:14 2025
#> \begin{table}[ht]
#> \centering
#> \begin{tabular}{rrrrr}
#> \hline
#> & Mean & SD & Min & Max \\
#> \hline
#> D-score & -0.56 & 0.54 & -1.59 & 1.29 \\
#> D-practice & -0.59 & 0.64 & -1.59 & 1.26 \\
#> D-test & -0.54 & 0.56 & -1.59 & 1.32 \\
#> \hline
#> \end{tabular}
#> \end{table}
The IAT_rel() function computes the reliability of the
IAT by correlating the D score obtained from practice blocks
with the D score obtained from test blocks (see Gawronski et al. 2017 for further
details):
IAT_rel(dscore)
#> $`Test-pratice Reliability`
#> [1] 0.65
#>
#> $`Number of participants`
#> [1] 162
#>
#> attr(,"class")
#> [1] "IAT_rel"
Plotting the results
The implicitMeasures package comes with several
functions for obtaining clear representations of the results at both
individual respondent and sample levels. Additionally, it includes a
function for computing and plotting multiple IAT D score
algorithms at the same time.
Individual respondent plot
The d_point() function plots the IAT D score
for each respondent.
d_point(dscore) # Data frame containing IAT D scores
In case of large sample size, the label identifying each respondent
is difficult to read. It can be eliminated by setting
x_values = FALSE.
Respondents can be arranged by increasing or decreasing D
scores by setting argument order_sbj equal to
"D-increasing" or "D-decreasing",
respectively. Descriptive statistics (\(M_{\text{D}}\pm 2sd\)) can be added by
setting include_stats = TRUE. Finally, the color of the
points can be changed by using argument col_point.
d_point(dscore, # dataframe containing IAT Ds
order_sbj = "D-decreasing", # change respondents order
x_values = FALSE, # remove respondents' labels
include_stats = TRUE, # include descriptive statistics
col_point = "lightskyblue") # change points color
Sample level plot
The d_density() function plots the distribution of the
IAT D scores. It allows for choosing the most appropriate
representation.
d_density(dscore) # dataframe containing IAT Dscores
The number of bins can be changed with argument n_bin.
Argument graph can be used for changing the graphical
representation of the data. It is possible to choose an histogram
representation (graph = "histogram", default), a
representation of the density distribution
(graph = "density"), or a boxplot
(graph = "boxplot"). Argument col_fill can be
used to change the color of the points representing each respondent’s
score in the violin plot. Descriptive statistics (i.e., \(M_{\text{D}} \pm 2sd\)) can be added to
the graph by setting argument include_stats = TRUE.
d_density(dscore, # dataframe containing IAT Dscores
graph = "boxplot", # change graphical representation
include_stats = TRUE) # include descriptive statistics
Multiple D scores
The multi_dscore() function computes and plot multiple
D score algorithms. The D score algorithms that can be
computed depend on the IAT administration. If the IAT administration
included a feedback strategy (i.e., built-in correction), only
D1 and D2 algorithms should be computed. If the IAT
administration did not include a feedback strategy, then algorithms
D3, D4, D5, and D6 should be
computed. An exhaustive and detailed illustration of the D
score algorithms is provided in the “Implicit Measures” vignette. To
specify the algorithms that can be computed, argument ds
must be set equal to either "built-in" (for the computation
of D1 and D2) or error-inflation (for the
computation of all other algorithms).
multi_scores <- multi_dscore(iat_data, # object with class "iat_clean"
ds = "error-inflation") # string specifying the
# algorithms to compute
The multi_dscore() function results in a
list containing two objects. The first object is a
data.frame that contains all the computed algorithms and
the respondent IDs.
multi_d <- multi_scores[[1]]
head(multi_d)
#> participant dscore_d3 dscore_d4 dscore_d5 dscore_d6
#> 1 4 -0.76242699 -0.76242699 -0.76242699 -0.76242699
#> 2 6 -1.24976744 -1.26905702 -1.24976744 -1.26905702
#> 3 8 -0.03801459 0.02021915 -0.03801459 0.02021915
#> 4 11 -0.96488057 -0.97207623 -0.95538961 -0.96294963
#> 5 14 -0.59341709 -0.57385144 -0.59236921 -0.57213017
#> 6 17 -1.30474798 -1.27140694 -1.27997040 -1.26676628
str(multi_d)
#> 'data.frame': 162 obs. of 5 variables:
#> $ participant: int 4 6 8 11 14 17 18 19 20 21 ...
#> $ dscore_d3 : num -0.762 -1.25 -0.038 -0.965 -0.593 ...
#> $ dscore_d4 : num -0.7624 -1.2691 0.0202 -0.9721 -0.5739 ...
#> $ dscore_d5 : num -0.762 -1.25 -0.038 -0.955 -0.592 ...
#> $ dscore_d6 : num -0.7624 -1.2691 0.0202 -0.9629 -0.5721 ...
The second object is a ggplot graph displaying the
distribution of the D scores computed with each algorithm in
violin plots.
