Return to the Deese–Roediger–McDermott (DRM) False Memory Procedure (Visual) page
						
							FALSE MEMORIES: DEESE-ROEDIGER-McDERMOTT (DRM) procedure
							(visual presentation of study words)
SCRIPT INFO

Script Author: Katja Borchert, Ph.D. (katjab@millisecond.com) for Millisecond Software, LLC
Date: 09-27-2016
last updated: 11-30-2016 by K.Borchert (katjab@millisecond.com) for Millisecond Software LLC

Script Copyright © 11-30-2016 Millisecond Software


BACKGROUND INFO 

											*Purpose*
This script implements the Deese–Roediger–McDermott (DRM) procedure to study false memories based on:

Deese, J. (1959). On the prediction of occurrence of particular verbal intrusions in immediate
recall. Journal of Experimental Psychology, 58, 17–22.

Roediger, H. L., III, & McDermott, K. B. (1995). Creating false memories: Remembering words not
presented in list. Journal of Experimental Psychology: Learning, Memory, and Cognition,
21, 803–814. (Experiment 2)

Note: this script presents the study words visually.


											  *Task*
Participants study 16 lists of 15 related words. The words are presented visually with a Stimulus Onset Asynchrony (SOA)
of 1500ms. One item that is highly related to all the words of one list ('lure') is
not included in the study lists. In an immediate recall test after 8 randomly selected lists, participants have to list as many
of the study words as they recall. Number of correctly recalled items as well number of times (and position on recall list)
of the 'lure' item is assessed by computer. Participants work on simple addition and multiplication problems after the
remaining 8 lists (=control task).
Once all 16 lists have been studied, participants are given a recognition test (old/new) of 96 randomly presented items
and remember-know judgments if the item has been identified as "old".
The recognition test contains all 'lure' items of the study lists (16) as well as 3 study items of each of the 16 study lists (48).
The remaining items are new items.

  
DATA FILE INFORMATION: 
The default data stored in the data files are:

(1) Raw data file: 'FalseMemories_visual_raw*.iqdat' (a separate file for each participant)*

build:							Inquisit build
computer.platform:				the platform the script was run on
date, time, subject, group:		date and time script was run with the current subject/groupnumber 
blockcode, blocknum:			the name and number of the current block
trialcode, trialnum: 			the name and number of the currently recorded trial
									(Note: not all trials that are run might record data; by default data is collected unless /recorddata = false is set for a particular trial/block) 
/phase:							"study", "recall", "math"
/listCount:						stores the number of lists run
/recallListCount:				counts number of recall lists run
/mathListCount:					counts number of math lists run
/nextList:						stores the list index (1-15 of the currently presented study list)
/lure:							stores the lure of the currently presented study list 
/wordCategory:					Recognition Phase: "new", "new-lure", "recall" (for study words used with recall task), "recall-lure", "math" (for study words used with math task), "math-lure"						
stimulusitem:					the presented stimuli in order of trial presentation
response:						the participant's response
correct:						the correctness of the response (1 = correct; 0 = incorrect) - if applicable
latency: 						the response latency (in ms)
/Recall:						stores the recall text input (with single commas to separate the different words)
/countCorrect_Recall:			tracks the number of correctly recalled words per list
/RecallWordEstimate:			stores the computer-derived estimate of the number of words recalled
									Note: see below of algoritm implemented. Algorithm does not check whether the recalled words are actual words.

/positionLure_Recall:			if lure is present in recall: stores the position of the lure in the recall list
/nr_otherRecalledWords			stores the number of other recalled words that are neither study words nor lures
/intrusionOther:				stores the character strings contained in the recall string that are neither the study words nor the lure
									Note: misspelled study words will show up here

(2) Summary data file: 'FalseMemories_visual_summary*.iqdat' (a separate file for each participant)*

script.startdate:				date script was run
script.starttime:				time script was started
script.subjectid:				subject id number
script.groupid:					group id number
script.elapsedtime:				time it took to run script (in ms)
computer.platform:				the platform the script was run on
/completed:						0 = script was not completed (prematurely aborted); 1 = script was completed (all conditions run)

Recall:
/mean_WordRecall:				mean of the estimated number of words recalled
									Note: the word count estimation is done by computer using the algorithm described below.
									There may be instances when the algorithm does not return the correct count.
									Furthermore, the algorithm does NOT check if the input consists of actual words.
/SD_WordRecall:					standard deviation of the estimated number of words recalled

/prop_word1Recall-
/prop_word12Recall:				stores the proportion of correctly recalled words in study positions 1 - 12 (Max: 6/6 for each item)
/prop_lureRecall:				stores proportion of recalling the lure (=a specific highly related item that was NOT a study item) based on the number of recall trials (Max: 6/6)
									Note: spelling errors of correctly recalled items are counted as 'errors' by the search algorithm (search algorithm only searches for correctly spelled words)
/mean_LurePosition:				calculates the mean lure Position in the list of recalled items across all lists
/SD_LurePosition:				standard deviation of the lure positions in the list of recalled items across all lists 
/mean_IntrusionsOther:			calculates the mean number of other word intrusions on recall
									!Note: a value > 0 could be a flag to manually check in the raw data file (e.g. values.intrusionOther) whether misspellings of study list words 
									occurred as these misspelled word would be counted as 'other intrusions'
									
