示例#1
0
    def _get(self, url):
        logging.debug('-->  GET: %s' % url)

        # fire it off
        res = requests.get(url)
        if not res.ok:
            logging.error("xx>  %s when getting %s: %s" %
                          (res.status_code, url, res.error))
            return []

        # decode JSON
        data = {}
        try:
            data = json.loads(res.content)
        except Exception as e:
            logging.error("-----\n%s\n-----\n%s\n-----" % (e, res.content))
            return []

        self.previousPageURI = data.get('previousPageURI')
        self.nextPageURI = data.get('nextPageURI')
        if self.nextPageURI:
            self.nextPageURI = self.nextPageURI.replace(
                ' ', '+')  # some queries come back with a space!
        self.totalCount = int(data.get('totalCount', 1))

        # instantiate Trial objects
        trials = []
        for tr in data.get('results', []):
            trial = Trial()
            trial.update_from_lilly(tr)
            trials.append(trial)

        return trials
示例#2
0
    def make_trial_set(self):
        self.trialSet = []
        all_pairs = list(
            itertools.product(self.sPlusOrientations, self.sMinusOrientations))
        for numSMinus in self.sMinusPresentations:
            for p in all_pairs:
                (sPlusOrientation, sMinusOrientation) = p
                if abs(sPlusOrientation - sMinusOrientation) < 0.001:
                    #make sure SPLUS and SMINUS are different
                    continue

                t = Trial()
                t.numSMinus = numSMinus
                t.sPlusOrientation = sPlusOrientation
                t.sMinusOrientation = sMinusOrientation

                self.trialSet.append(t)

        print str(len(self.trialSet)) + " different trial conditions."

        self.sequencer = Sequencer(self.trialSet, self.sequenceType)
        if self.sequenceType == Sequences.INTERVAL or self.sequenceType == Sequences.INTERVAL_RETRY:
            self.sequencer.sequencer.easyOris = self.easyOris
            self.sequencer.sequencer.hardOris = self.hardOris
            self.sequencer.sequencer.numEasy = self.numEasy
            self.sequencer.sequencer.numHard = self.numHard
示例#3
0
	def _get(self, url):
		logging.debug('-->  GET: %s' % url)
		
		# fire it off
		res = requests.get(url)
		if not res.ok:
			logging.error("xx>  %s when getting %s: %s" % (res.status_code, url, res.error))
			return []
		
		# decode JSON
		data = {}
		try:
			data = json.loads(res.content)
		except Exception as e:
			logging.error("-----\n%s\n-----\n%s\n-----" % (e, res.content))
			return []
		
		self.previousPageURI = data.get('previousPageURI')
		self.nextPageURI = data.get('nextPageURI')
		if self.nextPageURI:
			self.nextPageURI = self.nextPageURI.replace(' ', '+')	# some queries come back with a space!
		self.totalCount = int(data.get('totalCount', 1))
		
		# instantiate Trial objects
		trials = []
		for tr in data.get('results', []):
			trial = Trial()
			trial.update_from_lilly(tr)
			trials.append(trial)
		
		return trials
示例#4
0
 def move_to_next_trial(self):
     if self.current_trial_index is None:
         self.current_trial_index = 0
         rospy.logwarn(self.current_trial_index)
     else:
         del self.current_trial
         self.current_trial_index += 1
         rospy.logwarn(self.current_trial_index)
     trial_param = self.get_trial_params(self.current_trial_index)
     self.current_trial = Trial(self.elapsed_time, self.mean_angle,
                                trial_param, self.devices,
                                self.current_trial_index)
    def extract_trials(self):
        trials = []
        all_poke_idx, poke_times, all_withdraw_idx, withdraw_times, all_odor_idx, odor_times = self.get_trial_times(
        )

        # set up parameters
        self.total_bins_per_trial = int(
            (self.config.test.end_sec + self.config.train.window_size -
             self.config.test.start_sec) / self.config.original_bin_width)
        self.num_bins_per_spike_data = int(self.config.bin_width /
                                           self.config.original_bin_width)
        test_data_start_idx = range(
            self.total_bins_per_trial)[0::self.num_bins_per_spike_data]

        # for each trial, create a Trial instance
        for i in range(len(odor_times)):
            # get behaviorial data for current trial
            odor, position, in_seq, performance = self.get_behavior(
                all_odor_idx[i])
            # create instance of class Trial
            cur_trial = Trial(i + 1, poke_times[i], withdraw_times[i],
                              odor_times[i], odor, position, in_seq,
                              performance)

            # get start index and end index for a trial
            if self.config.onset_time:
                start_idx, end_idx = self.get_start_end_idx(
                    all_odor_idx[i], all_withdraw_idx[i],
                    self.config.original_bin_width, self.config.test.start_sec,
                    self.config.test.end_sec + self.config.train.window_size)
            else:
                start_idx, end_idx = self.get_start_end_idx(
                    all_poke_idx[i], all_withdraw_idx[i],
                    self.config.original_bin_width, self.config.test.start_sec,
                    self.config.test.end_sec + self.config.train.window_size)

            # get neural activity data (spike train and lfp) for current trial
            all_spikes_data, lfp_data = self.get_spikes_lfp_data(
                start_idx, end_idx)

            # save neural spike train data as a nested list
            cur_trial.spikes['all'] = self.get_test_data(
                test_data_start_idx, all_spikes_data,
                self.config.compress_data)

            trials.append(cur_trial)

        # save the trials data in a pickle file
        with open(self.config.test.trials_file, 'wb') as f:
            pickle.dump(trials, f)

        return trials
示例#6
0
def run_test(upper_len, incr, num_trials, func, is_c, safety_time=2):
    '''Returns multidimensional array of [[array_size, time],...]

    upper_len  - @type - int
               - @param - the longest array size that should be tested on
    incr       - @type - int
               - @param - increment the length of array for every set of trials
    num_trials - @type - int
               - @param - how many trials for every array length?
    func       - @type - function
               - @param - the function to run the trials on
    '''

    trials = []
    cur_len = 1
    int_bound = int(math.log(sys.maxint, 2))  #is C's longint, actually
    do_more = True
    while (cur_len <= upper_len and do_more):
        for i in range(num_trials):
            t = Trial()
            t.set_test_data(True, [], int, cur_len, int_bound)
            t.run_test(func, is_c)
            trials.append([cur_len, t.get_elapsed_time()])
            e_t = t.get_elapsed_time()
            # if it took more than safety_time, finish this set and stop
            if (e_t > safety_time):
                do_more = False
        cur_len += incr
    return trials
示例#7
0
 def next_task(self):
     if self.trial.is_end():
         if self.sentence_count == 6:
             self.sentence_count = 3
             chunk = self.stimuli.get_chunk(self.sentence_count)
             if chunk is None:
                 self.current_handler = ExperimentEndHandler(self.update, self.end_callback)
                 return
             else:
                 self.current_handler = BlockEndHandler(self.update, self.start_sentence_task)
             self.trial = Trial(chunk, self.stimuli.get_shuffled_groups())
             return
         else:
             self.sentence_count += 1
             self.trial = Trial(self.stimuli.get_chunk(self.sentence_count), self.stimuli.get_shuffled_groups())
     self.start_sentence_task()
