.Rhistory

training_array <- rbind(training_array, c(locations[[ifelse(i %% positions, i %% positions, positions)]], tail(training_array[i-1,],20) ,responses[[ifelse(i %% positions, i %% positions, positions)]]))
}
}
# random data Si//R(i-1)//R
for (i in 1:(n_trials+1)) {
if (i == 1){
random_array <- matrix(c(locations[[sample.int(positions, 1)]], zeros, responses[[sample.int(positions, 1)]]), ncol=60)
}else{
random_array <- rbind(random_array, c( locations[[sample.int(positions, 1)]], tail(random_array[i-1,],20) , responses[[sample.int(positions, 1)]]))
}
}
# practice data
for (i in 1:(practice_trials+1)) {
if (i == 1){
practice_array <- matrix(c(practice_locations[[1]], zeros, practice_responses[[1]]), ncol=60)
}else{
practice_array <- rbind(practice_array, c(practice_locations[[ifelse(i %% positions, i %% positions, positions)]], tail(practice_array[i-1,],20) ,practice_responses[[ifelse(i %% positions, i %% positions, positions)]]))
}
}
# number of replications
n_replications <- 25
# learning rates
p_encode <- c(0.33, 0.67, 1)
# specify models
model = "Minerva2"
resonance_summary_df
resonance_summary_df
tmp <- resonance_summary_df
# random test
#-----------------------100 Pretrials Condition--------------------------------#
for (m in 1:length(model)){
for (r in 1:n_replications) {
print(r)
for(i in 1:length(p_encode)) {
#To acknowledge the instructions given to the participants before starting the experiment proper, we stocked memory with one example of each S(i)//R(i21)//R(i) contingency with L ¼ 1.
# Memory is empty on first trial
normalized_echo <- probe_memory(random_array[1,], NULL, cue_features, model = model[m])
expectancy <- expect_event(random_array[1,], normalized_echo)
memory <- learn(
normalized_echo
, random_array[1,]
, 1
, NULL
, model = model[m]
)
# stock with 4 further exemplar memories
for(x in 2:5){
normalized_echo <- probe_memory(random_array[x,], memory, cue_features, model = model[m])
expectancy <- expect_event(random_array[x,], normalized_echo)
memory <- learn(
normalized_echo
, random_array[x,]
, 1
, memory
, model = model[m]
)
}
# practice blocks
for(p in 1:nrow(practice_array)){
normalized_echo <- probe_memory(practice_array[p,], memory, cue_features, model = model[m])
expectancy <- expect_event(practice_array[p,], normalized_echo)
memory <- learn(
normalized_echo
, practice_array[p,]
, 0.7
, memory
, model = model[m]
)
}
# normalized_echo <- probe_memory(test_ac_event, NULL, cue_features, model = model[m])
# expectancy <- expect_event(recall_abc_event, normalized_echo)
# sim_results_100_pretrials[[i,1,r]] <- expectancy
# normalized_echos_100_pretrials[[i,1,r]] <- normalized_echo
# Experimental trials
for(j in 2:(n_trials+1)) {
iteration <- 1
expectancy <- 0
while(expectancy<=0.99){
res <- probe_memory_resonance(random_array[j,], memory, cue_features, model = model[m], iteration)
normalized_echo <- res$normalized_echo
expectancy <- expect_event(random_array[j,], normalized_echo)
iteration <- iteration+1
#print(expectancy)
}
memory <- learn(
normalized_echo
, random_array[j,]
, p_encode[i]
, memory
, model = model[m]
)
#normalized_echo <- probe_memory(random_array[j,], memory, cue_features, model = model[m])
expectancy <- expect_event(random_array[j,], normalized_echo)
sim_resonance_100_pretrials[[i,j,r]] <- iteration
sim_results_100_pretrials[[i,j,r]] <- expectancy
normalized_echos_100_pretrials[[i,j,r]] <- normalized_echo
}
}
}
}
# random test
#-----------------------100 Pretrials Condition--------------------------------#
for (m in 1:length(model)){
for (r in 1:n_replications) {
print(r)
for(i in 1:length(p_encode)) {
#To acknowledge the instructions given to the participants before starting the experiment proper, we stocked memory with one example of each S(i)//R(i21)//R(i) contingency with L ¼ 1.
# Memory is empty on first trial
normalized_echo <- probe_memory(random_array[1,], NULL, cue_features, model = model[m])
expectancy <- expect_event(random_array[1,], normalized_echo)
memory <- learn(
normalized_echo
, random_array[1,]
, 1
, NULL
, model = model[m]
)
# stock with 4 further exemplar memories
for(x in 2:5){
normalized_echo <- probe_memory(random_array[x,], memory, cue_features, model = model[m])
expectancy <- expect_event(random_array[x,], normalized_echo)
memory <- learn(
normalized_echo
, random_array[x,]
, 1
, memory
, model = model[m]
)
}
# practice blocks
for(p in 1:nrow(practice_array)){
normalized_echo <- probe_memory(practice_array[p,], memory, cue_features, model = model[m])
expectancy <- expect_event(practice_array[p,], normalized_echo)
memory <- learn(
normalized_echo
, practice_array[p,]
, 0.7
, memory
, model = model[m]
)
}
# normalized_echo <- probe_memory(test_ac_event, NULL, cue_features, model = model[m])
# expectancy <- expect_event(recall_abc_event, normalized_echo)
# sim_results_100_pretrials[[i,1,r]] <- expectancy
# normalized_echos_100_pretrials[[i,1,r]] <- normalized_echo
# Experimental trials
for(j in 2:(n_trials+1)) {
iteration <- 1
expectancy <- 0
while(expectancy<=0.99){
res <- probe_memory_resonance(random_array[j,], memory, cue_features, model = model[m], iteration)
normalized_echo <- res$normalized_echo
expectancy <- expect_event(random_array[j,], normalized_echo)
iteration <- iteration+1
#print(expectancy)
}
memory <- learn(
normalized_echo
, random_array[j,]
, p_encode[i]
, memory
, model = model[m]
)
#normalized_echo <- probe_memory(random_array[j,], memory, cue_features, model = model[m])
expectancy <- expect_event(random_array[j,], normalized_echo)
sim_resonance_100_pretrials[[i,j,r]] <- iteration
sim_results_100_pretrials[[i,j,r]] <- expectancy
normalized_echos_100_pretrials[[i,j,r]] <- normalized_echo
}
}
}
}
expectancy
# random test
#-----------------------100 Pretrials Condition--------------------------------#
for (m in 1:length(model)){
for (r in 1:n_replications) {
print(r)
for(i in 1:length(p_encode)) {
#To acknowledge the instructions given to the participants before starting the experiment proper, we stocked memory with one example of each S(i)//R(i21)//R(i) contingency with L ¼ 1.
# Memory is empty on first trial
normalized_echo <- probe_memory(random_array[1,], NULL, cue_features, model = model[m])
expectancy <- expect_event(random_array[1,], normalized_echo)
memory <- learn(
normalized_echo
, random_array[1,]
, 1
, NULL
, model = model[m]
)
# stock with 4 further exemplar memories
for(x in 2:5){
normalized_echo <- probe_memory(random_array[x,], memory, cue_features, model = model[m])
expectancy <- expect_event(random_array[x,], normalized_echo)
memory <- learn(
normalized_echo
, random_array[x,]
, 1
, memory
, model = model[m]
)
}
# practice blocks
for(p in 1:nrow(practice_array)){
normalized_echo <- probe_memory(practice_array[p,], memory, cue_features, model = model[m])
expectancy <- expect_event(practice_array[p,], normalized_echo)
memory <- learn(
normalized_echo
, practice_array[p,]
, 0.7
, memory
, model = model[m]
)
}
# normalized_echo <- probe_memory(test_ac_event, NULL, cue_features, model = model[m])
# expectancy <- expect_event(recall_abc_event, normalized_echo)
# sim_results_100_pretrials[[i,1,r]] <- expectancy
# normalized_echos_100_pretrials[[i,1,r]] <- normalized_echo
# Experimental trials
for(j in 2:(n_trials+1)) {
iteration <- 1
expectancy <- 0
while(expectancy<=0.99){
res <- probe_memory_resonance(random_array[j,], memory, cue_features, model = model[m], iteration)
normalized_echo <- res$normalized_echo
expectancy <- expect_event(random_array[j,], normalized_echo)
iteration <- iteration+1
#print(expectancy)
}
memory <- learn(
normalized_echo
, random_array[j,]
, p_encode[i]
, memory
, model = model[m]
)
#normalized_echo <- probe_memory(random_array[j,], memory, cue_features, model = model[m])
expectancy <- expect_event(random_array[j,], normalized_echo)
sim_resonance_100_pretrials[[i,j,r]] <- iteration
sim_results_100_pretrials[[i,j,r]] <- expectancy
normalized_echos_100_pretrials[[i,j,r]] <- normalized_echo
}
}
}
}
expectancy
iteration
iteration <- 1
expectancy <- 0
iteration <- 1
m
r
i
# random test
#-----------------------100 Pretrials Condition--------------------------------#
for (m in 1:length(model)){
for (r in 1:n_replications) {
print(r)
for(i in 1:length(p_encode)) {
#To acknowledge the instructions given to the participants before starting the experiment proper, we stocked memory with one example of each S(i)//R(i21)//R(i) contingency with L ¼ 1.
# Memory is empty on first trial
normalized_echo <- probe_memory(random_array[1,], NULL, cue_features, model = model[m])
expectancy <- expect_event(random_array[1,], normalized_echo)
memory <- learn(
normalized_echo
, random_array[1,]
, 1
, NULL
, model = model[m]
)
# stock with 4 further exemplar memories
for(x in 2:5){
normalized_echo <- probe_memory(random_array[x,], memory, cue_features, model = model[m])
expectancy <- expect_event(random_array[x,], normalized_echo)
memory <- learn(
normalized_echo
, random_array[x,]
, 1
, memory
, model = model[m]
)
}
# practice blocks
for(p in 1:nrow(practice_array)){
normalized_echo <- probe_memory(practice_array[p,], memory, cue_features, model = model[m])
expectancy <- expect_event(practice_array[p,], normalized_echo)
memory <- learn(
normalized_echo
, practice_array[p,]
, 0.7
, memory
, model = model[m]
)
}
# normalized_echo <- probe_memory(test_ac_event, NULL, cue_features, model = model[m])
# expectancy <- expect_event(recall_abc_event, normalized_echo)
# sim_results_100_pretrials[[i,1,r]] <- expectancy
# normalized_echos_100_pretrials[[i,1,r]] <- normalized_echo
# Experimental trials
for(j in 2:(n_trials+1)) {
iteration <- 1
expectancy <- 0
while(expectancy<=0.99){
res <- probe_memory_resonance(random_array[j,], memory, cue_features, model = model[m], iteration)
normalized_echo <- res$normalized_echo
expectancy <- expect_event(random_array[j,], normalized_echo)
iteration <- iteration+1
#print(expectancy)
}
memory <- learn(
normalized_echo
, random_array[j,]
, p_encode[i]
, memory
, model = model[m]
)
#normalized_echo <- probe_memory(random_array[j,], memory, cue_features, model = model[m])
expectancy <- expect_event(random_array[j,], normalized_echo)
sim_resonance_100_pretrials[[i,j,r]] <- iteration
sim_results_100_pretrials[[i,j,r]] <- expectancy
normalized_echos_100_pretrials[[i,j,r]] <- normalized_echo
}
}
}
}
training_array <- rep(list(training_ab_event, training_bc_event, training_cd_event, training_de_event, training_ef_event), trials)
# setup constant variables over all simulations
n_features <- 160
cue_features <- 1:140
a <- b  <- c <- d <- e <- f <- context <- outcome <- rep(0, n_features)
# setup stimuli
a[1:20] <- b [21:40] <- c[41:60] <- d[61:80] <- e[81:100] <- f[101:120] <- 1
context[121:140] <- 1
outcome[141:160] <- 0
# number of replications
n_replications <- 100
# learning rates
p_encode <- c(0.2, 0.4, 0.6, 0.8, 1)
# specify models
model = "Minerva AL"
model = "Minerva2"
# specify events
training_a_event <- a + context
training_b_event <- b + context
training_c_event <- c + context
training_d_event <- d + context
training_e_event <- e + context
training_f_event <- f + context
training_ab_event <- a+b + context
training_bc_event <- b+c + context
training_cd_event <- c+d + context
training_de_event <- d+e + context
training_ef_event <- e+f + context
test_bc_event <- b + c + context
recall_bc_event <- b + c + context
test_bd_event <- b + d + context
recall_bcd_event <- b + c + d + context
test_be_event <- b + e + context
recall_bcde_event <- b + c + d + e + context
# specify probe
probe_a <- a + context
probe_b <- b + context
probe_c <- c + context
probe_d <- d + context
probe_e <- e + context
probe_f <- f + context
trials <- 50
# setup trial number
n_trials <- 5*trials
#training array
training_array <- rep(list(training_ab_event, training_bc_event, training_cd_event, training_de_event, training_ef_event), trials)
plot(matrix(unlist(training_array), ncol=160,byrow = TRUE))
#random shuffle
training_array <- sample(training_array)
#plot(matrix(unlist(training_array), ncol=160))
# prepare results object as 3D array[p_encode, n_trials, n_replications]
sim_results_0_pretrials <- array(NA, c(length(p_encode), n_trials, n_replications))
sim_results_10_pretrials <- array(NA, c(length(p_encode), n_trials, n_replications))
sim_results_30_pretrials <- array(NA, c(length(p_encode), n_trials, n_replications))
sim_results_100_pretrials <- array(NA, c(length(p_encode), n_trials, n_replications))
sim_results_0_adjacent <- array(NA, c(length(p_encode), n_trials, n_replications))
sim_results_0_close <- array(NA, c(length(p_encode), n_trials, n_replications))
sim_results_0_distant <- array(NA, c(length(p_encode), n_trials, n_replications))
# specify object for normalized echo for every trial as 3D array[p_encode, n_trials, n_replications]
# with cells containing normalized echo vector
normalized_echos_0_pretrials <- array(list(rep(NA, n_features)), dim = c(length(p_encode), n_trials, n_replications))
normalized_echos_10_pretrials <- array(list(rep(NA, n_features)), dim = c(length(p_encode), n_trials, n_replications))
normalized_echos_30_pretrials <- array(list(rep(NA, n_features)), dim = c(length(p_encode), n_trials, n_replications))
normalized_echos_100_pretrials <- array(list(rep(NA, n_features)), dim = c(length(p_encode), n_trials, n_replications))
normalized_echos_0_adjacent <- array(list(rep(NA, n_features)), dim = c(length(p_encode), n_trials, n_replications))
normalized_echos_0_close <- array(list(rep(NA, n_features)), dim = c(length(p_encode), n_trials, n_replications))
normalized_echos_0_distant <- array(list(rep(NA, n_features)), dim = c(length(p_encode), n_trials, n_replications))
training_array <- rep(list(training_ab_event, training_bc_event, training_cd_event, training_de_event, training_ef_event), trials)
plot(matrix(unlist(training_array), ncol=160,byrow = TRUE))
plot(matrix(unlist(training_array), ncol=160, byrow = TRUE))
library("plot.matrix")
plot(matrix(unlist(training_array), ncol=160, byrow = TRUE))
library('plot.matrix')
par(mar=c(5.1, 4.1, 4.1, 4.1)) # adapt margins
plot(matrix(unlist(training_array), ncol=160, byrow = TRUE))
plot(matrix(unlist(training_array), ncol=160, byrow = TRUE))
par(mar=c(5.1, 4.1, 4.1, 4.1)) # adapt margins
plot(matrix(unlist(training_array), ncol=160, byrow = TRUE))
training_array <- sample(training_array)
training_array <- sample(training_array)
plot(matrix(unlist(training_array), ncol=160, byrow = TRUE))
p_encode
i=4
i=5
normalized_echo <- probe_memory(training_array[[1]], NULL, cue_features, model = model[m])
expectancy <- expect_event(outcome, normalized_echo)
memory <- learn(
normalized_echo
, training_array[[1]]
, p_encode[i]
, NULL
, model = model[m]
)
plot(memory)
outcome
# main test
#-----------------------Main Condition--------------------------------#
for (m in 1:length(model)){
for (r in 1:n_replications) {
training_array <- sample(training_array)
for(i in 1:length(p_encode)) {
# Memory is empty on first trial
normalized_echo <- probe_memory(training_array[[1]], NULL, cue_features, model = model[m])
expectancy <- expect_event(training_array[[1]], normalized_echo)
memory <- learn(
normalized_echo
, training_array[[1]]
, p_encode[i]
, NULL
, model = model[m]
)
normalized_echo <- probe_memory(test_bd_event, NULL, cue_features, model = model[m])
expectancy <- expect_event(recall_bcd_event, normalized_echo)
sim_results_0_close[[i,1,r]] <- expectancy
normalized_echos_0_close[[i,1,r]] <- normalized_echo
normalized_echo <- probe_memory(test_be_event, NULL, cue_features, model = model[m])
expectancy <- expect_event(recall_bcde_event, normalized_echo)
sim_results_0_distant[[i,1,r]] <- expectancy
normalized_echos_0_distant[[i,1,r]] <- normalized_echo
normalized_echo <- probe_memory(test_bc_event, NULL, cue_features, model = model[m])
expectancy <- expect_event(recall_bc_event, normalized_echo)
sim_results_0_adjacent[[i,1,r]] <- expectancy
normalized_echos_0_adjacent[[i,1,r]] <- normalized_echo
# A trials
for(j in 2:n_trials) {
normalized_echo <- probe_memory(training_array[[j]], memory, cue_features, model = model[m])
expectancy <- expect_event(outcome, normalized_echo)
memory <- learn(
normalized_echo
, training_array[[j]]
, p_encode[i]
, memory
, model = model[m]
)
normalized_echo <- probe_memory(test_bd_event, memory, cue_features, model = model[m])
expectancy <- expect_event(recall_bcd_event, normalized_echo)
sim_results_0_close[[i,j,r]] <- expectancy
normalized_echos_0_close[[i,j,r]] <- normalized_echo
normalized_echo <- probe_memory(test_be_event, memory, cue_features, model = model[m])
expectancy <- expect_event(recall_bcde_event, normalized_echo)
sim_results_0_distant[[i,j,r]] <- expectancy
normalized_echos_0_distant[[i,j,r]] <- normalized_echo
normalized_echo <- probe_memory(test_bc_event, memory, cue_features, model = model[m])
expectancy <- expect_event(recall_bc_event, normalized_echo)
sim_results_0_adjacent[[i,j,r]] <- expectancy
normalized_echos_0_adjacent[[i,j,r]] <- normalized_echo
}
}
}
}
#-----calculate mean and standard error of results objects-----
divide_by_n_rep <- function(x, n_rep = n_replications){x/n_rep}
# Sum of expectancies for each trial over all replications
sum_sim_results_0_adjacent <- apply(sim_results_0_adjacent, c(1,2), FUN = sum)
# Mean of expectancies for each trial over all replications
mean_sim_results_0_adjacent <- apply(sum_sim_results_0_adjacent, c(1,2), FUN = divide_by_n_rep)
# Sum of expectancies for each trial over all replications
sum_sim_results_0_close <- apply(sim_results_0_close, c(1,2), FUN = sum)
# Mean of expectancies for each trial over all replications
mean_sim_results_0_close <- apply(sum_sim_results_0_close, c(1,2), FUN = divide_by_n_rep)
# Sum of expectancies for each trial over all replications
sum_sim_results_0_distant <- apply(sim_results_0_distant, c(1,2), FUN = sum)
# Mean of expectancies for each trial over all replications
mean_sim_results_0_distant <- apply(sum_sim_results_0_distant, c(1,2), FUN = divide_by_n_rep)
# critical trial until x|cue >= 0.95 in each replication for every learning rate
# crit_trials_100_pretrials <- apply(sim_results_100_pretrials, c(1,3), FUN = find_crit_trial)
# se of critical trials until x|cue >= 0.95 in each replication for every learning rate
# std_error_100_pretrials <- apply(crit_trials_100_pretrials, 1, FUN = std_err)
mean_sim_results_0_adjacent
mean_sim_results_0_adjacent
adjacent_df <- as.data.frame(mean_sim_results_0_adjacent)
adjacent_df
p_encode
str(p_encode)
adjacent_df <- as.data.frame(mean_sim_results_0_adjacent, row.names = p_encode)
adjacent_df
library(tidyr)
install.packages("tidyr")
library(tidyr)
library("tidyr")
library("tidyverse")
install.packages("tidyverse")
library("tidyverse")
library(ggplot)
library(ggplot2)
library(gather)
library(tidyr)