def runTest(self):
data = util.load_data_from_csv(
"test_files/sample_trial_data.csv",
"test_files/sample_fixations.csv", useAngularDists=True)
expectedRT = {'abc': {1: 100}, 'xyz': {1: 200}}
expectedChoice = {'abc': {1: 1}, 'xyz': {1: -1}}
expectedValueLeft = {'abc': {1: 1}, 'xyz': {1: 2}}
expectedValueRight = {'abc': {1: 0}, 'xyz': {1: 1}}
expectedFixItem = {'abc': {1: np.array([1, 2])},
'xyz': {1: np.array([1, 2, 1])}}
expectedFixTime = {'abc': {1: np.array([50, 50])},
'xyz': {1: np.array([100, 50, 50])}}
expectedIsCisTrial = {'abc': {1: False}, 'xyz': {1: True}}
expectedIsTransTrial = {'abc': {1: True}, 'xyz': {1: False}}
self.assertEqual(expectedRT, data.RT)
self.assertEqual(expectedChoice, data.choice)
self.assertEqual(expectedValueLeft, data.valueLeft)
self.assertEqual(expectedValueRight, data.valueRight)
np.testing.assert_equal(expectedFixItem, data.fixItem)
np.testing.assert_equal(expectedFixTime, data.fixTime)
self.assertEqual(expectedIsCisTrial, data.isCisTrial)
self.assertEqual(expectedIsTransTrial, data.isTransTrial)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--num-threads", type=int, default=9,
help="Size of the thread pool.")
parser.add_argument("--num-trials", type=int, default=800,
help="Number of artificial data trials to be generated "
"per trial condition.")
parser.add_argument("--d", type=float, default=0.006,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--sigma", type=float, default=0.08,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--theta", type=float, default=0.5,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--range-d", nargs="+", type=float,
default=[0.005, 0.006, 0.007],
help="Search range for parameter d.")
parser.add_argument("--range-sigma", nargs="+", type=float,
default=[0.065, 0.08, 0.095],
help="Search range for parameter sigma.")
parser.add_argument("--range-theta", nargs="+", type=float,
default=[0.4, 0.5, 0.6],
help="Search range for parameter theta.")
parser.add_argument("--expdata-file-name", type=str, default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name", type=str,
default="fixations.csv", help="Name of fixations file.")
parser.add_argument("--verbose", default=False, action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
pool = Pool(args.num_threads)
# Load experimental data from CSV file.
try:
data = load_data_from_csv(
args.expdata_file_name, args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
valueLeft = data.valueLeft
valueRight = data.valueRight
fixItem = data.fixItem
fixTime = data.fixTime
# Get empirical distributions.
try:
dists = get_empirical_distributions(valueLeft, valueRight, fixItem,
fixTime)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
# Trial conditions for artificial data generation.
orientations = range(-15,20,5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Generate artificial data.
if args.verbose:
print("Running simulations...")
try:
simul = run_simulations(
probLeftFixFirst, distLatencies, distTransitions, distFixations,
args.num_trials, trialConditions, args.d, args.theta,
sigma=args.sigma)
except Exception as e:
print("An exception occurred while generating artificial data: " +
str(e))
return
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
# Grid search to recover the parameters.
if args.verbose:
print("Starting grid search...")
numModels = (len(args.range_d) * len(args.range_sigma) *
len(args.range_theta))
models = list()
posteriors = dict()
for d in args.range_d:
for theta in args.range_theta:
for sigma in args.range_sigma:
model = (d, theta, sigma)
models.append(model)
posteriors[model] = 1. / numModels
trials = simulChoice.keys()
for trial in trials:
listParams = list()
for model in models:
listParams.append(
(simulChoice[trial], simulValueLeft[trial],
simulValueRight[trial], simulFixItem[trial],
simulFixTime[trial], model[0], model[1], model[2]))
try:
likelihoods = pool.map(get_trial_likelihood_wrapper, listParams)
except Exception as e:
print("An exception occurred during the likelihood computation for "
"trial " + str(trial) + ": " + str(e))
return
# Get the denominator for normalizing the posteriors.
i = 0
denominator = 0
for model in models:
denominator += posteriors[model] * likelihoods[i]
i += 1
if denominator == 0:
continue
# Calculate the posteriors after this trial.
i = 0
for model in models:
prior = posteriors[model]
posteriors[model] = likelihoods[i] * prior / denominator
i += 1
if args.verbose and trial % 200 == 0:
for model in posteriors:
print("P" + str(model) + " = " + str(posteriors[model]))
print("Sum: " + str(sum(posteriors.values())))
if args.verbose:
for model in posteriors:
print("P" + str(model) + " = " + str(posteriors[model]))
print("Sum: " + str(sum(posteriors.values())))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("subject", type=str, help="Subject name.")
parser.add_argument("--num-threads", type=int, default=9,
help="Size of the thread pool.")
parser.add_argument("--num-trials", type=int, default=100,
help="Number of trials to be used in the analysis; if "
"smaller than 1, all trials are used.")
parser.add_argument("--num-samples", type=int, default=32,
help="Number of samples to be drawn from the posterior "
"distribution when generating simulations.")
parser.add_argument("--num-simulations-per-sample", type=int, default=1,
help="Number of simulations to be genearated for each "
"sample drawn from the posterior distribution.")
parser.add_argument("--range-d", nargs="+", type=float,
default=[0.003, 0.006, 0.009],
help="Search range for parameter d.")
parser.add_argument("--range-sigma", nargs="+", type=float,
default=[0.03, 0.06, 0.09],
help="Search range for parameter sigma.")
parser.add_argument("--range-theta", nargs="+", type=float,
default=[0.3, 0.5, 0.7],
help="Search range for parameter theta.")
parser.add_argument("--expdata-file-name", type=str, default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name", type=str,
default="fixations.csv", help="Name of fixations file.")
parser.add_argument("--save-simulations", default=False,
action="store_true", help="Save simulations to CSV.")
parser.add_argument("--verbose", default=False, action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
pool = Pool(args.num_threads)
choice = dict()
valueLeft = dict()
valueRight = dict()
fixItem = dict()
fixTime = dict()
# Load experimental data from CSV file.
try:
data = load_data_from_csv(
args.expdata_file_name, args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
choice[args.subject] = data.choice[args.subject]
valueLeft[args.subject] = data.valueLeft[args.subject]
valueRight[args.subject] = data.valueRight[args.subject]
fixItem[args.subject] = data.fixItem[args.subject]
fixTime[args.subject] = data.fixTime[args.subject]
# Posteriors estimation for the parameters of the model, using odd trials.
if args.verbose:
print("Starting grid search for subject " + args.subject + "...")
numModels = (len(args.range_d) * len(args.range_theta) *
len(args.range_sigma))
models = list()
posteriors = dict()
for d in args.range_d:
for theta in args.range_theta:
for sigma in args.range_sigma:
model = (d, theta, sigma)
models.append(model)
posteriors[model] = 1. / numModels
subjects = choice.keys()
for subject in subjects:
trials = choice[subject].keys()
if args.num_trials < 1:
args.num_trials = len(trials)
trialSet = np.random.choice(
[trial for trial in trials if trial % 2],
args.num_trials, replace=False)
for trial in trialSet:
if not trial % 2:
continue
listParams = list()
for model in models:
listParams.append(
(choice[subject][trial], valueLeft[subject][trial],
valueRight[subject][trial], fixItem[subject][trial],
fixTime[subject][trial], model[0], model[1], model[2]))
try:
likelihoods = pool.map(get_trial_likelihood_wrapper, listParams)
except Exception as e:
print("An exception occurred during the likelihood computation "
"for trial " + str(trial) + ": " + str(e))
return
# Get the denominator for normalizing the posteriors.
i = 0
denominator = 0
for model in models:
denominator += posteriors[model] * likelihoods[i]
i += 1
if denominator == 0:
continue
# Calculate the posteriors after this trial.
i = 0
for model in models:
prior = posteriors[model]
posteriors[model] = likelihoods[i] * prior / denominator
i += 1
if args.verbose:
for model in posteriors:
print("P" + str(model) + " = " + str(posteriors[model]))
print("Sum: " + str(sum(posteriors.values())))
if args.verbose:
print("Finished grid search!")
# Get empirical distributions from even trials.
try:
dists = get_empirical_distributions(
valueLeft, valueRight, fixItem, fixTime, useOddTrials=False,
useEvenTrials=True)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
# Trial conditions for generating simulations.
orientations = range(-15,20,5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Generate probabilistic simulations using the posteriors distribution.
try:
simul = generate_probabilistic_simulations(
probLeftFixFirst, distLatencies, distTransitions, distFixations,
trialConditions, posteriors, args.num_samples,
args.num_simulations_per_sample)
except Exception as e:
print("An exception occurred while running simulations: " + str(e))
return
simulRT = simul.RT
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
simulFixRDV = simul.fixRDV
if args.save_simulations:
totalTrials = len(simulRT.keys())
save_simulations_to_csv(
simulChoice, simulRT, simulValueLeft, simulValueRight, simulFixItem,
simulFixTime, simulFixRDV, totalTrials)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--num-threads", type=int, default=9,
help="Size of the thread pool.")
parser.add_argument("--trials-per-subject", type=int, default=100,
help="Number of trials from each subject to be used in "
"the analysis; if smaller than 1, all trials are used.")
parser.add_argument("--pop-size", type=int, default=18,
help="Number of individuals in each population.")
parser.add_argument("--num-generations", type=int, default=20,
help="Number of generations.")
parser.add_argument("--crossover-rate", type=float, default=0.5,
help="Crossover rate.")
parser.add_argument("--mutation-rate", type=float, default=0.3,
help="Mutation rate.")
parser.add_argument("--lower-bound-d", type=float, default=0.0001,
help="Lower search bound for parameter d.")
parser.add_argument("--upper-bound-d", type=float, default=0.01,
help="Upper search bound for parameter d.")
parser.add_argument("--lower-bound-theta", type=float, default=0,
help="Lower search bound for parameter theta.")
parser.add_argument("--upper-bound-theta", type=float, default=1,
help="Upper search bound for parameter theta.")
parser.add_argument("--lower-bound-sigma", type=float, default=0.001,
help="Lower search bound for parameter sigma.")
parser.add_argument("--upper-bound-sigma", type=float, default=0.1,
help="Upper search bound for parameter sigma.")
parser.add_argument("--expdata-file-name", type=str, default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name", type=str,
default="fixations.csv", help="Name of fixations file.")
args = parser.parse_args()
global choice
global valueLeft
global valueRight
global fixItem
global fixTime
global trialsPerSubject
# Load experimental data from CSV file and update global variables.
try:
data = load_data_from_csv(
args.expdata_file_name, args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
choice = data.choice
valueLeft = data.valueLeft
valueRight = data.valueRight
fixItem = data.fixItem
fixTime = data.fixTime
trialsPerSubject = args.trials_per_subject
creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox = base.Toolbox()
# Create thread pool.
pool = Pool(args.num_threads)
toolbox.register("map", pool.map)
# Create individual.
toolbox.register("attr_d", random.uniform, args.lower_bound_d,
args.upper_bound_d)
toolbox.register("attr_theta", random.uniform, args.lower_bound_theta,
args.upper_bound_theta)
toolbox.register("attr_sigma", random.uniform, args.lower_bound_sigma,
args.upper_bound_sigma)
toolbox.register("individual", tools.initCycle, creator.Individual,
(toolbox.attr_d, toolbox.attr_theta, toolbox.attr_sigma),
n=1)
# Create population.
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
pop = toolbox.population(n=args.pop_size)
# Create operators.
toolbox.register("mate", tools.cxUniform, indpb=0.4)
toolbox.register("mutate", tools.mutGaussian, mu=0,
sigma=[0.0005, 0.05, 0.005], indpb=0.4)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", evaluate)
# Evaluate the entire population.
try:
fitnesses = toolbox.map(toolbox.evaluate, pop)
except:
print("An exception occurred during the first population evaluation: " +
str(e))
return
bestFit = sys.float_info.max
bestInd = None
for ind, fit in zip(pop, fitnesses):
ind.fitness.values = fit
# Get best individual.
if fit < bestFit:
bestInd = ind
for g in xrange(args.num_generations):
print("Generation " + str(g) + "...")
# Select the next generation individuals.
offspring = toolbox.select(pop, len(pop))
# Clone the selected individuals.
offspring = map(toolbox.clone, offspring)
# Apply crossover and mutation on the offspring.
for child1, child2 in zip(offspring[::2], offspring[1::2]):
if random.random() < args.crossover_rate:
toolbox.mate(child1, child2)
del child1.fitness.values
del child2.fitness.values
for mutant in offspring:
if random.random() < args.mutation_rate:
toolbox.mutate(mutant)
del mutant.fitness.values
# Evaluate the individuals which are valid but have an invalid fitness.
invalidInd = list()
for ind in offspring:
if (ind[0] < args.lower_bound_d or
ind[0] > args.upper_bound_d or
ind[1] < args.lower_bound_theta or
ind[1] > args.upper_bound_theta or
ind[2] < args.lower_bound_sigma or
ind[2] > args.upper_bound_sigma):
ind.fitness.values = sys.float_info.max,
elif not ind.fitness.valid:
invalidInd.append(ind)
try:
fitnesses = map(toolbox.evaluate, invalidInd)
except:
print("An exception occurred during the population evaluation " +
"for generation " + str(g) + ": " + str(e))
return
for ind, fit in zip(invalidInd, fitnesses):
ind.fitness.values = fit
# The population is entirely replaced by the offspring.
pop[:] = offspring
# Update best individual.
for ind in pop:
if ind.fitness.values[0] < bestFit:
bestFit = ind.fitness.values[0]
bestInd = ind
print("Best individual: " + str(bestInd))
print("Fitness of best individual: " + str(bestFit))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--num-threads",
type=int,
default=9,
help="Size of the thread pool.")
parser.add_argument(
"--trials-per-subject",
type=int,
default=100,
help="Number of trials from each subject to be used in "
"the analysis; if smaller than 1, all trials are used.")
parser.add_argument(
"--num-samples",
type=int,
default=100,
help="Number of samples to be drawn from the posterior "
"distribution when generating simulations.")
parser.add_argument("--num-simulations-per-sample",
type=int,
default=10,
help="Number of simulations to be genearated for each "
"sample drawn from the posterior distribution.")
parser.add_argument("--range-d",
nargs="+",
type=float,
default=[0.003, 0.006, 0.009],
help="Search range for parameter d.")
parser.add_argument("--range-sigma",
nargs="+",
type=float,
default=[0.03, 0.06, 0.09],
help="Search range for parameter sigma.")
parser.add_argument("--range-theta",
nargs="+",
type=float,
default=[0.3, 0.5, 0.7],
help="Search range for parameter theta.")
parser.add_argument("--expdata-file-name",
type=str,
default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name",
type=str,
default="fixations.csv",
help="Name of fixations file.")
parser.add_argument("--save-simulations",
default=False,
action="store_true",
help="Save simulations to CSV.")
parser.add_argument("--verbose",
default=False,
action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
pool = Pool(args.num_threads)
# Load experimental data from CSV file.
try:
data = load_data_from_csv(args.expdata_file_name,
args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
choice = data.choice
valueLeft = data.valueLeft
valueRight = data.valueRight
fixItem = data.fixItem
fixTime = data.fixTime
# Posteriors estimation for the parameters of the model, using odd trials.
if args.verbose:
print("Starting grid search...")
numModels = (len(args.range_d) * len(args.range_theta) *
len(args.range_sigma))
models = list()
posteriors = dict()
for d in args.range_d:
for theta in args.range_theta:
for sigma in args.range_sigma:
model = (d, theta, sigma)
models.append(model)
posteriors[model] = 1. / numModels
subjects = choice.keys()
for subject in subjects:
if args.verbose:
print("Running subject " + subject + "...")
trials = choice[subject].keys()
if args.trials_per_subject < 1:
args.trials_per_subject = len(trials)
trialSet = np.random.choice([trial for trial in trials if trial % 2],
args.trials_per_subject,
replace=False)
for trial in trialSet:
listParams = list()
for model in models:
listParams.append(
(choice[subject][trial], valueLeft[subject][trial],
valueRight[subject][trial], fixItem[subject][trial],
fixTime[subject][trial], model[0], model[1], model[2]))
try:
likelihoods = pool.map(get_trial_likelihood_wrapper,
listParams)
except Exception as e:
print(
"An exception occurred during the likelihood computation "
"for subject " + subject + ", trial " + str(trial) + ": " +
str(e))
return
# Get the denominator for normalizing the posteriors.
i = 0
denominator = 0
for model in models:
denominator += posteriors[model] * likelihoods[i]
i += 1
if denominator == 0:
continue
# Calculate the posteriors after this trial.
i = 0
for model in models:
prior = posteriors[model]
posteriors[model] = likelihoods[i] * prior / denominator
i += 1
if args.verbose:
for model in posteriors:
print("P" + str(model) + " = " + str(posteriors[model]))
print("Sum: " + str(sum(posteriors.values())))
if args.verbose:
print("Finished grid search!")
# Get empirical distributions from even trials.
try:
dists = get_empirical_distributions(valueLeft,
valueRight,
fixItem,
fixTime,
useOddTrials=False,
useEvenTrials=True)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
# Trial conditions for generating simulations.
orientations = range(-15, 20, 5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Generate probabilistic simulations using the posteriors distribution.
try:
simul = generate_probabilistic_simulations(
probLeftFixFirst, distLatencies, distTransitions, distFixations,
trialConditions, posteriors, args.num_samples,
args.num_simulations_per_sample)
except Exception as e:
print("An exception occurred while running simulations: " + str(e))
return
simulRT = simul.RT
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
simulFixRDV = simul.fixRDV
if args.save_simulations:
totalTrials = len(simulRT.keys())
save_simulations_to_csv(simulChoice, simulRT, simulValueLeft,
simulValueRight, simulFixItem, simulFixTime,
simulFixRDV, totalTrials)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--num-threads", type=int, default=9,
help="Size of the thread pool.")
parser.add_argument("--num-trials", type=int, default=10,
help="Number of artificial data trials to be generated "
"per trial condition.")
parser.add_argument("--num-simulations", type=int, default=10,
help="Number of simulations to be generated per trial "
"condition, to be used in the RT histograms.")
parser.add_argument("--bin-step", type=int, default=100,
help="Size of the bin step to be used in the RT "
"histograms.")
parser.add_argument("--max-rt", type=int, default=8000,
help="Maximum RT to be used in the RT histograms.")
parser.add_argument("--d", type=float, default=0.006,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--sigma", type=float, default=0.08,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--theta", type=float, default=0.5,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--range-d", nargs="+", type=float,
default=[0.005, 0.006, 0.007],
help="Search range for parameter d.")
parser.add_argument("--range-sigma", nargs="+", type=float,
default=[0.065, 0.08, 0.095],
help="Search range for parameter sigma.")
parser.add_argument("--range-theta", nargs="+", type=float,
default=[0.4, 0.5, 0.6],
help="Search range for parameter theta.")
parser.add_argument("--expdata-file-name", type=str, default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name", type=str,
default="fixations.csv", help="Name of fixations file.")
parser.add_argument("--verbose", default=False, action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
pool = Pool(args.num_threads)
# Load experimental data from CSV file.
try:
data = load_data_from_csv(
args.expdata_file_name, args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
# Get empirical distributions.
try:
dists = get_empirical_distributions(
data.valueLeft, data.valueRight, data.fixItem, data.fixTime)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
if args.verbose:
print("Done getting empirical distributions!")
histBins = range(0, args.max_rt + args.bin_step, args.bin_step)
orientations = range(-15,20,5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Generate histograms for artificial data.
dataHistLeft = dict()
dataHistRight = dict()
for trialCondition in trialConditions:
RTsLeft = list()
RTsRight = list()
trial = 0
while trial < args.num_trials:
try:
results = addm(probLeftFixFirst, distLatencies, distTransitions,
distFixations, args.d, args.sigma, args.theta,
trialCondition[0], trialCondition[1])
except Exception as e:
print("An exception occurred while running the model for "
"artificial data generation, at trial " + str(trial) +
": " + str(e))
return
if results.choice == -1:
RTsLeft.append(results.RT)
elif results.choice == 1:
RTsRight.append(results.RT)
trial += 1
dataHistLeft[trialCondition] = np.histogram(RTsLeft, bins=histBins)[0]
dataHistRight[trialCondition] = np.histogram(RTsRight, bins=histBins)[0]
if args.verbose:
print("Done generating histograms of artificial data!")
# Grid search on the parameters of the model.
models = list()
for d in args.range_d:
for sigma in args.range_sigma:
for theta in args.range_theta:
model = (d, sigma, theta)
models.append(model)
listParams = list()
for model in models:
listParams.append(
(model[0], model[1], model[2], trialConditions,
args.num_simulations, histBins, dataHistLeft, dataHistRight,
probLeftFixFirst, distLatencies, distTransitions, distFixations))
likelihoods = pool.map(get_model_likelihood_wrapper, listParams)
if args.verbose:
for i in xrange(len(models)):
print("L" + str(models[i]) + " = " + str(likelihoods[i]))
bestIndex = likelihoods.index(max(likelihoods))
print("Best fit: " + str(models[bestIndex]))
nargs='?',
default=1.0)
parser.add_argument('-ep', '--epoch', type=int, nargs='?', default=10)
parser.add_argument('-wn', '--word_ngrams', type=int, nargs='?', default=1)
parser.add_argument('-mc', '--min_count', type=int, nargs='?', default=1)
args = parser.parse_args()
model_name = args.model_name
learning_rate = args.learning_rate
epoch = args.epoch
word_ngrams = args.word_ngrams
min_count = args.min_count
# load train data
logger.info("start load load")
train_data_df = load_data_from_csv(config.train_data_path)
validate_data_df = load_data_from_csv(config.validate_data_path)
content_train = train_data_df.iloc[:, 1]
logger.info("start seg train data")
content_train = seg_words(content_train)
logger.info("complete seg train data")
logger.info("prepare train format")
train_data_format = np.asarray([content_train]).T
logger.info("complete formate train data")
columns = train_data_df.columns.values.tolist()
# model train
def main():
parser = argparse.ArgumentParser()
parser.add_argument("subject", type=str, help="Subject name.")
parser.add_argument("--num-threads",
type=int,
default=9,
help="Size of the thread pool.")
parser.add_argument(
"--num-trials",
type=int,
default=200,
help="Number of artificial data trials to be generated "
"per trial condition.")
parser.add_argument("--d",
type=float,
default=0.006,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--sigma",
type=float,
default=0.08,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--theta",
type=float,
default=0.5,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--range-d",
nargs="+",
type=float,
default=[0.005, 0.006, 0.007],
help="Search range for parameter d.")
parser.add_argument("--range-sigma",
nargs="+",
type=float,
default=[0.065, 0.08, 0.095],
help="Search range for parameter sigma.")
parser.add_argument("--range-theta",
nargs="+",
type=float,
default=[0.4, 0.5, 0.6],
help="Search range for parameter theta.")
parser.add_argument("--expdata-file-name",
type=str,
default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name",
type=str,
default="fixations.csv",
help="Name of fixations file.")
parser.add_argument("--verbose",
default=False,
action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
pool = Pool(args.num_threads)
valueLeft = dict()
valueRight = dict()
fixItem = dict()
fixTime = dict()
# Load experimental data from CSV file.
try:
data = load_data_from_csv(args.expdata_file_name,
args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
valueLeft[args.subject] = data.valueLeft[args.subject]
valueRight[args.subject] = data.valueRight[args.subject]
fixItem[args.subject] = data.fixItem[args.subject]
fixTime[args.subject] = data.fixTime[args.subject]
# Get empirical distributions.
try:
dists = get_empirical_distributions(valueLeft, valueRight, fixItem,
fixTime)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
# Trial conditions for artificial data generation.
orientations = range(-15, 20, 5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Generate artificial data.
if args.verbose:
print("Running simulations...")
try:
simul = run_simulations(probLeftFixFirst,
distLatencies,
distTransitions,
distFixations,
args.num_trials,
trialConditions,
args.d,
args.theta,
sigma=args.sigma)
except Exception as e:
print("An exception occurred while generating artificial data: " +
str(e))
return
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
# Grid search to recover the parameters.
if args.verbose:
print("Starting grid search...")
numModels = (len(args.range_d) * len(args.range_theta) *
len(args.range_sigma))
models = list()
posteriors = dict()
for d in args.range_d:
for theta in args.range_theta:
for sigma in args.range_sigma:
model = (d, theta, sigma)
models.append(model)
posteriors[model] = 1. / numModels
trials = simulChoice.keys()
for trial in trials:
listParams = list()
for model in models:
listParams.append(
(simulChoice[trial], simulValueLeft[trial],
simulValueRight[trial], simulFixItem[trial],
simulFixTime[trial], model[0], model[1], model[2]))
try:
likelihoods = pool.map(get_trial_likelihood_wrapper, listParams)
except Exception as e:
print(
"An exception occurred during the likelihood computation for "
"trial " + str(trial) + ": " + str(e))
return
# Get the denominator for normalizing the posteriors.
i = 0
denominator = 0
for model in models:
denominator += posteriors[model] * likelihoods[i]
i += 1
if denominator == 0:
continue
# Calculate the posteriors after this trial.
i = 0
for model in models:
prior = posteriors[model]
posteriors[model] = likelihoods[i] * prior / denominator
i += 1
if args.verbose and trial % 200 == 0:
for model in posteriors:
print("P" + str(model) + " = " + str(posteriors[model]))
print("Sum: " + str(sum(posteriors.values())))
if args.verbose:
for model in posteriors:
print("P" + str(model) + " = " + str(posteriors[model]))
print("Sum: " + str(sum(posteriors.values())))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--num-threads",
type=int,
default=9,
help="Size of the thread pool.")
parser.add_argument(
"--trials-per-subject",
type=int,
default=100,
help="Number of trials from each subject to be used in "
"the analysis; if smaller than 1, all trials are used.")
parser.add_argument("--pop-size",
type=int,
default=18,
help="Number of individuals in each population.")
parser.add_argument("--num-generations",
type=int,
default=20,
help="Number of generations.")
parser.add_argument("--crossover-rate",
type=float,
default=0.5,
help="Crossover rate.")
parser.add_argument("--mutation-rate",
type=float,
default=0.3,
help="Mutation rate.")
parser.add_argument("--lower-bound-d",
type=float,
default=0.0001,
help="Lower search bound for parameter d.")
parser.add_argument("--upper-bound-d",
type=float,
default=0.01,
help="Upper search bound for parameter d.")
parser.add_argument("--lower-bound-theta",
type=float,
default=0,
help="Lower search bound for parameter theta.")
parser.add_argument("--upper-bound-theta",
type=float,
default=1,
help="Upper search bound for parameter theta.")
parser.add_argument("--lower-bound-sigma",
type=float,
default=0.001,
help="Lower search bound for parameter sigma.")
parser.add_argument("--upper-bound-sigma",
type=float,
default=0.1,
help="Upper search bound for parameter sigma.")
parser.add_argument("--expdata-file-name",
type=str,
default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name",
type=str,
default="fixations.csv",
help="Name of fixations file.")
args = parser.parse_args()
global choice
global valueLeft
global valueRight
global fixItem
global fixTime
global trialsPerSubject
# Load experimental data from CSV file and update global variables.
try:
data = load_data_from_csv(args.expdata_file_name,
args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
choice = data.choice
valueLeft = data.valueLeft
valueRight = data.valueRight
fixItem = data.fixItem
fixTime = data.fixTime
trialsPerSubject = args.trials_per_subject
creator.create("FitnessMin", base.Fitness, weights=(-1.0, ))
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox = base.Toolbox()
# Create thread pool.
pool = Pool(args.num_threads)
toolbox.register("map", pool.map)
# Create individual.
toolbox.register("attr_d", random.uniform, args.lower_bound_d,
args.upper_bound_d)
toolbox.register("attr_theta", random.uniform, args.lower_bound_theta,
args.upper_bound_theta)
toolbox.register("attr_sigma", random.uniform, args.lower_bound_sigma,
args.upper_bound_sigma)
toolbox.register("individual",
tools.initCycle,
creator.Individual,
(toolbox.attr_d, toolbox.attr_theta, toolbox.attr_sigma),
n=1)
# Create population.
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
pop = toolbox.population(n=args.pop_size)
# Create operators.
toolbox.register("mate", tools.cxUniform, indpb=0.4)
toolbox.register("mutate",
tools.mutGaussian,
mu=0,
sigma=[0.0005, 0.05, 0.005],
indpb=0.4)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", evaluate)
# Evaluate the entire population.
try:
fitnesses = toolbox.map(toolbox.evaluate, pop)
except:
print(
"An exception occurred during the first population evaluation: " +
str(e))
return
bestFit = sys.float_info.max
bestInd = None
for ind, fit in zip(pop, fitnesses):
ind.fitness.values = fit
# Get best individual.
if fit < bestFit:
bestInd = ind
for g in xrange(args.num_generations):
print("Generation " + str(g) + "...")
# Select the next generation individuals.
offspring = toolbox.select(pop, len(pop))
# Clone the selected individuals.
offspring = map(toolbox.clone, offspring)
# Apply crossover and mutation on the offspring.
for child1, child2 in zip(offspring[::2], offspring[1::2]):
if random.random() < args.crossover_rate:
toolbox.mate(child1, child2)
del child1.fitness.values
del child2.fitness.values
for mutant in offspring:
if random.random() < args.mutation_rate:
toolbox.mutate(mutant)
del mutant.fitness.values
# Evaluate the individuals which are valid but have an invalid fitness.
invalidInd = list()
for ind in offspring:
if (ind[0] < args.lower_bound_d or ind[0] > args.upper_bound_d
or ind[1] < args.lower_bound_theta
or ind[1] > args.upper_bound_theta
or ind[2] < args.lower_bound_sigma
or ind[2] > args.upper_bound_sigma):
ind.fitness.values = sys.float_info.max,
elif not ind.fitness.valid:
invalidInd.append(ind)
try:
fitnesses = map(toolbox.evaluate, invalidInd)
except:
print("An exception occurred during the population evaluation " +
"for generation " + str(g) + ": " + str(e))
return
for ind, fit in zip(invalidInd, fitnesses):
ind.fitness.values = fit
# The population is entirely replaced by the offspring.
pop[:] = offspring
# Update best individual.
for ind in pop:
if ind.fitness.values[0] < bestFit:
bestFit = ind.fitness.values[0]
bestInd = ind
print("Best individual: " + str(bestInd))
print("Fitness of best individual: " + str(bestFit))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--trials-per-subject", type=int, default=100,
help="Number of trials from each subject to be used in "
"the analysis; if smaller than 1, all trials are used.")
parser.add_argument("--num-iterations", type=int, default=100,
help="Number of basin hopping iterations.")
parser.add_argument("--step-size", type=float, default=0.001,
help="Step size for use in the random displacement of "
"the basin hopping algorithm.")
parser.add_argument("--initial-d", type=float, default=0.005,
help="Initial value for parameter d.")
parser.add_argument("--initial-theta", type=float, default=0.5,
help="Initial value for parameter theta.")
parser.add_argument("--initial-sigma", type=float, default=0.05,
help="Initial value for parameter sigma.")
parser.add_argument("--lower-bound-d", type=float, default=0.0001,
help="Lower search bound for parameter d.")
parser.add_argument("--upper-bound-d", type=float, default=0.01,
help="Upper search bound for parameter d.")
parser.add_argument("--lower-bound-theta", type=float, default=0,
help="Lower search bound for parameter theta.")
parser.add_argument("--upper-bound-theta", type=float, default=1,
help="Upper search bound for parameter theta.")
parser.add_argument("--lower-bound-sigma", type=float, default=0.001,
help="Lower search bound for parameter sigma.")
parser.add_argument("--upper-bound-sigma", type=float, default=0.1,
help="Upper search bound for parameter sigma.")
parser.add_argument("--expdata-file-name", type=str, default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name", type=str,
default="fixations.csv", help="Name of fixations file.")
args = parser.parse_args()
global choice
global valueLeft
global valueRight
global fixItem
global fixTime
global trialsPerSubject
# Load experimental data from CSV file and update global variables.
try:
data = load_data_from_csv(
args.expdata_file_name, args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
choice = data.choice
valueLeft = data.valueLeft
valueRight = data.valueRight
fixItem = data.fixItem
fixTime = data.fixTime
trialsPerSubject = args.trials_per_subject
# Initial guess for the parameters: d, theta, sigma.
initialParams = [args.initial_d, args.initial_theta, args.initial_sigma]
# Search bounds.
bounds = [(args.lower_bound_d, args.upper_bound_d),
(args.lower_bound_theta, args.upper_bound_theta),
(args.lower_bound_sigma, args.upper_bound_sigma)
]
# Optimize using Basinhopping algorithm.
minimizerKwargs = dict(method="L-BFGS-B", bounds=bounds)
try:
result = basinhopping(
get_model_nll, initialParams, minimizer_kwargs=minimizerKwargs,
niter=args.num_iterations,stepsize=args.step_size)
except Exception as e:
print("An exception occurred during the basinhopping optimization: " +
str(e))
return
print("Optimization result: " + str(result))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("subject", type=str, help="Subject name")
parser.add_argument("--num-threads",
type=int,
default=9,
help="Size of the thread pool.")
parser.add_argument("--num-trials",
type=int,
default=100,
help="Number of trials to be used in the analysis; if "
"smaller than 1, all trials are used.")
parser.add_argument("--num-simulations",
type=int,
default=32,
help="Number of simulations to be generated per trial "
"condition.")
parser.add_argument("--range-d",
nargs="+",
type=float,
default=[0.003, 0.006, 0.009],
help="Search range for parameter d.")
parser.add_argument("--range-sigma",
nargs="+",
type=float,
default=[0.03, 0.06, 0.09],
help="Search range for parameter sigma.")
parser.add_argument("--range-theta",
nargs="+",
type=float,
default=[0.3, 0.5, 0.7],
help="Search range for parameter theta.")
parser.add_argument("--expdata-file-name",
type=str,
default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name",
type=str,
default="fixations.csv",
help="Name of fixations file.")
parser.add_argument("--save-simulations",
default=False,
action="store_true",
help="Save simulations to CSV.")
parser.add_argument("--save-figures",
default=False,
action="store_true",
help="Save figures comparing "
"choice and RT curves for data and simulations.")
parser.add_argument("--verbose",
default=False,
action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
pool = Pool(args.num_threads)
choice = dict()
valueLeft = dict()
valueRight = dict()
fixItem = dict()
fixTime = dict()
# Load experimental data from CSV file.
try:
data = load_data_from_csv(args.expdata_file_name,
args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
choice[args.subject] = data.choice[args.subject]
valueLeft[args.subject] = data.valueLeft[args.subject]
valueRight[args.subject] = data.valueRight[args.subject]
fixItem[args.subject] = data.fixItem[args.subject]
fixTime[args.subject] = data.fixTime[args.subject]
# Maximum likelihood estimation using odd trials only.
# Grid search on the parameters of the model.
if args.verbose:
print("Starting grid search for subject " + args.subject + "...")
models = list()
listParams = list()
for d in args.range_d:
for theta in args.range_theta:
for sigma in args.range_sigma:
models.append((d, theta, sigma))
params = (choice, valueLeft, valueRight, fixItem, fixTime, d,
theta, sigma, args.num_trials, True, False,
args.verbose)
listParams.append(params)
results = pool.map(get_model_nll_wrapper, listParams)
# Get optimal parameters.
minNegLogLikeIdx = results.index(min(results))
optimD = models[minNegLogLikeIdx][0]
optimTheta = models[minNegLogLikeIdx][1]
optimSigma = models[minNegLogLikeIdx][2]
if args.verbose:
print("Finished grid search!")
print("Optimal d: " + str(optimD))
print("Optimal theta: " + str(optimTheta))
print("Optimal sigma: " + str(optimSigma))
print("Min NLL: " + str(min(results)))
# Get empirical distributions from even trials.
try:
dists = get_empirical_distributions(valueLeft,
valueRight,
fixItem,
fixTime,
useOddTrials=False,
useEvenTrials=True)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
# Trial conditions for generating simulations.
orientations = range(-15, 20, 5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Generate simulations using the even trials distributions and the
# estimated parameters.
try:
simul = run_simulations(probLeftFixFirst,
distLatencies,
distTransitions,
distFixations,
args.num_simulations,
trialConditions,
optimD,
optimTheta,
sigma=optimSigma)
except Exception as e:
print("An exception occurred while running simulations: " + str(e))
return
simulRT = simul.RT
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
simulFixRDV = simul.fixRDV
totalTrials = args.num_simulations * len(trialConditions)
if args.save_simulations:
save_simulations_to_csv(simulChoice, simulRT, simulValueLeft,
simulValueRight, simulFixItem, simulFixTime,
simulFixRDV, totalTrials)
if args.save_figures:
# Create pdf file to save figures.
pp = PdfPages("figures_" + str(optimD) + "_" + str(optimTheta) + "_" +
str(optimSigma) + "_" + str(args.num_simulations) +
".pdf")
# Generate choice and RT curves for real data (odd trials) and
# simulations (generated from even trials).
fig1 = generate_choice_curves(choice, valueLeft, valueRight,
simulChoice, simulValueLeft,
simulValueRight, totalTrials)
pp.savefig(fig1)
fig2 = generate_rt_curves(RT, valueLeft, valueRight, simulRT,
simulValueLeft, simulValueRight, totalTrials)
pp.savefig(fig2)
pp.close()
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--trials-per-subject",
type=int,
default=100,
help="Number of trials from each subject to be used in "
"the analysis; if smaller than 1, all trials are used.")
parser.add_argument("--num-iterations",
type=int,
default=100,
help="Number of basin hopping iterations.")
parser.add_argument("--step-size",
type=float,
default=0.001,
help="Step size for use in the random displacement of "
"the basin hopping algorithm.")
parser.add_argument("--initial-d",
type=float,
default=0.005,
help="Initial value for parameter d.")
parser.add_argument("--initial-theta",
type=float,
default=0.5,
help="Initial value for parameter theta.")
parser.add_argument("--initial-sigma",
type=float,
default=0.05,
help="Initial value for parameter sigma.")
parser.add_argument("--lower-bound-d",
type=float,
default=0.0001,
help="Lower search bound for parameter d.")
parser.add_argument("--upper-bound-d",
type=float,
default=0.01,
help="Upper search bound for parameter d.")
parser.add_argument("--lower-bound-theta",
type=float,
default=0,
help="Lower search bound for parameter theta.")
parser.add_argument("--upper-bound-theta",
type=float,
default=1,
help="Upper search bound for parameter theta.")
parser.add_argument("--lower-bound-sigma",
type=float,
default=0.001,
help="Lower search bound for parameter sigma.")
parser.add_argument("--upper-bound-sigma",
type=float,
default=0.1,
help="Upper search bound for parameter sigma.")
parser.add_argument("--expdata-file-name",
type=str,
default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name",
type=str,
default="fixations.csv",
help="Name of fixations file.")
args = parser.parse_args()
global choice
global valueLeft
global valueRight
global fixItem
global fixTime
global trialsPerSubject
# Load experimental data from CSV file and update global variables.
try:
data = load_data_from_csv(args.expdata_file_name,
args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
choice = data.choice
valueLeft = data.valueLeft
valueRight = data.valueRight
fixItem = data.fixItem
fixTime = data.fixTime
trialsPerSubject = args.trials_per_subject
# Initial guess for the parameters: d, theta, sigma.
initialParams = [args.initial_d, args.initial_theta, args.initial_sigma]
# Search bounds.
bounds = [(args.lower_bound_d, args.upper_bound_d),
(args.lower_bound_theta, args.upper_bound_theta),
(args.lower_bound_sigma, args.upper_bound_sigma)]
# Optimize using Basinhopping algorithm.
minimizerKwargs = dict(method="L-BFGS-B", bounds=bounds)
try:
result = basinhopping(get_model_nll,
initialParams,
minimizer_kwargs=minimizerKwargs,
niter=args.num_iterations,
stepsize=args.step_size)
except Exception as e:
print("An exception occurred during the basinhopping optimization: " +
str(e))
return
print("Optimization result: " + str(result))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--bin-step", type=int, default=10,
help="Size of the bin step to be used in the fixation "
"distributions.")
parser.add_argument("--max-fix-bin", type=int, default=3000,
help="Maximum fixation length to be used in the "
"fixation distributions.")
parser.add_argument("--num-fix-dists", type=int, default=3,
help="Number of fixation distributions.")
parser.add_argument("--num-iterations", type=int, default=3,
help="Number of iterations used to approximate the"
"true distributions.")
parser.add_argument("--num-simulations", type=int, default=400,
help="Number of simulations to be generated per trial "
"condition.")
parser.add_argument("--d", type=float, default=0.004,
help="aDDM parameter for generating simulations.")
parser.add_argument("--sigma", type=float, default=0.07,
help="aDDM parameter for generating simulations.")
parser.add_argument("--theta", type=float, default=0.25,
help="aDDM parameter for generating simulations.")
parser.add_argument("--expdata-file-name", type=str, default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name", type=str,
default="fixations.csv", help="Name of fixations file.")
parser.add_argument("--save-simulations", default=False,
action="store_true", help="Save simulations to CSV.")
parser.add_argument("--verbose", default=False, action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
# Time bins to be used in the fixation distributions.
bins = range(args.bin_step, args.max_fix_bin + args.bin_step, args.bin_step)
# Load experimental data from CSV file.
try:
data = load_data_from_csv(
args.expdata_file_name, args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
RT = data.RT
choice = data.choice
valueLeft = data.valueLeft
valueRight = data.valueRight
fixItem = data.fixItem
fixTime = data.fixTime
# Get empirical distributions from even trials.
try:
dists = get_empirical_distributions(
valueLeft, valueRight, fixItem, fixTime, useOddTrials=False,
useEvenTrials=True)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
# Trial conditions for generating simulations.
orientations = range(-15,20,5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Create original empirical distributions of fixations.
empiricalFixDist = dict()
for numFix in xrange(1, args.num_fix_dists + 1):
empiricalFixDist[numFix] = dict()
for valueDiff in xrange(-3,4):
empiricalFixDist[numFix][valueDiff] = dict()
for bin in bins:
empiricalFixDist[numFix][valueDiff][bin] = 0
for fixTime in distFixations[numFix][valueDiff]:
bin = args.bin_step * min((fixTime // args.bin_step) + 1,
len(bins))
empiricalFixDist[numFix][valueDiff][bin] += 1
# Normalize the distributions.
for numFix in xrange(1, args.num_fix_dists + 1):
for valueDiff in xrange(-3,4):
sumBins = sum(empiricalFixDist[numFix][valueDiff].values())
for bin in bins:
empiricalFixDist[numFix][valueDiff][bin] = (
float(empiricalFixDist[numFix][valueDiff][bin]) /
float(sumBins))
for it in xrange(args.num_iterations):
if args.verbose:
print("Iteration " + str(it + 1) + "/" + str(args.num_iterations))
# Generate simulations using the current empirical distributions and the
# model parameters.
try:
simul = run_simulations(
probLeftFixFirst, distLatencies, distTransitions,
empiricalFixDist, args.num_simulations, trialConditions, args.d,
args.theta, args.sigma, bins, args.num_fix_dists)
except Exception as e:
print("An exception occurred while running simulations in " +
"iteration " + str(it) + ": " + str(e))
return
simulRT = simul.RT
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
simulFixRDV = simul.fixRDV
simulUninterruptedLastFixTime = simul.uninterruptedLastFixTime
countLastFix = dict()
countTotal = dict()
for numFix in xrange(1, args.num_fix_dists + 1):
countLastFix[numFix] = dict()
countTotal[numFix] = dict()
for valueDiff in xrange(-3,4):
countLastFix[numFix][valueDiff] = dict()
countTotal[numFix][valueDiff] = dict()
for bin in bins:
countLastFix[numFix][valueDiff][bin] = 0
countTotal[numFix][valueDiff][bin] = 0
for trial in simulRT.keys():
# Count all item fixations, except last.
fixUnfixValueDiffs = {
1: simulValueLeft[trial] - simulValueRight[trial],
2: simulValueRight[trial] - simulValueLeft[trial]}
lastItemFixSkipped = False
lastFixItem = -1
numFix = 1
for item, time in zip(
simulFixItem[trial][::-1], simulFixTime[trial][::-1]):
if not lastItemFixSkipped and (item == 1 or item == 2):
lastFixItem = item
lastItemFixSkipped = True
continue
if item == 1 or item == 2:
bin = args.bin_step * min((time // args.bin_step) + 1,
len(bins))
vDiff = fixUnfixValueDiffs[item]
countTotal[numFix][vDiff][bin] += 1
if numFix < args.num_fix_dists:
numFix += 1
# Count last fixation.
vDiff = fixUnfixValueDiffs[lastFixItem]
bin = args.bin_step * min(
(simulUninterruptedLastFixTime[trial] // args.bin_step) + 1,
len(bins))
countLastFix[numFix][vDiff][bin] += 1
countTotal[numFix][vDiff][bin] += 1
# Obtain true distributions of fixations.
trueFixDist = dict()
for numFix in xrange(1, args.num_fix_dists + 1):
trueFixDist[numFix] = dict()
for valueDiff in xrange(-3,4):
trueFixDist[numFix][valueDiff] = dict()
for bin in bins:
probNotLastFix = 1
if countTotal[numFix][valueDiff][bin] > 0:
probNotLastFix = 1 - (
float(countLastFix[numFix][valueDiff][bin]) /
float(countTotal[numFix][valueDiff][bin]))
if probNotLastFix == 0:
trueFixDist[numFix][valueDiff][bin] = (
empiricalFixDist[numFix][valueDiff][bin])
else:
trueFixDist[numFix][valueDiff][bin] = (
float(empiricalFixDist[numFix][valueDiff][bin]) /
float(probNotLastFix))
# Normalize the distributions.
for numFix in xrange(1, args.num_fix_dists + 1):
for valueDiff in xrange(-3,4):
sumBins = sum(trueFixDist[numFix][valueDiff].values())
if sumBins > 0:
for bin in bins:
trueFixDist[numFix][valueDiff][bin] = (
float(trueFixDist[numFix][valueDiff][bin]) /
float(sumBins))
# Update empirical distributions using the current true distributions.
empiricalFixDist = trueFixDist
# Generate final simulations.
try:
simul = run_simulations(
probLeftFixFirst, distLatencies, distTransitions, empiricalFixDist,
args.num_simulations, trialConditions, args.d, args.theta,
args.sigma, bins, args.num_fix_dists)
except Exception as e:
print("An exception occurred while running the final " +
"simulations: " + str(e))
return
simulRT = simul.RT
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
simulFixRDV = simul.fixRDV
simulUninterruptedLastFixTime = simul.uninterruptedLastFixTime
if args.save_simulations:
totalTrials = args.num_simulations * len(trialConditions)
save_simulations_to_csv(
simulChoice, simulRT, simulValueLeft, simulValueRight, simulFixItem,
simulFixTime, simulFixRDV, totalTrials)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--num-threads",
type=int,
default=9,
help="Size of the thread pool.")
parser.add_argument(
"--num-trials",
type=int,
default=10,
help="Number of artificial data trials to be generated "
"per trial condition.")
parser.add_argument("--num-simulations",
type=int,
default=10,
help="Number of simulations to be generated per trial "
"condition, to be used in the RT histograms.")
parser.add_argument("--bin-step",
type=int,
default=100,
help="Size of the bin step to be used in the RT "
"histograms.")
parser.add_argument("--max-rt",
type=int,
default=8000,
help="Maximum RT to be used in the RT histograms.")
parser.add_argument("--d",
type=float,
default=0.006,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--sigma",
type=float,
default=0.08,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--theta",
type=float,
default=0.5,
help="aDDM parameter for generating artificial data.")
parser.add_argument("--range-d",
nargs="+",
type=float,
default=[0.005, 0.006, 0.007],
help="Search range for parameter d.")
parser.add_argument("--range-sigma",
nargs="+",
type=float,
default=[0.065, 0.08, 0.095],
help="Search range for parameter sigma.")
parser.add_argument("--range-theta",
nargs="+",
type=float,
default=[0.4, 0.5, 0.6],
help="Search range for parameter theta.")
parser.add_argument("--expdata-file-name",
type=str,
default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name",
type=str,
default="fixations.csv",
help="Name of fixations file.")
parser.add_argument("--verbose",
default=False,
action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
pool = Pool(args.num_threads)
# Load experimental data from CSV file.
try:
data = load_data_from_csv(args.expdata_file_name,
args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
# Get empirical distributions.
try:
dists = get_empirical_distributions(data.valueLeft, data.valueRight,
data.fixItem, data.fixTime)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
if args.verbose:
print("Done getting empirical distributions!")
histBins = range(0, args.max_rt + args.bin_step, args.bin_step)
orientations = range(-15, 20, 5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Generate histograms for artificial data.
dataHistLeft = dict()
dataHistRight = dict()
for trialCondition in trialConditions:
RTsLeft = list()
RTsRight = list()
trial = 0
while trial < args.num_trials:
try:
results = addm(probLeftFixFirst, distLatencies,
distTransitions, distFixations, args.d,
args.sigma, args.theta, trialCondition[0],
trialCondition[1])
except Exception as e:
print("An exception occurred while running the model for "
"artificial data generation, at trial " + str(trial) +
": " + str(e))
return
if results.choice == -1:
RTsLeft.append(results.RT)
elif results.choice == 1:
RTsRight.append(results.RT)
trial += 1
dataHistLeft[trialCondition] = np.histogram(RTsLeft, bins=histBins)[0]
dataHistRight[trialCondition] = np.histogram(RTsRight,
bins=histBins)[0]
if args.verbose:
print("Done generating histograms of artificial data!")
# Grid search on the parameters of the model.
models = list()
for d in args.range_d:
for sigma in args.range_sigma:
for theta in args.range_theta:
model = (d, sigma, theta)
models.append(model)
listParams = list()
for model in models:
listParams.append(
(model[0], model[1], model[2], trialConditions,
args.num_simulations, histBins, dataHistLeft, dataHistRight,
probLeftFixFirst, distLatencies, distTransitions, distFixations))
likelihoods = pool.map(get_model_likelihood_wrapper, listParams)
if args.verbose:
for i in xrange(len(models)):
print("L" + str(models[i]) + " = " + str(likelihoods[i]))
bestIndex = likelihoods.index(max(likelihoods))
print("Best fit: " + str(models[bestIndex]))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--num-threads", type=int, default=9,
help="Size of the thread pool.")
parser.add_argument("--trials-per-subject", type=int, default=100,
help="Number of trials from each subject to be used in "
"the analysis; if smaller than 1, all trials are used.")
parser.add_argument("--num-simulations", type=int, default=400,
help="Number of simulations to be generated per trial "
"condition.")
parser.add_argument("--range-d", nargs="+", type=float,
default=[0.003, 0.006, 0.009],
help="Search range for parameter d.")
parser.add_argument("--range-sigma", nargs="+", type=float,
default=[0.03, 0.06, 0.09],
help="Search range for parameter sigma.")
parser.add_argument("--range-theta", nargs="+", type=float,
default=[0.3, 0.5, 0.7],
help="Search range for parameter theta.")
parser.add_argument("--expdata-file-name", type=str, default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name", type=str,
default="fixations.csv", help="Name of fixations file.")
parser.add_argument("--use-cis-trials", default=False, action="store_true",
help="Use CIS trials in the analysis.")
parser.add_argument("--use-trans-trials", default=False,
action="store_true", help="Use TRANS trials in the "
"analysis.")
parser.add_argument("--save-simulations", default=False,
action="store_true", help="Save simulations to CSV.")
parser.add_argument("--verbose", default=False, action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
pool = Pool(args.num_threads)
# Load experimental data from CSV file.
try:
data = load_data_from_csv(
args.expdata_file_name, args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
choice = data.choice
valueLeft = data.valueLeft
valueRight = data.valueRight
fixItem = data.fixItem
fixTime = data.fixTime
isCisTrial = data.isCisTrial
isTransTrial = data.isTransTrial
# Maximum likelihood estimation.
# Grid search on the parameters of the model using odd trials only.
if args.verbose:
print("Starting grid search...")
models = list()
listParams = list()
for d in args.range_d:
for theta in args.range_theta:
for sigma in args.range_sigma:
models.append((d, theta, sigma))
params = (choice, valueLeft, valueRight, fixItem, fixTime, d,
theta, sigma, args.trials_per_subject, True, False,
isCisTrial, isTransTrial, args.use_cis_trials,
args.use_trans_trials, args.verbose)
listParams.append(params)
results = pool.map(get_model_nll_wrapper, listParams)
# Get optimal parameters.
minNegLogLikeIdx = results.index(min(results))
optimD = models[minNegLogLikeIdx][0]
optimTheta = models[minNegLogLikeIdx][1]
optimSigma = models[minNegLogLikeIdx][2]
if args.verbose:
print("Finished grid search!")
print("Optimal d: " + str(optimD))
print("Optimal theta: " + str(optimTheta))
print("Optimal sigma: " + str(optimSigma))
print("Min NLL: " + str(min(results)))
# Get empirical distributions from even trials only.
try:
dists = get_empirical_distributions(
valueLeft, valueRight, fixItem, fixTime, useOddTrials=False,
useEvenTrials=True, isCisTrial=isCisTrial,
isTransTrial=isTransTrial, useCisTrials=args.use_cis_trials,
useTransTrials=args.use_trans_trials)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
# Parameters for generating simulations.
orientations = range(-15,20,5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
if oLeft != oRight and args.use_cis_trials and oLeft * oRight >= 0:
trialConditions.append((vLeft, vRight))
elif (oLeft != oRight and args.use_trans_trials and
oLeft * oRight <= 0):
trialConditions.append((vLeft, vRight))
# Generate simulations using the empirical distributions and the
# estimated parameters.
try:
simul = run_simulations(
probLeftFixFirst, distLatencies, distTransitions, distFixations,
args.num_simulations, trialConditions, optimD, optimTheta,
sigma=optimSigma)
except Exception as e:
print("An exception occurred while running simulations: " + str(e))
return
simulRT = simul.RT
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
simulFixRDV = simul.fixRDV
if args.save_simulations:
totalTrials = args.num_simulations * len(trialConditions)
save_simulations_to_csv(
simulChoice, simulRT, simulValueLeft, simulValueRight, simulFixItem,
simulFixTime, simulFixRDV, totalTrials)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("subject", type=str, help="Subject name")
parser.add_argument("--num-threads", type=int, default=9,
help="Size of the thread pool.")
parser.add_argument("--num-trials", type=int, default=100,
help="Number of trials to be used in the analysis; if "
"smaller than 1, all trials are used.")
parser.add_argument("--num-simulations", type=int, default=32,
help="Number of simulations to be generated per trial "
"condition.")
parser.add_argument("--range-d", nargs="+", type=float,
default=[0.003, 0.006, 0.009],
help="Search range for parameter d.")
parser.add_argument("--range-sigma", nargs="+", type=float,
default=[0.03, 0.06, 0.09],
help="Search range for parameter sigma.")
parser.add_argument("--range-theta", nargs="+", type=float,
default=[0.3, 0.5, 0.7],
help="Search range for parameter theta.")
parser.add_argument("--expdata-file-name", type=str, default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name", type=str,
default="fixations.csv", help="Name of fixations file.")
parser.add_argument("--save-simulations", default=False,
action="store_true", help="Save simulations to CSV.")
parser.add_argument("--save-figures", default=False,
action="store_true", help="Save figures comparing "
"choice and RT curves for data and simulations.")
parser.add_argument("--verbose", default=False, action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
pool = Pool(args.num_threads)
choice = dict()
valueLeft = dict()
valueRight = dict()
fixItem = dict()
fixTime = dict()
# Load experimental data from CSV file.
try:
data = load_data_from_csv(
args.expdata_file_name, args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
choice[args.subject] = data.choice[args.subject]
valueLeft[args.subject] = data.valueLeft[args.subject]
valueRight[args.subject] = data.valueRight[args.subject]
fixItem[args.subject] = data.fixItem[args.subject]
fixTime[args.subject] = data.fixTime[args.subject]
# Maximum likelihood estimation using odd trials only.
# Grid search on the parameters of the model.
if args.verbose:
print("Starting grid search for subject " + args.subject + "...")
models = list()
listParams = list()
for d in args.range_d:
for theta in args.range_theta:
for sigma in args.range_sigma:
models.append((d, theta, sigma))
params = (choice, valueLeft, valueRight, fixItem, fixTime, d,
theta, sigma, args.num_trials, True, False,
args.verbose)
listParams.append(params)
results = pool.map(get_model_nll_wrapper, listParams)
# Get optimal parameters.
minNegLogLikeIdx = results.index(min(results))
optimD = models[minNegLogLikeIdx][0]
optimTheta = models[minNegLogLikeIdx][1]
optimSigma = models[minNegLogLikeIdx][2]
if args.verbose:
print("Finished grid search!")
print("Optimal d: " + str(optimD))
print("Optimal theta: " + str(optimTheta))
print("Optimal sigma: " + str(optimSigma))
print("Min NLL: " + str(min(results)))
# Get empirical distributions from even trials.
try:
dists = get_empirical_distributions(
valueLeft, valueRight, fixItem, fixTime, useOddTrials=False,
useEvenTrials=True)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
# Trial conditions for generating simulations.
orientations = range(-15,20,5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Generate simulations using the even trials distributions and the
# estimated parameters.
try:
simul = run_simulations(
probLeftFixFirst, distLatencies, distTransitions, distFixations,
args.num_simulations, trialConditions, optimD, optimTheta,
sigma=optimSigma)
except Exception as e:
print("An exception occurred while running simulations: " + str(e))
return
simulRT = simul.RT
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
simulFixRDV = simul.fixRDV
totalTrials = args.num_simulations * len(trialConditions)
if args.save_simulations:
save_simulations_to_csv(
simulChoice, simulRT, simulValueLeft, simulValueRight, simulFixItem,
simulFixTime, simulFixRDV, totalTrials)
if args.save_figures:
# Create pdf file to save figures.
pp = PdfPages(
"figures_" + str(optimD) + "_" + str(optimTheta) + "_" +
str(optimSigma) + "_" + str(args.num_simulations) + ".pdf")
# Generate choice and RT curves for real data (odd trials) and
# simulations (generated from even trials).
fig1 = generate_choice_curves(
choice, valueLeft, valueRight, simulChoice, simulValueLeft,
simulValueRight, totalTrials)
pp.savefig(fig1)
fig2 = generate_rt_curves(
RT, valueLeft, valueRight, simulRT, simulValueLeft, simulValueRight,
totalTrials)
pp.savefig(fig2)
pp.close()
logger = logging.getLogger(__name__)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('-mn', '--model_name', type=str, nargs='?',
default='fasttext_model.pkl',
help='the name of model')
args = parser.parse_args()
model_name = args.model_name
# load data
logger.info("start load load")
test_data_df = load_data_from_csv(config.test_data_path)
# load model
logger.info("start load model")
classifier_dict = joblib.load(config.model_path + model_name)
content_test = test_data_df['content']
logger.info("start seg train data")
content_test = seg_words(content_test)
logger.info("complete seg train data")
logger.info("prepare predict data format")
test_data_format = np.asarray([content_test]).T
logger.info("complete prepare predict formate data")
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--bin-step",
type=int,
default=10,
help="Size of the bin step to be used in the fixation "
"distributions.")
parser.add_argument("--max-fix-bin",
type=int,
default=3000,
help="Maximum fixation length to be used in the "
"fixation distributions.")
parser.add_argument("--num-fix-dists",
type=int,
default=3,
help="Number of fixation distributions.")
parser.add_argument("--num-iterations",
type=int,
default=3,
help="Number of iterations used to approximate the"
"true distributions.")
parser.add_argument("--num-simulations",
type=int,
default=400,
help="Number of simulations to be generated per trial "
"condition.")
parser.add_argument("--d",
type=float,
default=0.004,
help="aDDM parameter for generating simulations.")
parser.add_argument("--sigma",
type=float,
default=0.07,
help="aDDM parameter for generating simulations.")
parser.add_argument("--theta",
type=float,
default=0.25,
help="aDDM parameter for generating simulations.")
parser.add_argument("--expdata-file-name",
type=str,
default="expdata.csv",
help="Name of experimental data file.")
parser.add_argument("--fixations-file-name",
type=str,
default="fixations.csv",
help="Name of fixations file.")
parser.add_argument("--save-simulations",
default=False,
action="store_true",
help="Save simulations to CSV.")
parser.add_argument("--verbose",
default=False,
action="store_true",
help="Increase output verbosity.")
args = parser.parse_args()
# Time bins to be used in the fixation distributions.
bins = range(args.bin_step, args.max_fix_bin + args.bin_step,
args.bin_step)
# Load experimental data from CSV file.
try:
data = load_data_from_csv(args.expdata_file_name,
args.fixations_file_name,
useAngularDists=True)
except Exception as e:
print("An exception occurred while loading the data: " + str(e))
return
RT = data.RT
choice = data.choice
valueLeft = data.valueLeft
valueRight = data.valueRight
fixItem = data.fixItem
fixTime = data.fixTime
# Get empirical distributions from even trials.
try:
dists = get_empirical_distributions(valueLeft,
valueRight,
fixItem,
fixTime,
useOddTrials=False,
useEvenTrials=True)
except Exception as e:
print("An exception occurred while getting empirical distributions: " +
str(e))
return
probLeftFixFirst = dists.probLeftFixFirst
distLatencies = dists.distLatencies
distTransitions = dists.distTransitions
distFixations = dists.distFixations
# Trial conditions for generating simulations.
orientations = range(-15, 20, 5)
trialConditions = list()
for oLeft in orientations:
for oRight in orientations:
if oLeft != oRight:
vLeft = np.absolute((np.absolute(oLeft) - 15) / 5)
vRight = np.absolute((np.absolute(oRight) - 15) / 5)
trialConditions.append((vLeft, vRight))
# Create original empirical distributions of fixations.
empiricalFixDist = dict()
for numFix in xrange(1, args.num_fix_dists + 1):
empiricalFixDist[numFix] = dict()
for valueDiff in xrange(-3, 4):
empiricalFixDist[numFix][valueDiff] = dict()
for bin in bins:
empiricalFixDist[numFix][valueDiff][bin] = 0
for fixTime in distFixations[numFix][valueDiff]:
bin = args.bin_step * min(
(fixTime // args.bin_step) + 1, len(bins))
empiricalFixDist[numFix][valueDiff][bin] += 1
# Normalize the distributions.
for numFix in xrange(1, args.num_fix_dists + 1):
for valueDiff in xrange(-3, 4):
sumBins = sum(empiricalFixDist[numFix][valueDiff].values())
for bin in bins:
empiricalFixDist[numFix][valueDiff][bin] = (
float(empiricalFixDist[numFix][valueDiff][bin]) /
float(sumBins))
for it in xrange(args.num_iterations):
if args.verbose:
print("Iteration " + str(it + 1) + "/" + str(args.num_iterations))
# Generate simulations using the current empirical distributions and the
# model parameters.
try:
simul = run_simulations(probLeftFixFirst, distLatencies,
distTransitions, empiricalFixDist,
args.num_simulations, trialConditions,
args.d, args.theta, args.sigma, bins,
args.num_fix_dists)
except Exception as e:
print("An exception occurred while running simulations in " +
"iteration " + str(it) + ": " + str(e))
return
simulRT = simul.RT
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
simulFixRDV = simul.fixRDV
simulUninterruptedLastFixTime = simul.uninterruptedLastFixTime
countLastFix = dict()
countTotal = dict()
for numFix in xrange(1, args.num_fix_dists + 1):
countLastFix[numFix] = dict()
countTotal[numFix] = dict()
for valueDiff in xrange(-3, 4):
countLastFix[numFix][valueDiff] = dict()
countTotal[numFix][valueDiff] = dict()
for bin in bins:
countLastFix[numFix][valueDiff][bin] = 0
countTotal[numFix][valueDiff][bin] = 0
for trial in simulRT.keys():
# Count all item fixations, except last.
fixUnfixValueDiffs = {
1: simulValueLeft[trial] - simulValueRight[trial],
2: simulValueRight[trial] - simulValueLeft[trial]
}
lastItemFixSkipped = False
lastFixItem = -1
numFix = 1
for item, time in zip(simulFixItem[trial][::-1],
simulFixTime[trial][::-1]):
if not lastItemFixSkipped and (item == 1 or item == 2):
lastFixItem = item
lastItemFixSkipped = True
continue
if item == 1 or item == 2:
bin = args.bin_step * min(
(time // args.bin_step) + 1, len(bins))
vDiff = fixUnfixValueDiffs[item]
countTotal[numFix][vDiff][bin] += 1
if numFix < args.num_fix_dists:
numFix += 1
# Count last fixation.
vDiff = fixUnfixValueDiffs[lastFixItem]
bin = args.bin_step * min(
(simulUninterruptedLastFixTime[trial] // args.bin_step) + 1,
len(bins))
countLastFix[numFix][vDiff][bin] += 1
countTotal[numFix][vDiff][bin] += 1
# Obtain true distributions of fixations.
trueFixDist = dict()
for numFix in xrange(1, args.num_fix_dists + 1):
trueFixDist[numFix] = dict()
for valueDiff in xrange(-3, 4):
trueFixDist[numFix][valueDiff] = dict()
for bin in bins:
probNotLastFix = 1
if countTotal[numFix][valueDiff][bin] > 0:
probNotLastFix = 1 - (
float(countLastFix[numFix][valueDiff][bin]) /
float(countTotal[numFix][valueDiff][bin]))
if probNotLastFix == 0:
trueFixDist[numFix][valueDiff][bin] = (
empiricalFixDist[numFix][valueDiff][bin])
else:
trueFixDist[numFix][valueDiff][bin] = (
float(empiricalFixDist[numFix][valueDiff][bin]) /
float(probNotLastFix))
# Normalize the distributions.
for numFix in xrange(1, args.num_fix_dists + 1):
for valueDiff in xrange(-3, 4):
sumBins = sum(trueFixDist[numFix][valueDiff].values())
if sumBins > 0:
for bin in bins:
trueFixDist[numFix][valueDiff][bin] = (
float(trueFixDist[numFix][valueDiff][bin]) /
float(sumBins))
# Update empirical distributions using the current true distributions.
empiricalFixDist = trueFixDist
# Generate final simulations.
try:
simul = run_simulations(probLeftFixFirst, distLatencies,
distTransitions, empiricalFixDist,
args.num_simulations, trialConditions, args.d,
args.theta, args.sigma, bins,
args.num_fix_dists)
except Exception as e:
print("An exception occurred while running the final " +
"simulations: " + str(e))
return
simulRT = simul.RT
simulChoice = simul.choice
simulValueLeft = simul.valueLeft
simulValueRight = simul.valueRight
simulFixItem = simul.fixItem
simulFixTime = simul.fixTime
simulFixRDV = simul.fixRDV
simulUninterruptedLastFixTime = simul.uninterruptedLastFixTime
if args.save_simulations:
totalTrials = args.num_simulations * len(trialConditions)
save_simulations_to_csv(simulChoice, simulRT, simulValueLeft,
simulValueRight, simulFixItem, simulFixTime,
simulFixRDV, totalTrials)