示例#8
0
    def rank_image_cb(self, msg):
        logger.info(
            'Received message with {} compressed_imgs, {} imgs, {} strs'.
            format(len(msg.compressed_imgs), len(msg.imgs), len(msg.strs)))
        if self.trial and not self.trial.mode in (Trial.State.ABORTED,
                                                  Trial.State.COMPLETED):
            print('Aborting due to ongoing trial')
            self.action_server.set_aborted()
            return

        self.reset()

        if len(msg.compressed_imgs) > 0:
            self.screen.fill((255, 255, 255))
            self.screen.blit(
                self.font.render(
                    'Received {} images'.format(len(msg.compressed_imgs)), 1,
                    (0, 0, 0)), (40, self.size[1] / 2))
            pygame.display.flip()

            scaled_imgs = [
                ImageConverter.from_ros(img) for img in msg.compressed_imgs
            ]

            self.start_trial(
                Trial(zip(msg.option_ids, scaled_imgs),
                      size=self.size,
                      preview_time=4000,
                      image_time=self.PRESENTATION_DELAY))

            while self.ranking:
                pygame.time.wait(100)
        else:
            self.action_server.set_aborted()
def main():
    gridSize = 15
    bounds = [1, 1, gridSize - 2, gridSize - 2]
    minDistanceBetweenGrids = 5
    condition = [-5, -3, -1, 0, 1, 3, 5]
    counter = [0] * len(condition)
    initialWorld = InitialWorld(bounds)
    updateWorld = UpdateWorld(bounds, condition, counter)
    pg.init()
    screenWidth = 680
    screenHeight = 680
    screen = pg.display.set_mode((screenWidth, screenHeight))
    leaveEdgeSpace = 2
    lineWidth = 1
    backgroundColor = [205, 255, 204]
    lineColor = [0, 0, 0]
    targetColor = [255, 50, 50]
    playerColor = [50, 50, 255]
    targetRadius = 10
    playerRadius = 10
    stopwatchUnit = 100
    finishTime = 1000 * 30
    block = 1
    textColorTuple = (255, 50, 50)
    stopwatchEvent = pg.USEREVENT + 1
    pg.time.set_timer(stopwatchEvent, stopwatchUnit)
    pg.event.set_allowed([pg.KEYDOWN, pg.QUIT, stopwatchEvent])
    picturePath = os.path.abspath(os.path.join(os.getcwd(), os.pardir)) + '/Pictures/'
    resultsPath = os.path.abspath(os.path.join(os.getcwd(), os.pardir)) + '/Results/'
    experimentValues = co.OrderedDict()
    experimentValues["name"] = input("Please enter your name:").capitalize()
    experimentValues["condition"] = 'None'
    writerPath = resultsPath + experimentValues["name"] + '.csv'
    writer = WriteDataFrameToCSV(writerPath)
    introductionImage = pg.image.load(picturePath + 'introduction.png')
    restImage = pg.image.load(picturePath + 'rest.png')
    finishImage = pg.image.load(picturePath + 'finish.png')
    introductionImage = pg.transform.scale(introductionImage, (screenWidth, screenHeight))
    finishImage = pg.transform.scale(finishImage, (int(screenWidth * 2 / 3), int(screenHeight / 4)))
    drawBackground = DrawBackground(screen, gridSize, leaveEdgeSpace, backgroundColor, lineColor, lineWidth,
                                    textColorTuple)
    drawNewState = DrawNewState(screen, drawBackground, targetColor, playerColor, targetRadius, playerRadius)
    drawImage = DrawImage(screen)
    humanController = HumanController(gridSize, stopwatchEvent, stopwatchUnit, drawNewState, finishTime)
    trial = Trial(humanController, drawNewState, stopwatchEvent, finishTime)
    experiment = Experiment(trial, writer, experimentValues, initialWorld, updateWorld, drawImage, resultsPath,
                            minDistanceBetweenGrids)
    giveExperimentFeedback = GiveExperimentFeedback(screen, textColorTuple, screenWidth, screenHeight)
    drawImage(introductionImage)
    score = [0] * block
    for i in range(block):
        score[i] = experiment(finishTime)
        giveExperimentFeedback(i, score)
        if i == block - 1:
            drawImage(finishImage)
        else:
            drawImage(restImage)

    participantsScore = np.sum(np.array(score))
    print(participantsScore)
示例#10
0
 def __init__(self, db, update, end_callback, groups=None):
     self.db = db
     self.stimuli = Stimuli(groups)
     self.update = update
     self.sentence_count = 3
     self.trial = Trial(self.stimuli.get_chunk(self.sentence_count), self.stimuli.get_shuffled_groups())
     self.start_sentence_task()
     self.end_callback = end_callback
示例#11
0
def all_trials_main():
    # roughly 1 day of trails
    machines = [
        # "mlcnetA.cs.wpi.edu",
        # "mlcnetB.cs.wpi.edu",
        # "mlcnetC.cs.wpi.edu",
        "mlcnetD.cs.wpi.edu"
    ]
    protocols = [
        # "cubic",
        # "bbr",
        # "hybla",
        "pcc"
    ]

    dir = 'data/' + date.today().strftime("%Y-%m-%d")
    if not os.path.exists(dir):
        os.makedirs(dir)
    # roughly 24 hours
    for i in range(80):
        for machine, protocol in zip(machines, protocols):
            print(machine, protocol)
            title = f"{dir}/{machine}_{protocol}_{i}"
            trial = Trial(name=title, data="1G", remote=machine)
            trial.remote_tc(cc=protocol)
            trial.start()
示例#12
0
def load_trials(mat, session):
    if session is None:
        return []
    trials = []
    data = mat['dv']['exp'][0, 0]
    keys = ['dir', 'coh', 'durIdx', 'dur', 'tr', 'response', 'correct']
    data = [data[key][0, 0] for key in keys]
    data = [d.transpose()[0] if d.shape[0] > 1 else d[0] for d in data]
    for dirc, coh, durIdx, dur, tr, resp, crct in zip(*data):
        # for tr, coh, dirc, durIdx, dur, resp, crct in mat['D']:
        trial = Trial(session, tr, coh, dur, durIdx, dirc, resp,
                      True if crct == 1 else False)
        trials.append(trial)
    return trials
示例#13
0
def parse_trial(trial_path):
    with open(trial_path,'rb') as input_file:
        trial_result = json.load(input_file)
        generation_list = list()
        for gen in trial_result['generationalData']:
            individual_list = list()
            for indi in gen['individualList']:
                individual_list.append(
                    Individual(indi['UUID'], indi['parentUUID'], indi['switch'], indi['lightFirst'], indi['fitness']))

            generation_list.append(Generation(gen['generationNumber'], individual_list))

        trial = Trial(trial_result['config'], generation_list)
    return trial
