def read(queue, mwm_pipeend, display_freq, episode_duration): #used for data acquisition timing counter = 0 record_times = [] #mwm collects data at approximately 512 Hz. Can vary though. That's why we need the trim. trim_size = (episode_duration - .4) * 508 print("episode_duration:", episode_duration) episode_data = [] #creates a new mindwave mobile object mwm_reader = MindwaveDataPointReader() mwm_reader.start() #finds the start signal while True: data_point = mwm_reader.readNextDataPoint() if data_point.__class__ is StartCommand: print("Start sequence received, signaling animation...") #once the start command is received from the mwm, the start signal is sent through the pipe to the animation process mwm_pipeend.send([True]) break epi_type = mwm_pipeend.recv()[0] print("\tCommencing data acquisition at", time.time()) #for as long as the episode is happening, read data from mwm. For some reason, mwm closes too late. Need early stopping #that's why I subtract .4 seconds from the end_time here end_time = (time.time() + episode_duration - .4) - .1 while time.time() < end_time: data_point = mwm_reader.readNextDataPoint() if (data_point.__class__ is RawDataPoint): episode_data.append(data_point._readRawValue()) if (display_freq): current_time = time.time() record_times.append(current_time) counter += 1 if (counter == 240): l = np.average(np.diff(record_times)) print("\t\tmwm:", 1 / l, "Hz") record_times = [] counter = 0 print("\tClosing mwm stream at", time.time()) #get the episode type from the environment # print("trimming ", len(episode_data) - int(trim_size), "readings") # trim the episode data so it's always a constant length print("trimming:", len(episode_data) - trim_size) episode_data = episode_data[:int(trim_size)] episode_data_df = pd.DataFrame().append([episode_data]) episode_data_df['episode_type'] = np.array([epi_type]) #close and delete mwm mwm_reader.end() del mwm_reader #when the episode is finished, the data gathered by the recorder device is accessed and placed in the queue so the parent process can obtain it queue.put(episode_data_df)
def read(queue, mwm_pipeend, display_freq, episode_duration, num_episodes): #num_episodes counter = 0 record_times = [] current_episode = 0 trim_size = (episode_duration - .4) * 508 - 20 trial_data_df = pd.DataFrame() # creates a new mindwave mobile object mwm_reader = MindwaveDataPointReader() mwm_reader.start() # finds the start signal while True: data_point = mwm_reader.readNextDataPoint() if data_point.__class__ is StartCommand: print("Start sequence received.") break start_time = time.time() #idles for 3 seconds to jump past annoying start spike while (time.time() < start_time + 12): mwm_reader.readNextDataPoint() if (display_freq): current_time = time.time() record_times.append(current_time) counter += 1 if (counter == 512): l = np.average(np.diff(record_times)) print("\t\tmwm idling") record_times = [] counter = 0 # once the start command is received from the mwm, the start signal is sent through the pipe to the animation process mwm_pipeend.send(["start_trial"]) print("Startup spike passed. Trial begins.\n") while (current_episode < num_episodes): counter = 0 record_times = [] #used for data acquisition timing episode_data = [] episode_reading_times = [] epi_type = mwm_pipeend.recv()[0] mwm_reader.clearBuffer() # mwm_reader.clearBufferV2() mwm_pipeend.send(["buffer_cleared"]) #for as long as the episode is happening, read data from mwm. For some reason, mwm closes too late. Need early stopping #that's why I subtract .4 seconds from the end_time here end_time = (time.time() + episode_duration - .4) - .15 print("\tCommencing data acquisition at", time.time()) #record data for length of episode while time.time() < end_time: data_point = mwm_reader.readNextDataPoint() if (data_point.__class__ is RawDataPoint): episode_data.append(data_point._readRawValue()) episode_reading_times.append(time.time()) if (display_freq): current_time = time.time() record_times.append(current_time) counter += 1 if (counter == 240): l = np.average(np.diff(record_times)) print("\t\tmwm:", int(1 / l), "Hz") record_times = [] counter = 0 print("\tEnding data acquisition at", time.time()) correct_index = 1024 #this value represents the index at which Pacman initially moves #receives the time at which pacman makes his move from the environment action_time = mwm_pipeend.recv()[0] #finds the index closest in time to pacman's move time action_index = episode_reading_times.index( min(episode_reading_times, key=lambda x: abs(x - action_time))) #adds dummy data to front of episode_data or removes offset number of readings so that the critical points are aligned offset = action_index - correct_index if (offset < 0): dummy = [0] * abs(offset) episode_data = dummy + episode_data elif (offset > 0): episode_data = episode_data[offset:] to_trim = int(len(episode_data) - trim_size) print("\t\ttrimming:", to_trim, "readings") episode_data = episode_data[:int(trim_size)] episode_data_df = pd.DataFrame().append([episode_data]) episode_data_df['episode_type'] = np.array([epi_type]) episode_data_df['episode_num'] = np.array([current_episode]) episode_data_df['action_index'] = np.array([action_index]) episode_data_df['trimmed_data'] = np.array([to_trim]) episode_data_df['win'] = np.array([epi_type in [0, 3]]) print("\tpredicting...") prediction = predict(episode_data_df) mwm_pipeend.send(prediction) print("prediction sent") #predict if episode data df is corrupt if (action_index < 950 or action_index > 1100): episode_data_df['is_corrupt'] = np.array([1]) elif (to_trim > 100 or to_trim < 0): episode_data_df['is_corrupt'] = np.array([1]) else: episode_data_df['is_corrupt'] = np.array([0]) # append to trial data df trial_data_df = pd.concat([trial_data_df, episode_data_df]) print("Episode finished. \n\n") #idle until animation sends finished animation signal # while(not mwm_pipeend.recv()): # mwm_reader.readNextDataPoint() # if (display_freq): # current_time = time.time() # record_times.append(current_time) # counter += 1 # if (counter == 240): # l = np.average(np.diff(record_times)) # print("\t\tmwm:", 1 / l, "Hz") # record_times = [] # counter = 0 current_episode += 1 #close and delete mwm mwm_reader.end() del mwm_reader #when the episode is finished, the data gathered by the recorder device is accessed and placed in the queue so the parent process can obtain it queue.put(trial_data_df)