Recognition:									
									
/propHits:						hit rate (across all studied words)
/propHits_recallWords:			hit rate for study words used in recall blocks
/propHits_mathWords:			hit rate for study words used in math blocks
/propFA:						false alarm rate (across all non-studied words)
/propFA_recallLures:			false alarm rate for lures tied to study words in recall blocks
/propFA_mathLures:				false alarm rate for lures tied to study words in math blocks
/propFA_newWords:				false alarm rate for study words from lists that were not studied
/propFA_newLures:				false alarm rate for lures of non-studied lists

/propRemember_recallWords:		proportion remember judgments for hits for study words used in recall blocks
/propRemember_recallLures:		proportion remember judgments for false alarms  for recall study word lures

/propRemember_mathWords:		proportion remember judgments for hits for study words used in math blocks
/propRemember_mathLures:		proportion remember judgments for false alarms  for math study word lures

/propRemember_newWords:			proportion remember judgments for false alarms for study words from lists that were not studied
/propRemember_newLures:			proportion remember judgments for false alarms for lures of non-studied lists	

Math:
/nr_MathProblems:				number of math problems attempted 
/propCorrect_Math:				proportion correct math problems

* separate data files: to change to one data file for all participants (on Inquisit Lab only), go to section
"DATA" and follow further instructions



EXPERIMENTAL SET-UP

- 24 lists of 15 study items + 1 'lure' item (=16 items per list) get randomly assigned to be used for study-recall lists (8), 
study-math lists (8) and recognition-only lists (8)

(I) Study-Phase:
- the order of study-recall and study-math tasks (8 each) is randomly determined
- the presentation order of the study words during the study phase is sequential
- words are presented visually with a SOA 1500ms

Recall Task:
Algorithm to estimate number of recalled words:
In general this algorithm uses the number of a specific word separator (here: comma)
to estimate the number of words in between the separators: estimated word count = number of separators + 1
The algorithm uses several steps to clean up the text input to ensure as much as 
possible that only single commas are used as word separators. It also removes
trailing commas from the input if necessary.

Steps:
(1) textbox response is stored in values.Recall (Example: values.Recall = "bed; chair; table") (note: there is a space AND a ; after bed and chair)
(2) values.Recall replaces 7 types of possible word separator symbols (e.g. ";", " ") with a comma (Example: values.Recall = "bed,,chair,,table")
(3) values.Recall adds a comma to the first item (Example: values.Recall = ",bed,,chair,,table")
(3) values.Recall replaces all consecutive commas with a single comma (Example: values.Recall = ",bed,chair,table")
(4) if values.Recall does not end in a comma at this point, this comma is added (Example: values.Recall = ",bed,chair,table,")
(5) the length of the variable values.Recall is stored in variable values.RecallLength (Example: values.RecallLength = 17)
(6) a second variable (values.reducedRecall) deletes all commas in values.Recall (Example: values.reducedRecall = "bedchairtable" => length: 13)
(7) the word count estimate = length of values.Recall* - length of values.reducedRecall - 1 (extra comma) (Example: estimate = 17 - 13 - 1 = 3)
		*with length = number of characters 

Note: the recall scoring algorithms implemented in this script depend on participants 
(a) using the implemented separators
(b) make no spelling mistakes
(c) don't use phonetically similar words (e.g. pain instead of pane)
Manual checks of the raw data might be necessary to adjust the scores (see values.intrustionOther)

		
		
(II) Recognition Phase:
- 96 items (48 old/48 new): order is randomly determined
	48 => 3 from all 16 study lists (items selected: position1, 8, 10) (old words)
	24 => the 'lures' of all 24 lists (new words)
	24 => 3 from the 8 recognition only study lists (items selected: position1, 8, 10) (new words)
- old/new judgments
- if old: remember-know judgments

STIMULI
- words published by Roediger & McDermott (1995)
- study words presented black on white in the center of the screen (size can be adjusted under section Editable Parameters)

INSTRUCTIONS
instructions are provided by Millisecond Software and followed the guidelines outlined in
Roediger & McDermott (1995). The Instructions can be edited under section Editable Instructions.


EDITABLE CODE:
check below for (relatively) easily editable parameters, stimuli, instructions etc. 
Keep in mind that you can use this script as a template and therefore always "mess" with the entire code to further customize your experiment.

The parameters you can change are:

/wordpresentationSOA:	the stimulus onset asynchrony (in ms) of the presented study words (default: 1500ms)
/recallDelay:			the delay (in ms) between last presented study list word and the recall trial (default: 0ms)
/maxRecallDuration:		the time (in ms) allotted to the recall of the words (default: 2.5mins or 150000ms)
/MinRecognitionDelay:	the minimum delay (in ms) between end of last trial and the recognition task (default: 2 min or 120000ms)
/studywordSize:			proportional sizing of study words (default: 5% of canvas height)

Copyright © Millisecond Software. All rights reserved.
Contact | Terms of Service | Security Statement | Employment