示例#14
0
class TrialHandler():
    def __init__(self, db, update, end_callback, groups=None):
        self.db = db
        self.stimuli = Stimuli(groups)
        self.update = update
        self.sentence_count = 3
        self.trial = Trial(self.stimuli.get_chunk(self.sentence_count), self.stimuli.get_shuffled_groups())
        self.start_sentence_task()
        self.end_callback = end_callback

    def handle_keyboard(self, keycode):
        self.current_handler.handle_keyboard(keycode)

    def start_sentence_task(self):
        self.sentences, self.words = self.trial.get_one_group_data_from_chunk()
        self.current_handler = SentenceHandler(self.sentences, self.update, self.start_word_task)

    def start_word_task(self):
        self.current_handler = WordHandler(self.words, self.update, self.next_task, self.db)

    def next_task(self):
        if self.trial.is_end():
            if self.sentence_count == 6:
                self.sentence_count = 3
                chunk = self.stimuli.get_chunk(self.sentence_count)
                if chunk is None:
                    self.current_handler = ExperimentEndHandler(self.update, self.end_callback)
                    return
                else:
                    self.current_handler = BlockEndHandler(self.update, self.start_sentence_task)
                self.trial = Trial(chunk, self.stimuli.get_shuffled_groups())
                return
            else:
                self.sentence_count += 1
                self.trial = Trial(self.stimuli.get_chunk(self.sentence_count), self.stimuli.get_shuffled_groups())
        self.start_sentence_task()
示例#15
0
 def get_best_fit(self, n_try, test_size):
     best_trials = []
     for a in self.dh.actions:
         trials = []
         for i in range(n_try):
             a.split_train_test(test_size)
             a.scale_dataset()
             a.offline_train()
             print a.get_regression_score(), a.gmm.score(a.y_test)
             trials.append(
                 Trial(a, a.get_regression_score(), a.gmm.score(a.y_test)))
     #    print trials
         trials.sort(key=lambda t: t.cluster_score, reverse=True)
         best_trials.append(trials[0])
     return best_trials
示例#16
0
文件: pcc.py 项目: wDANDANw/Satellite
def main():
    dir = 'pcc'
    if not os.path.exists(dir):
        os.makedirs(dir)

    machine = "mlcnetD.cs.wpi.edu"
    protocol = "pcc"

    title = f"{dir}/{machine}_{protocol}"
    trial = Trial(name=title, data="1G", remote=machine)
    trial.remote_tc(cc=protocol)
    dir = trial.data_dir()

    trial.start()
示例#17
0
def window_sizes():
    dir = 'data/WINDOW_SIZES/' + date.today().strftime("%Y-%m-%d")
    if not os.path.exists(dir):
        os.makedirs(dir)
    # roughly 24 hours
    wmems = [
        int(BDP * 0.5),
        BDP * 1,
        BDP * 2,
        BDP * 4,
        BDP * 8,
        BDP * 16,
        65625000,
    ]
    for wmem in wmems:
        title = f"{dir}/{wmem}"
        trial = Trial(name=title, data="1G", remote='mlc1')
        trial.remote_tc(cc='cubic', win=wmem)
        trial.local_tc(cc='cubic', win=wmem)
        trial.start()
示例#18
0
def main(batch_size: int = Option(32, "-b"),
         G_lr: float = Option(0.01,
                              help="Learning rate for generator training"),
         D_lr: float = Option(0.01,
                              help="Learning rate for discriminator training"),
         GAN_G_lr: float = Option(
             0.00008, help="Learning rate for GAN generator training"),
         GAN_D_lr: float = Option(
             0.00016, help="Learning rate for GAN discriminator training"),
         G_epoch: int = Option(10, help="Iteration of generator training"),
         D_epoch: int = Option(3, help="Iteration of discriminator training"),
         GAN_epoch: int = Option(1, help="Iteration of GAN training"),
         itr: int = Option(1, help="Iteration of whole NOGAN training"),
         optim_type: str = Option("ADAB",
                                  help="Options of Optimizers for Generator"),
         level: str = Option("O1",
                             help="FP16 Training Flags, Refer to Apex Docs"),
         adv_weight: float = Option(1.0, help="Weight for discriminator loss"),
         load_dir: Optional[Path] = Option(None)):
    """
    NOGAN training Trial.
    """
    torch.backends.cudnn.benchmark = True
    assert (itr > 0), "Number must be bigger than 0"
    trial = Trial(batch_size=batch_size,
                  G_lr=G_lr,
                  D_lr=D_lr,
                  optim_type=optim_type,
                  level=level)
    decreased_lr = False
    if load_dir is not None:
        trial.load_trial(load_dir)
    for _ in range(itr):
        trial.Generator_NOGAN(
            epochs=G_epoch,
            content_weight=3.0,
            recon_weight=10.,
            loss=['content_loss', 'recon_loss'],
        )
        trial.Discriminator_NOGAN(epochs=D_epoch, adv_weight=adv_weight)
        trial.GAN_NOGAN(GAN_epoch,
                        GAN_G_lr=GAN_G_lr,
                        GAN_D_lr=GAN_D_lr,
                        adv_weight=adv_weight)
示例#19
0
def read_input_file(modo_inputs):
    input_list = []
    if modo_inputs == "prueba":
        input_file = open("pairAndResInputs.txt", "r")
    if modo_inputs == "biblia":
        input_file = open("pairAndResInputsBIBLIA.txt", "r")
    try:
        for line in input_file:
            # rstrip() para evitar que algun \n moleste
            prime, pairString, res = line.rstrip().split(" ")
            left, right = pairString.split(",")
            trial = Trial(prime, int(left), int(right),
                          res)  #res es una string porque a veces es una latra
            input_list.append(trial)
        input_file.close()
    except UnboundLocalError as error:
        print(error)
        print("\nRecordar debes: es prueba o biblia. Escribir bien debes.\n")
        sys.exit()

    return input_list
示例#20
0
    def __init__(self):

        self.current_trial = DummyTrial()
        self.current_trial_index = None

        rospy.init_node('virtual_desert')
        self.get_param()
        self.rate = rospy.Rate(self.param['update_rate'])

        self.lock = threading.Lock()
        self.start_time = rospy.get_time()

        self.angle_lowpass_filter = lowpass_filter.LowpassFilter(
            self.param['angle_lowpass_fcut'])
        self.angle_accumulator = angle_utils.AngleAccumulator()
        self.angle_fixer = angle_utils.AngleFixer()

        self.devices = {}
        self.devices['panels_controller'] = display_ctrl.LedController()
        self.devices['alicat_proxy'] = AlicatProxy()
        self.devices['autostep_proxy'] = AutostepProxy()
        self.devices['autostep_tracking_data_pub'] = rospy.Publisher(
            '/autostep/tracking_data', TrackingData, queue_size=10)
        self.devices['sunled_proxy'] = BasicLedStripProxy()

        self.initialize_panels_controller()
        self.initialize_autostep()
        self.rolling_circ_mean = RollingCircularMean(
            self.param['rolling_mean_size'])
        self.angle_data_sub = rospy.Subscriber('/angle_data', MsgAngleData,
                                               self.on_angle_data_callback)

        self.data_pub = rospy.Publisher('/virtual_desert_data',
                                        VirtualDesertData,
                                        queue_size=10)
        self.param_pub = rospy.Publisher('/virtual_desert_param',
                                         std_msgs.msg.String,
                                         queue_size=10)
