Mixture modeling for workingmemory experiments
Project description
Biased Memory Toolbox
A Python toolbox for mixture modeling of data from visualworkingmemory experiments
Cherie Zhou (@cherieai) and Sebastiaan Mathôt (@smathot)
Copyright 2020  2021
Citation
Zhou, C., Lorist, M., Mathôt, S., (2021). Categorical bias in visual working memory: The effect of memory load and retention interval. Cortex. https://osf.io/puq4v/
This manuscript is a Stage 1 inprinciple acceptance of a registered report
Installation
pip install biased_memory_toolbox
Usage
This section focuses on using the module, assuming that you have a basic understanding of mixture modeling of working memory data. If you want to know more about the theory behind mixture modeling, please read (for example) the manuscript cited above.
We start by reading in a data file using DataMatrix. The data should contain a column that contains the memoranda (here: memory_hue
) and a column that contains the responses (here: response_hue
), both in degrees with values between 0 and 360.
from datamatrix import io
dm = io.readtxt('exampledata/exampleparticipant.csv')
As a first step, which is not related to mixture modeling per se, we check whether the participant performed significantly (p < .05) above chance. This is done with a permutation test that is implemented as test_chance_performance()
. Here, low pvalues indicate that performance deviates from chance.
import biased_memory_toolbox as bmt
t, p = bmt.test_chance_performance(dm.memory_hue, dm.response_hue)
print('testing performance: t = {:.4f}, p = {:.4f}'.format(t, p))
Output:
testing performance: t = 57.0220, p = 0.0000
Now let's fit the mixture model. We start with a basic model in which only precision and guess rate are estimated, as in the original Zhang and Luck (2008) paper.
To do so, we first calculate the response error, which is simply the circular distance between the memory hue (the color that the participant needed to remember) and the response hue (the color that the participant reproduced). This is done with response_bias()
, which, when no categories are provided, simply calculates the response error.
dm.response_error = bmt.response_bias(dm.memory_hue, dm.response_hue)
We can fit the model with a simple call to fix_mixture_model()
. By specifying include_bias=False
, we fix the bias parameter (the mean of the distribution) at 0, and thus
only get two parameters: the precision and the guess rate.
precision, guess_rate = bmt.fit_mixture_model(
dm.response_error,
include_bias=False
)
print('precision: {:.4f}, guess rate: {:.4f}'.format(precision, guess_rate))
Output:
precision: 1721.6386, guess rate: 0.0627
Now let's fit a slightly more complex model that also includes a bias parameter. To do so, we first calculate the response 'bias', which is similar to the response error except that it is recoded such that positive values reflect a response error towards the prototype of the category that the memorandum belongs to. For example, if the participant saw a slightly aquaish shade of green but reproduced a pure green, then this would correspond to a positive response bias for that response.
To calculate the response bias we need to specify a dict
with category boundaries and prototypes when calling response_bias()
. A sensible default (DEFAULT_CATEGORIES
), based on ratings of human participants, is provided with the toolbox.
dm.response_bias = bmt.response_bias(
dm.memory_hue,
dm.response_hue,
categories=bmt.DEFAULT_CATEGORIES
)
Next we fit the model again by calling fit_mixture_model()
. We now also get a bias parameter (because we did not specify include_bias=False
) as described in Zhou, Lorist, and Mathôt (2021).
precision, guess_rate, bias = bmt.fit_mixture_model(dm.response_bias)
print(
'precision: {:.4f}, guess rate: {:.4f}, bias: {:.4f}'.format(
precision,
guess_rate,
bias
)
)
Output:
precision: 1725.9568, guess rate: 0.0626, bias: 0.5481
It also makes sense to visualize the model fit, to see if the model accurately captures the pattern of responses. We can do this by plotting a probability density function, which can be generated by mixture_model_pdf()
.
import numpy as np
import seaborn as sns
from matplotlib import pyplot as plt
x = np.linspace(180, 180, 360)
y = bmt.mixture_model_pdf(x, precision, guess_rate, bias)
plt.figure(figsize=(10, 5))
plt.subplot(121)
plt.title('Model fit')
plt.xlim(50, 50)
plt.plot(x, y)
plt.subplot(122)
plt.title('Histogram of response biases')
plt.xlim(50, 50)
sns.distplot(dm.response_bias, kde=False)
plt.savefig('example.png')
We can also fit a model that takes into account swap errors, as described by Bays, Catalao, and Husain (2009). To do so, we need to also specify the response bias (or plain error) with respect to the nontarget items.
Here, we select only those trials in which the set size was 3, and then create two new columns for the response bias with respect to the second and third memory colors, which were nontargets in this experiment. (The first color was the target color.)
dm3 = dm.set_size == 3
dm3.response_bias_nontarget2 = bmt.response_bias(
dm3.hue2,
dm3.response_hue,
categories=bmt.DEFAULT_CATEGORIES
)
dm3.response_bias_nontarget3 = bmt.response_bias(
dm3.hue3,
dm3.response_hue,
categories=bmt.DEFAULT_CATEGORIES
)
By passing a list of nontarget response biases, we get a fourth parameter: swap rate.
precision, guess_rate, bias, swap_rate = bmt.fit_mixture_model(
x=dm3.response_bias,
x_nontargets=[
dm3.response_bias_nontarget2,
dm3.response_bias_nontarget3
],
)
print(
'precision: {:.4f}, guess rate: {:.4f}, bias: {:.4f}, swap_rate: {:.4f}'.format(
precision,
guess_rate,
bias,
swap_rate
)
)
Output:
precision: 1458.9628, guess rate: 0.0502, bias: 1.2271, swap_rate: 0.0191
License
biased_memory_toolbox
is licensed under the GNU General Public License
v3.
Project details
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for biased_memory_toolbox1.2.1.tar.gz
Algorithm  Hash digest  

SHA256  8d36a1ee3160d0adfe5394c1b18fccd4730af345ea58ddff2f78ad232e7d593d 

MD5  5092830d2430ef5901efee6df589e596 

BLAKE2b256  37bd67fe08c11f8f8f2bb9c23429384b7a9c1d1ffa0acf1b3f66ac38ec523eba 
Hashes for biased_memory_toolbox1.2.1py3noneany.whl
Algorithm  Hash digest  

SHA256  c953c42c1393b56ee46052a843fe8aabe283eb7fd1771a496a9001157e499b8b 

MD5  3d47a77405e35290623185e72e01c2b6 

BLAKE2b256  b58a189ff753ded9c076cc580c908f90d890c9143ce9fc6b93b0c5ddf04ef4a0 