示例#21
0
def all_trials_main():
    # roughly 1 day of trails
    machines = [
        #"mlcnetA.cs.wpi.edu",
        "mlcnetB.cs.wpi.edu"
        #"mlcnetC.cs.wpi.edu",
        # "mlcnetD.cs.wpi.edu"
    ]
    protocols = [
        #"cubic",
        "bbr"
        #"hybla",
        # "pcc"
    ]

    initcwnd = [
        # 3,
        # 5,
        #10,
        # 20,
        # 40,
        100,
        250
    ]

    dir = 'data/' + date.today().strftime("%Y-%m-%d")
    if not os.path.exists(dir):
        os.makedirs(dir)
    # roughly 24 hours

    for i in range(5):
        for j in initcwnd:
            for machine, protocol in zip(machines, protocols):
                print(machine, protocol)
                title = f"{dir}/{j}/{machine}_{protocol}_{i}"
                #            time.sleep(15)
                trial = Trial(name=title, data="128MB", remote=machine)
                # trial.mock()
                trial.remote_tc(cc=protocol, initcwnd=j)
                trial.start()
示例#22
0
# The same for positions
positions = []
try:
    while True:
        p = input('Enter number of shares to buy (Ctrl+D to end) ')
        try:
            positions.append(int(p))
        except ValueError as e:
            print(str(e))
except KeyboardInterrupt:
    print()
    sys.exit(1)
except EOFError:
    print()
    # Continue execution

if len(positions) == 0:
    print('No number of shares specified, exiting')
    sys.exit(2)

output_file = open('result.txt', 'w')

for p in positions:
    trial = Trial(p, num_trial)
    trial.plot('histogram_%04d_pos.pdf' % p)
    output_file.write(
            'Position %d: Mean %f, STD %f\n' % (p, trial.mean, trial.std)
            )

output_file.close()
示例#23
0
class VirtualDesert(object):

    Default_Param_File = 'virtual_desert_param.yaml'

    def __init__(self):

        self.current_trial = DummyTrial()
        self.current_trial_index = None

        rospy.init_node('virtual_desert')
        self.get_param()
        self.rate = rospy.Rate(self.param['update_rate'])

        self.lock = threading.Lock()
        self.start_time = rospy.get_time()

        self.angle_lowpass_filter = lowpass_filter.LowpassFilter(
            self.param['angle_lowpass_fcut'])
        self.angle_accumulator = angle_utils.AngleAccumulator()
        self.angle_fixer = angle_utils.AngleFixer()

        self.devices = {}
        self.devices['panels_controller'] = display_ctrl.LedController()
        self.devices['alicat_proxy'] = AlicatProxy()
        self.devices['autostep_proxy'] = AutostepProxy()
        self.devices['autostep_tracking_data_pub'] = rospy.Publisher(
            '/autostep/tracking_data', TrackingData, queue_size=10)
        self.devices['sunled_proxy'] = BasicLedStripProxy()

        self.initialize_panels_controller()
        self.initialize_autostep()
        self.rolling_circ_mean = RollingCircularMean(
            self.param['rolling_mean_size'])
        self.angle_data_sub = rospy.Subscriber('/angle_data', MsgAngleData,
                                               self.on_angle_data_callback)

        self.data_pub = rospy.Publisher('/virtual_desert_data',
                                        VirtualDesertData,
                                        queue_size=10)
        self.param_pub = rospy.Publisher('/virtual_desert_param',
                                         std_msgs.msg.String,
                                         queue_size=10)

    def initialize_panels_controller(self):
        # Wait until we have a subscriber connected or else message may be thrown away
        # It would be better if the panels controller used a service.
        while self.devices['panels_controller'].pub.get_num_connections() < 1:
            # May want to put a try counter on this and error out after some number of attempts
            rospy.sleep(0.1)
        self.devices['panels_controller'].set_config_id(
            self.param['panels_config_id'])
        self.devices['panels_controller'].stop()

    def shutdown_panels(self):
        self.devices['panels_controller'].stop()
        self.devices['panels_controller'].all_off()

    def initialize_autostep(self):
        # Set up known starting angle=0
        self.devices['autostep_proxy'].disable_tracking_mode()
        self.devices['autostep_proxy'].set_move_mode('jog')
        self.devices['autostep_proxy'].move_to(0.0)
        self.devices['autostep_proxy'].busy_wait()
        while self.devices['autostep_tracking_data_pub'].get_num_connections(
        ) < 1:
            # May want to put a try counter on this and error out after some number of attempts
            rospy.sleep(0.1)

    def shutdown_autostep(self):
        self.devices['autostep_proxy'].disable_tracking_mode()
        self.devices['autostep_proxy'].soft_stop()

    def get_param(self):
        self.param = rospy.get_param('/virtual_desert', None)
        if self.param is None:
            param_file_path = os.path.join(
                os.path.dirname(os.path.abspath(__file__)),
                self.Default_Param_File)
            with open(param_file_path, 'r') as f:
                self.param = yaml.load(f)

    @property
    def angle_dt(self):
        return 1.0 / self.param['angle_framerate']

    @property
    def elapsed_time(self):
        return rospy.get_time() - self.start_time

    @property
    def mean_angle(self):
        with self.lock:
            mean_angle = self.rolling_circ_mean.value()
        return mean_angle

    @property
    def angle(self):
        with self.lock:
            angle = self.angle_lowpass_filter.value
        return angle

    def on_angle_data_callback(self, data):
        with self.lock:
            self.rolling_circ_mean.insert_data(data.angle)
            angle_unwrapped = self.angle_accumulator.update(data.angle)
            angle_fixed = self.angle_fixer.fix_data(angle_unwrapped)
            self.angle_lowpass_filter.update(angle_fixed, self.angle_dt)

    def move_to_next_trial(self):
        if self.current_trial_index is None:
            self.current_trial_index = 0
            rospy.logwarn(self.current_trial_index)
        else:
            del self.current_trial
            self.current_trial_index += 1
            rospy.logwarn(self.current_trial_index)
        trial_param = self.get_trial_params(self.current_trial_index)
        self.current_trial = Trial(self.elapsed_time, self.mean_angle,
                                   trial_param, self.devices,
                                   self.current_trial_index)

    def get_trial_params(self, index):
        """ 
        Get parameters for trial set flow parameters to default and override
        where specified in trial 
        """
        trial_param = copy.deepcopy(self.param['trials'][index])
        param_name_list = ['flow', 'panels', 'sunled', 'autostep']
        for param_name in param_name_list:
            try:
                param = copy.deepcopy(
                    self.param['{}_default'.format(param_name)])
            except KeyError:
                param = {}
            if param is None:
                param = {}
            param.update(trial_param[param_name])
            trial_param[param_name] = param
        return trial_param

    def run(self):

        # Set to true to make sure parameters are in bag file
        if self.param['wait_for_param_sub']:
            while self.param_pub.get_num_connections() < 1:
                rospy.sleep(0.1)
        self.param_pub.publish(json.dumps(self.param))

        while not rospy.is_shutdown():
            elapsed_time = self.elapsed_time
            if elapsed_time > self.param['startup_delay']:
                if self.current_trial.is_done(elapsed_time):
                    try:
                        self.move_to_next_trial()
                    except IndexError:
                        break  # Done with trials -> exit loop
                trial_msg = self.current_trial.update(elapsed_time, self.angle)
                #print('t: {:0.2f}'.format(self.elapsed_time))
            else:
                print('pretrial delay, t={:0.2f}'.format(elapsed_time))
                trial_msg = TrialData()

            msg = VirtualDesertData()
            msg.header.stamp = rospy.Time.now()
            msg.angle = self.angle
            msg.elapsed_time = elapsed_time
            msg.current_trial_index = self.current_trial_index
            msg.trial_data = trial_msg
            self.data_pub.publish(msg)
            self.rate.sleep()

        self.shutdown_panels()
        self.shutdown_autostep()
    def _get_trials_data(self, session_nr, raw_spike_timestamps):
        """
        This method use the original experiment stimuli data set to extract the order and categories of the stimuli
        shown to each subjects. The label of the stimulus for the new old recognition task is also obtained using
        this method.
        :param session_nr: session number
        :param raw_spike_timestamps: raw_spike_timestamps from cell
        :return: a list of all trial objects
        """

        # Get data from variant stimuli data set
        block_id_recog = self.sessions[session_nr]['block_id_recog']
        block_id_learn = self.sessions[session_nr]['block_id_learn']
        variant = self.sessions[session_nr]['variant']
        filename = ''
        if variant == 1:
            filename = 'NewOldDelay_v3.mat'
            filename2 = 'NewOldDelayStimuli.mat'
        elif variant == 2:
            filename = 'NewOldDelay2_v3.mat'
            filename2 = 'NewOldDelayStimuli2.mat'
        elif variant == 3:
            filename = 'NewOldDelay3_v3.mat'
            filename2 = 'NewOldDelayStimuli3.mat'

        path_to_labels = os.path.join(self.path, 'stimFiles', filename)
        experiment_stimuli = loadmat(path_to_labels)['experimentStimuli']
        stimuli_recog_list = experiment_stimuli[0, block_id_recog - 1][3]
        new_old_recog_list = experiment_stimuli[0, block_id_recog - 1][4]
        stimuli_learn_list = experiment_stimuli[0, block_id_learn - 1][2]

        path_to_categories = os.path.join(self.path, 'stimFiles', filename2)
        category_mat = loadmat(path_to_categories)
        category_names = category_mat['categories']
        category_mapping = pd.DataFrame(category_mat['categoryMapping']).set_index(0)
        file_mapping = category_mat['fileMapping']

        # Get events and raw cell data

        events_recog = self._get_event_data(session_nr, experiment_type='recog')
        recog_events_time_points = self._extract_event_periods(events_recog)

        events_learn = self._get_event_data(session_nr, experiment_type='learn')
        learn_events_time_points = self._extract_event_periods(events_learn)

        # Get recog response from log file
        experiment_id_recog = self.sessions[session_nr]['experiment_id_recog']
        log_file_path = os.path.join(self._construct_data_path(session_nr, 'events'), 'newold'+str(experiment_id_recog)+'.txt')
        log_file = pd.read_csv(log_file_path, sep=';', header=None)
        log_events = np.asarray(log_file[1])
        recog_responses = log_events[(log_events >= 31)*(log_events <= 36)] - 30

        # Get learn response from log file
        experiment_id_learn = self.sessions[session_nr]['experiment_id_learn']
        log_file_path = os.path.join(self._construct_data_path(session_nr, 'events'), 'newold'+str(experiment_id_learn)+'.txt')
        log_file = pd.read_csv(log_file_path, sep=';', header=None)
        log_events = np.asarray(log_file[1])
        learn_responses = log_events[(log_events >= 20) * (log_events <= 21)] - 20

        # Create the trial list
        trials = []
        for i in range(0, 100):

            # Processing the recog phase

            baseline_offset = 1000000
            trial_start = recog_events_time_points['stimulus_on'][i] - baseline_offset
            trial_end = recog_events_time_points['trial_end'][i]
            trial_duration = trial_end - trial_start

            trial_timestamps_recog = raw_spike_timestamps[(raw_spike_timestamps > trial_start) *
                                     (raw_spike_timestamps <= trial_end)] - trial_start

            stimuli_recog_id = stimuli_recog_list[0][i]
            category_recog = category_mapping.loc[stimuli_recog_id, 1]

            category_name_recog = category_names[0, category_recog - 1][0]
            file_path = file_mapping[0][i][0].replace('C:\code\\', '')
            new_old_recog = new_old_recog_list[0][i]
            response_recog = recog_responses[i]

            # Processing the learning phase

            trial_start = learn_events_time_points['stimulus_on'][i] - baseline_offset
            trial_end = learn_events_time_points['trial_end'][i]
            trial_duration = trial_end - trial_start

            trial_timestamps_learn = raw_spike_timestamps[(raw_spike_timestamps > trial_start) *
                                     (raw_spike_timestamps <= trial_end)] - trial_start
            stimuli_learn_id = stimuli_learn_list[0][i]
            category_learn = category_mapping.loc[stimuli_learn_id, 1]

            category_name_learn = category_names[0, category_learn - 1][0]
            response_learn = learn_responses[i]

            # Creating this trial object
            trial = Trial(category_recog, category_name_recog, new_old_recog, response_recog, category_learn,
                          category_name_learn, response_learn, file_path, stimuli_recog_id, trial_timestamps_recog,
                          trial_timestamps_learn)
            trials.append(trial)

        return trials
示例#25
0
# The same for positions
positions = []
try:
    while True:
        p = input('Enter number of shares to buy (Ctrl+D to end) ')
        try:
            positions.append(int(p))
        except ValueError as e:
            print(str(e))
except KeyboardInterrupt:
    print()
    sys.exit(1)
except EOFError:
    print()
    # Continue execution

if len(positions) == 0:
    print('No number of shares specified, exiting')
    sys.exit(2)

output_file = open('result.txt', 'w')

for p in positions:
    trial = Trial(p, num_trial)
    trial.plot('histogram_%04d_pos.pdf' % p)
    output_file.write('Position %d: Mean %f, STD %f\n' %
                      (p, trial.mean, trial.std))

output_file.close()
示例#26
0
def Instruct(self, config, lang="E"):

    inst = Func(get_instructions, config).result

    # with If(practice==True):
    with Parallel():
        if not config.TOUCH:
            MouseCursor(blocking=False)
        with Serial(blocking=False):
            with Parallel():
                toplbl = Label(text=inst['top_text'],
                               markup=True,
                               halign='center',
                               center_x=self.exp.screen.center_x,
                               center_y=self.exp.screen.center_y,
                               font_size=s(config.INST_FONT_SIZE))

                # upper left
                Flanker(center_x=self.exp.screen.center_x - s(400),
                        center_y=toplbl.top + s(125),
                        sep=s(config.CONFIG_SEP),
                        df=s(config.CONFIG_DF),
                        line_width=s(config.LW),
                        stim="__<__\n_<<<_\n<<<<<\n_<<<_\n__<__\n")
                # upper middle
                Flanker(center_x=self.exp.screen.center_x,
                        center_y=toplbl.top + s(125),
                        sep=s(config.CONFIG_SEP),
                        df=s(config.CONFIG_DF),
                        line_width=s(config.LW),
                        stim="__>__\n_><>_\n><<<>\n_><>_\n__>__\n")
                # upper right
                Flanker(center_x=self.exp.screen.center_x + s(400),
                        center_y=toplbl.top + s(125),
                        sep=s(config.CONFIG_SEP),
                        df=s(config.CONFIG_DF),
                        line_width=s(config.LW),
                        stim="__<__\n_<><_\n<><><\n_<><_\n__<__\n")

                # lower left
                Flanker(center_x=self.exp.screen.center_x - s(400),
                        center_y=toplbl.bottom - s(125),
                        sep=s(config.CONFIG_SEP),
                        df=s(config.CONFIG_DF),
                        line_width=s(config.LW),
                        stim="__<__\n_<><_\n<><><\n_<><_\n__<__\n")
                # lower middle
                Flanker(center_x=self.exp.screen.center_x,
                        center_y=toplbl.bottom - s(125),
                        sep=s(config.CONFIG_SEP),
                        df=s(config.CONFIG_DF),
                        line_width=s(config.LW),
                        stim="__>__\n_><>_\n><><>\n_><>_\n__>__\n")
                # lower right
                Flanker(center_x=self.exp.screen.center_x + s(400),
                        center_y=toplbl.bottom - s(125),
                        sep=s(config.CONFIG_SEP),
                        df=s(config.CONFIG_DF),
                        line_width=s(config.LW),
                        stim="__<__\n_<><_\n<>>><\n_<><_\n__<__\n")

            with UntilDone():
                Wait(until=toplbl.appear_time)
                GetResponse(keys=config.CONT_KEY)

            Wait(1.0)

            with Loop(
                [["__<__\n_<<<_\n<<<<<\n_<<<_\n__<__\n", config.RESP_KEYS[0]],
                 ["__>__\n_><>_\n><<<>\n_><>_\n__>__\n", config.RESP_KEYS[0]],
                 ["__<__\n_<><_\n<>>><\n_<><_\n__<__\n", config.RESP_KEYS[-1]],
                 ["__>__\n_><>_\n><><>\n_><>_\n__>__\n",
                  config.RESP_KEYS[-1]]]) as prac_ev:
                Wait(1.0)
                p2 = Trial(config,
                           stim=prac_ev.current[0],
                           center_x=self.exp.screen.center_x,
                           center_y=self.exp.screen.center_y,
                           correct_resp=prac_ev.current[1],
                           condition='+')
                with If(p2.correct):
                    # They got it right
                    Label(text=u"\u2713",
                          color='green',
                          duration=config.FEEDBACK_TIME,
                          font_size=s(config.FEEDBACK_FONT_SIZE),
                          font_name='DejaVuSans.ttf')
                with Else():
                    # they got it wrong
                    Label(text=u"\u2717",
                          color='red',
                          font_size=s(config.FEEDBACK_FONT_SIZE),
                          duration=config.FEEDBACK_TIME,
                          font_name='DejaVuSans.ttf')

            with Meanwhile():
                with Parallel():
                    Ellipse(color='red', size=(s(55), s(55)))
                    Ellipse(color=config.INNER_CIRCLE_COLOR,
                            size=(s(45), s(45)))
                    Label(text=inst['inst_1'],
                          markup=True,
                          halign='center',
                          center_x=self.exp.screen.center_x,
                          center_y=self.exp.screen.center_y + s(300),
                          font_size=s(config.INST_FONT_SIZE))

            Wait(1.0)
            Label(text=inst['inst_2'],
                  markup=True,
                  halign='center',
                  center_x=self.exp.screen.center_x,
                  center_y=self.exp.screen.center_y + s(300),
                  font_size=s(config.INST_FONT_SIZE))
            with UntilDone():
                GetResponse(keys=config.CONT_KEY)

            with Loop([[
                    "__<__\n_<><_\n<>>><\n_<><_\n__<__\n", config.RESP_KEYS[1],
                    cos(radians((360. / config.NUM_LOCS) * 5)),
                    sin(radians((360. / config.NUM_LOCS) * 5))
            ],
                       [
                           "__<__\n_<><_\n<><><\n_<><_\n__<__\n",
                           config.RESP_KEYS[0],
                           cos(radians((360. / config.NUM_LOCS) * 1)),
                           sin(radians((360. / config.NUM_LOCS) * 1))
                       ],
                       [
                           "__>__\n_><>_\n><><>\n_><>_\n__>__\n",
                           config.RESP_KEYS[1],
                           cos(radians((360. / config.NUM_LOCS) * 3.)),
                           sin(radians((360. / config.NUM_LOCS) * 3.))
                       ],
                       [
                           "__>__\n_><>_\n><><>\n_><>_\n__>__\n",
                           config.RESP_KEYS[1],
                           cos(radians((360. / config.NUM_LOCS) * 4.)),
                           sin(radians((360. / config.NUM_LOCS) * 4.))
                       ],
                       [
                           "__>__\n_>>>_\n>>>>>\n_>>>_\n__>__\n",
                           config.RESP_KEYS[1],
                           cos(radians((360. / config.NUM_LOCS) * 0)),
                           sin(radians((360. / config.NUM_LOCS) * 0))
                       ],
                       [
                           "__>__\n_><>_\n><<<>\n_><>_\n__>__\n",
                           config.RESP_KEYS[0],
                           cos(radians((360. / config.NUM_LOCS) * 2)),
                           sin(radians((360. / config.NUM_LOCS) * 2))
                       ]]) as prac_ev:
                Wait(1.0)
                with Parallel():
                    Ellipse(color='red',
                            size=(s(55), s(55)),
                            center_x=self.exp.screen.center_x +
                            prac_ev.current[2] * s(config.FROM_CENTER),
                            center_y=self.exp.screen.center_y +
                            prac_ev.current[3] * s(config.FROM_CENTER),
                            blocking=False)
                    Ellipse(color=config.INNER_CIRCLE_COLOR,
                            size=(s(45), s(45)),
                            center_x=self.exp.screen.center_x +
                            prac_ev.current[2] * s(config.FROM_CENTER),
                            center_y=self.exp.screen.center_y +
                            prac_ev.current[3] * s(config.FROM_CENTER),
                            blocking=False)
                    p4 = Trial(config,
                               stim=prac_ev.current[0],
                               center_x=self.exp.screen.center_x +
                               prac_ev.current[2] * s(config.FROM_CENTER),
                               center_y=self.exp.screen.center_y +
                               prac_ev.current[3] * s(config.FROM_CENTER),
                               correct_resp=prac_ev.current[1],
                               condition='+')
                with If(p4.correct):
                    # They got it right
                    Label(text=u"\u2713",
                          color='green',
                          duration=config.FEEDBACK_TIME,
                          font_size=s(config.FEEDBACK_FONT_SIZE),
                          font_name='DejaVuSans.ttf')
                with Else():
                    # they got it wrong
                    Label(text=u"\u2717",
                          color='red',
                          font_size=s(config.FEEDBACK_FONT_SIZE),
                          duration=config.FEEDBACK_TIME,
                          font_name='DejaVuSans.ttf')

            Label(text=inst['to_cont'],
                  halign='center',
                  center_x=self.exp.screen.center_x,
                  center_y=self.exp.screen.center_y,
                  font_size=s(config.INST_FONT_SIZE))
            with UntilDone():
                GetResponse(keys=config.CONT_KEY)

            Wait(1.0)
            Label(text=inst['inst_3'],
                  markup=True,
                  halign='center',
                  center_x=self.exp.screen.center_x,
                  center_y=self.exp.screen.center_y + s(200),
                  font_size=s(config.INST_FONT_SIZE))
            with UntilDone():
                GetResponse(keys=config.CONT_KEY)

            with Loop([[
                    "__<__\n_<><_\n<>>><\n_<><_\n__<__\n", config.RESP_KEYS[1],
                    cos(radians((360. / config.NUM_LOCS) * 5)),
                    sin(radians((360. / config.NUM_LOCS) * 5))
            ],
                       [
                           "__<__\n_<><_\n<><><\n_<><_\n__<__\n",
                           config.RESP_KEYS[0],
                           cos(radians((360. / config.NUM_LOCS) * 1)),
                           sin(radians((360. / config.NUM_LOCS) * 1))
                       ],
                       [
                           "__>__\n_><>_\n><><>\n_><>_\n__>__",
                           config.RESP_KEYS[1],
                           cos(radians((360. / config.NUM_LOCS) * 3)),
                           sin(radians((360. / config.NUM_LOCS) * 3))
                       ],
                       [
                           "__>__\n_>>>_\n>>>>>\n_>>>_\n__>__\n",
                           config.RESP_KEYS[1],
                           cos(radians((360. / config.NUM_LOCS) * 6)),
                           sin(radians((360. / config.NUM_LOCS) * 6))
                       ],
                       [
                           "__>__\n_><>_\n><<<>\n_><>_\n__>__\n",
                           config.RESP_KEYS[0],
                           cos(radians((360. / config.NUM_LOCS) * 2)),
                           sin(radians((360. / config.NUM_LOCS) * 2))
                       ]]) as prac_ev:
                Wait(1.0)
                p5 = Trial(config,
                           stim=prac_ev.current[0],
                           center_x=self.exp.screen.center_x +
                           prac_ev.current[2] * s(config.FROM_CENTER),
                           center_y=self.exp.screen.center_y +
                           prac_ev.current[3] * s(config.FROM_CENTER),
                           correct_resp=prac_ev.current[1],
                           condition='+')

                with If(p5.correct):
                    # They got it right
                    Label(text=u"\u2713",
                          color='green',
                          duration=config.FEEDBACK_TIME,
                          font_size=s(config.FEEDBACK_FONT_SIZE),
                          center_y=self.exp.screen.center_y + s(50),
                          font_name='DejaVuSans.ttf')
                with Else():
                    # they got it wrong
                    Label(text=u"\u2717",
                          color='red',
                          font_size=s(config.FEEDBACK_FONT_SIZE),
                          center_y=self.exp.screen.center_y + s(50),
                          duration=config.FEEDBACK_TIME,
                          font_name='DejaVuSans.ttf')
            with Meanwhile():
                Label(text="+", font_size=s(config.ORIENT_FONT_SIZE))

        with Serial(blocking=False):
            with ButtonPress():
                Button(text=inst['skip_text'],
                       right=self.exp.screen.width,
                       bottom=0,
                       width=s(config.SKIP_SIZE[0]),
                       height=s(config.SKIP_SIZE[1]),
                       blocking=False,
                       font_size=s(config.SKIP_FONT_SIZE))

    Wait(1.0)

    Label(text=inst['done'],
          halign='center',
          center_x=self.exp.screen.center_x,
          center_y=self.exp.screen.center_y,
          font_size=s(config.INST_FONT_SIZE))
    with UntilDone():
        GetResponse(keys=config.CONT_KEY)
	def __init__(self, expparadigm, config, phrases, args):
		# TODO: add a 'question' argument
		debug("__init__")
		Trial.__init__(self, config, args['experiment'], args['item'], 
				args['condition'], args['mode'], 
				phrases, len(phrases)+1, question=None)
		if expparadigm == "MR-SAT":
			self.paradigm = "MR"	
		elif expparadigm == "SAT":
			self.paradigm = "SR"	
		else:	
			raise("Invalid experiment paradigm.")

		mode = args['mode']

		if not args.has_key('speededAcceptability'):
			args['speededAcceptability'] = False
		#if not args.has_key('lastFeedbackOffset'):
		#	args['lastFeedbackOffset'] = 0

		self.args = args

		self.displayPhrase = None
		self.lastPhraseRead = None
		self.lastResponseCorrect = None

		# create phrase chunks
		masked_phrases = []
		text_phrases  = []
		space = Text(text=" ", color=(0.0,0.0,0.0), position=(0,0),
    			     font_size=self.config.sprStimulusSize, anchor='left', 
			     on=0, font_name=self.config.font)
		space_size = space.parameters.size[0]

		# set initial word coordinates
		phrase_positions = []
		if mode == CPresentationMode.MovingWindow:
			x_pos = self.config.xPositionStart
			y_pos = globalScreen.size[1]/2
			anchor = "left"

		elif mode == CPresentationMode.Centered:
			x_pos = globalScreen.size[0]/2
			y_pos = globalScreen.size[1]/2
			anchor = "center"
		
		# create phrases
		self.sentence = ""
		for i in range(0, len(phrases)):
			if phrases[i] == "$":
				self.phraseSignalReference = i
				continue

			self.sentence = self.sentence +  " " + phrases[i]
			text = Text(text = phrases[i], color = (0.0,0.0,0.0),
          			position = (x_pos, y_pos),
    				font_size = self.config.sprStimulusSize,
  		     		anchor=anchor, on=0, font_name=self.config.font)

			if mode == CPresentationMode.MovingWindow:
				phrase_positions.append( (x_pos,y_pos) )
				x_pos = x_pos + text.parameters.size[0] + space_size

			text_phrases.append(text)
			# TODO: Fix y coordinates too. Necessary once the stimulus 
			#       becomes longer than one line.
		assert( hasattr(self, "phraseSignalReference"))
		self.sentence.strip()

		# create masks if the mode is moving window
		if mode == CPresentationMode.MovingWindow:
			for i in range(0, len(phrases)):
				text_size = text_phrases[i].parameters.size
				mask_size = (text_size[0], config.sprMaskHeight )
				mask_position = [ phrase_positions[i][0], 
						  phrase_positions[i][1] ]	
				mask_position[1] = mask_position[1]-(text_size[1]/2-mask_size[1]/2)

				phrase_mask = Target2D(color=(0.0,0.0,0.0),
						position=mask_position, 
						anchor='left',
						on=1, size=mask_size)

				masked_phrases.append(phrase_mask)

		self.screen = TrialScreenSAT(config, text_phrases, 
					  masked_phrases, mode, 
					  self.args['signalsCnt'],
					  self.args['feedbackIndicators'],
					  self.args['mappingIndicators'])

		if not self.args['speededAcceptability']:
			self.responses = [False]*self.args['signalsCnt']
		else:
			self.responses = [False]

		self._directionBeforeSignal = None
		self._directionAfterSignal = None
示例#28
0
    def do_experiment(self, targets, nontargets, slug):
        t = Trial(list(enumerate(targets + nontargets)),
                  size=self.size,
                  preview_time=4000,
                  image_time=self.PRESENTATION_DELAY)
        self.start_trial(t)
        accumulated_raw_results = []

        while self.running:
            self.clock.tick(self.FRAMERATE)
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.reset()
                    return
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        self.reset()
                        return
                    elif event.key == pygame.K_SPACE:
                        self.reset()
                        t = Trial(list(enumerate(targets + nontargets)),
                                  size=self.size,
                                  preview_time=4000,
                                  image_time=self.PRESENTATION_DELAY)
                        self.start_trial(t)
                elif event.type == self.EVENT_ID:
                    if self.trial:
                        pygame.time.set_timer(
                            self.EVENT_ID,
                            self.trial.show_next_image(self.screen, self.bci))
                        pygame.display.flip()

                        if self.trial.mode == Trial.State.COMPLETED:
                            self.bci and self.bci.end_block()

                            results = None
                            print('Trial completed')
                            logger.info('completed trial')
                            results = self.trial.process_results(
                                self.screen, self.bci)

                            if results:
                                self.action_server.set_succeeded(results)
                            else:
                                print('Trial insufficient')
                            pygame.display.flip()

                            logger.info('raw results:')
                            raw_results = sorted(self.trial.option_results,
                                                 key=lambda x: x.idx)
                            accumulated_raw_results.append(raw_results)
                            with open('data/{}.pickle'.format(slug), 'w') as f:
                                pickle.dump(accumulated_raw_results, f)
                            logger.info('\n'.join(map(str, raw_results)))
                            logger.info('processed results:')
                            logger.info(results)

                            self.ranking = False
                            self.trial = None

                            print('press space to run again')
                        elif self.trial.mode == Trial.State.ABORTED:
                            print('Trial aborted')
                            self.action_server.set_aborted()
                            self.ranking = False
                            self.trial = None
                            self.bci and self.bci.end_block()
                            self.reset()
示例#29
0
from trial import Trial, MyException
import json

trials = []

with open('../data.json') as json_data:
    d = json.load(json_data)

    for obj in d["data"]:

        try:
            t = Trial(obj)
        except MyException:
            continue 

        t.clean()
        trials.append(t)




done = []
done_obj = []
for t in trials:
    if t.participant_id not in done:
        done_obj.append(t)
        done.append(t.participant_id)
示例#30
0
    def __init__(self, expparadigm, config, phrases, args):
        # TODO: add a 'question' argument
        debug("__init__")
        Trial.__init__(self,
                       config,
                       args['experiment'],
                       args['item'],
                       args['condition'],
                       args['mode'],
                       phrases,
                       len(phrases) + 1,
                       question=None)
        if expparadigm == "MR-SAT":
            self.paradigm = "MR"
        elif expparadigm == "SAT":
            self.paradigm = "SR"
        else:
            raise ("Invalid experiment paradigm.")

        mode = args['mode']

        if not args.has_key('speededAcceptability'):
            args['speededAcceptability'] = False
        #if not args.has_key('lastFeedbackOffset'):
        #	args['lastFeedbackOffset'] = 0

        self.args = args

        self.displayPhrase = None
        self.lastPhraseRead = None
        self.lastResponseCorrect = None

        # create phrase chunks
        masked_phrases = []
        text_phrases = []
        space = Text(text=" ",
                     color=(0.0, 0.0, 0.0),
                     position=(0, 0),
                     font_size=self.config.sprStimulusSize,
                     anchor='left',
                     on=0,
                     font_name=self.config.font)
        space_size = space.parameters.size[0]

        # set initial word coordinates
        phrase_positions = []
        if mode == CPresentationMode.MovingWindow:
            x_pos = self.config.xPositionStart
            y_pos = globalScreen.size[1] / 2
            anchor = "left"

        elif mode == CPresentationMode.Centered:
            x_pos = globalScreen.size[0] / 2
            y_pos = globalScreen.size[1] / 2
            anchor = "center"

        # create phrases
        self.sentence = ""
        for i in range(0, len(phrases)):
            if phrases[i] == "$":
                self.phraseSignalReference = i
                continue

            self.sentence = self.sentence + " " + phrases[i]
            text = Text(text=phrases[i],
                        color=(0.0, 0.0, 0.0),
                        position=(x_pos, y_pos),
                        font_size=self.config.sprStimulusSize,
                        anchor=anchor,
                        on=0,
                        font_name=self.config.font)

            if mode == CPresentationMode.MovingWindow:
                phrase_positions.append((x_pos, y_pos))
                x_pos = x_pos + text.parameters.size[0] + space_size

            text_phrases.append(text)
            # TODO: Fix y coordinates too. Necessary once the stimulus
            #       becomes longer than one line.
        assert (hasattr(self, "phraseSignalReference"))
        self.sentence.strip()

        # create masks if the mode is moving window
        if mode == CPresentationMode.MovingWindow:
            for i in range(0, len(phrases)):
                text_size = text_phrases[i].parameters.size
                mask_size = (text_size[0], config.sprMaskHeight)
                mask_position = [
                    phrase_positions[i][0], phrase_positions[i][1]
                ]
                mask_position[1] = mask_position[1] - (text_size[1] / 2 -
                                                       mask_size[1] / 2)

                phrase_mask = Target2D(color=(0.0, 0.0, 0.0),
                                       position=mask_position,
                                       anchor='left',
                                       on=1,
                                       size=mask_size)

                masked_phrases.append(phrase_mask)

        self.screen = TrialScreenSAT(config, text_phrases, masked_phrases,
                                     mode, self.args['signalsCnt'],
                                     self.args['feedbackIndicators'],
                                     self.args['mappingIndicators'])

        if not self.args['speededAcceptability']:
            self.responses = [False] * self.args['signalsCnt']
        else:
            self.responses = [False]

        self._directionBeforeSignal = None
        self._directionAfterSignal = None
示例#31
0
    path = args.restore_path
    full_path = gen_full_path(subdir, path, unique=False)
    init_logger(full_path, args.debug)
    vae, agent, environment, params = restore_experiment(
        full_path, env_class, args)

trigger = params['env_params'].get('trigger')
if (trigger == 'None') or (trigger == ''):
    trigger = None
if trigger is not None:
    trigger_class = importlib.import_module(subdir + ".triggers")
    trigger = trigger_class.__dict__[trigger](
        params['env_params']['trigger_step'])

train = not params['test']
trial = Trial(full_path, vae, agent, environment, trigger)
try:
    update_step = params['concurrent_batches'] * params['train_step']
    trial.run(params['num_steps'], params['summary_step'], update_step, train,
              params['record'])
except Exception as e:
    logging.exception("Exception in trial.")
finally:
    try:
        trial.agent.lookup.table.shutdown()
        trial.model.exit_signal.set()
    except AttributeError:
        pass
    try:
        trial.vae.sess.close()
    except: