def generate_random_plot_given_labels(session, labels, time_offsets): """ Generate random raw data plot including given labels Generate random raw data plot with given labels on it, multisensor plot used, call pyplot.show() to show plot in time. Plot will not be saved automatically Args: session: session number which is used to choose session data files labels: string list contains labels we want to be involved in plot time_offsets: list of label time offsets for each session """ sensors = [3] rawfiles = ["../raw_dataset/session"+ str(session)+"_sensor"+ str(sensor) +".raw.csv" for sensor in sensors] annotationfiles = ["../raw_dataset/session"+str(session)+"_sensor" + str(sensor) + ".annotation.csv" for sensor in sensors] sessions = [str(session) for sensor in sensors] time_offset = [time_offsets[session-1] for sensor in sensors] raw_data = w_utils.raw_csv_consolidator(rawfiles, sessions=sessions, sensors=sensors) annotation_data = s_annotation.annotation_csv_consolidator(annotationfiles,sessions=sessions, time_offsets=time_offset, sensors=sensors) annotation_single = s_annotation.annotation_csv_consolidator([annotationfiles[0],],sessions=[sessions[0],], time_offsets=[time_offset[0],]) raw_data = s_raw.preprocess_raw(raw_data, annotation_data, grace_period = timedelta(seconds=0), by='sensor') lbound, rbound = s_annotation.generate_bounds_by_labels(annotation_single, duration=timedelta(minutes=1, seconds=30), labels=labels) raw_data = s_raw.select_raw_by_ts(raw_data, lbound, rbound, by='sensor') annotation_data = s_annotation.select_annotation_by_ts(annotation_data, lbound, rbound, by='sensor') # s_viewer.get_multisensor_raw_plot(raw_data, labels=annotation_data, subplots=False) # multi steps post_value_names, posture_data = s_raw.transform_raw(raw_data, transform_type='post-distance') raw_datas = [raw_data, posture_data] labels = [annotation_data, annotation_data] titles = ['raw','post-distance'] s_viewer.get_multistep_view_plot(raw_datas, labels, titles, subplots=False) pyplot.show()
def main(raw_filenames, annotation_filenames, sessions, subjects, sensors, time_offsets): """ Main function for visual test on dataset Generate 20 random sequences of 5 min with and without labels on multisensor plot, and save them to files Args: raw_filenames: raw data filepath strings for each sensor of current session annotation_filenames: annotation filepath strings for each sensor of current session sessions: session numbers for each sensor subjects: subject strings for each sensor of current session sensors: sensor numbers of current session time_offsets: list of label time offset for each sensor of current session """ raw_data = w_utils.raw_csv_consolidator(raw_filenames, sessions, subjects, sensors) annotation_data = s_annotation.annotation_csv_consolidator( annotation_filenames, time_offsets, sessions, subjects, sensors) raw_data = s_raw.preprocess_raw(raw_data, annotation_data, by='sensor') # index of plot which needs to be regenerated regen = [11, 19] secs = [] for count in regen: try: lbound, rbound = w_utils.generate_random_bounds( raw_data, timedelta(minutes=5)) # count = 4 # lbound = w_utils.convert_fromstring("2012-05-03 12:43:16", annotation.annotation_tstr_format) # rbound = w_utils.convert_fromstring("2012-05-03 12:48:16", annotation.annotation_tstr_format) random_raw = s_raw.select_raw_by_ts(raw_data, lbound, rbound, by='sensor') random_annotation = s_annotation.select_annotation_by_ts( annotation_data, lbound, rbound, by='sensor') s_viewer.get_multisensor_raw_plot(random_raw, labels=random_annotation, subplots=False) true_filename = "../visual_test_data/session" + str( num_session) + "/true/true" + str(count) + '.png' pyplot.savefig(true_filename) s_viewer.get_multisensor_raw_plot(random_raw, subplots=False) test_filename = "../visual_test_data/session" + str( num_session) + "/test/test" + str(count) + '.png' pyplot.savefig(test_filename) # count += 1 secs.append(lbound) except IndexError: continue # print the list of time ranges that is randomly generated for s in secs: print s
def main(): for i in s_info.session_arr: i = 2 annotation_file = 'session' + str(i) + '.annotation.csv' annotation_list = s_annotation.annotation_csv_importer( s_info.clean_dataset_folder + annotation_file) raw_file = 'session' + str(i) + '_DAK.raw.csv' raw_ankle_data = w_utils.raw_csv_importer(s_info.clean_dataset_folder + raw_file) selected_st, selected_et = get_walking_or_standing_annotation( annotation_list) n_subplots = len(selected_st) + 1 #generate subplot grid ncols = np.ceil(np.sqrt(n_subplots)) nrows = np.ceil(n_subplots / float(ncols)) c = 1 consolidate_figure = pyplot.figure(figsize=(20, 10)) for st, et in zip(selected_st, selected_et): lbound = annotation_list.ix[st, s_annotation.st_col] rbound = annotation_list.ix[et, s_annotation.et_col] lbound = lbound - timedelta(seconds=5) rbound = rbound + timedelta(seconds=5) selected_raw = s_raw.select_raw_by_ts(raw_ankle_data, lbound, rbound) selected_annotation = s_annotation.select_annotation_by_ts( annotation_list, lbound, rbound) selected_raw = s_viewer._prepare_raw_for_plot(selected_raw) print selected_annotation ax = consolidate_figure.add_subplot(nrows, ncols, c) s_viewer.get_singlesensor_raw_plot(selected_raw, selected_annotation, subplots=False, ax=ax, figsize=None) single_figure = pyplot.figure(figsize=(20, 10)) s_viewer.get_singlesensor_raw_plot(selected_raw, selected_annotation, ax=single_figure.gca(), subplots=False) figfile = 'session' + str(i) + '_walking_episode' + str( c) + '.rawplot.png' single_figure.savefig(s_info.post_figure_folder + figfile) pyplot.close(single_figure) c += 1 # add legend ax = consolidate_figure.add_subplot(nrows, ncols, c) s_viewer.get_legends_plot() figfile = 'session' + str(i) + '_walking_episodes.rawplot.png' consolidate_figure.savefig(s_info.post_figure_folder + figfile) pyplot.close(consolidate_figure) sys.exit(1)
def unit_tests(rawfile, annotfile, predictfile, visualfile): raw_data = w_utils.raw_csv_consolidator([ rawfile, ], sessions=[ 1, ], subjects=[ 5, ], sensors=[ 'wrist', ]) annotation_data = s_annotation.annotation_csv_consolidator([ annotfile, ], sessions=[ 1, ], subjects=[ 5, ], sensors=[ 'wrist', ]) raw_data = s_raw.preprocess_raw(raw_data, annotation_data, grace_period=timedelta(seconds=0)) # prediction_data = pd.read_csv(predictfile, names=['prob','puffs']) # visualtest_data = pd.read_csv(visualfile, header=0) # activity_viewer(raw_data, annotation_data, prediction_data=prediction_data, visualtest_data=visualtest_data) # print annotation_data # lbound, rbound = annot.generate_random_annotation_bounds(annotation_data, timedelta(minutes=1)) lbound, rbound = s_annotation.generate_bounds_by_labels( annotation_data, duration=timedelta(minutes=5), labels=['walking', 'smoking']) raw_data = s_raw.preprocess_raw(raw_data, annotation_data) raw_data = s_raw.select_raw_by_ts(raw_data, lbound, rbound)
def generate_puffing_example_plots(folder, example_file, time_offsets): """ Generate examples of puffing plots Generate examples of puffing plots with subplots of different preprocessing skill and save them as files. Call pyplot.show() afterwards to show plots in time Args: folder: path string to save the generated examples example_file: csv file path string which contains info of puffing examples time_offsets: list of label offset for each session """ examples = pd.read_csv(example_file, header=0) for idx, row in examples.iterrows(): session = row[0] if isinstance(row[1], int): sensors = [row[1],] else: sensors = row[1] use = row[4] case = row[5] lbound = w_utils.convert_fromstring(row[2], timeformat) rbound = w_utils.convert_fromstring(row[3], timeformat) rawfiles = ["../raw_dataset/session"+ str(session)+"_sensor"+ str(sensor) +".raw.csv" for sensor in sensors] annotationfiles = ["../raw_dataset/session"+str(session)+"_sensor" + str(sensor) + ".annotation.csv" for sensor in sensors] sessions = [str(session) for sensor in sensors] time_offset = [time_offsets[session-1] for sensor in sensors] raw_data = w_utils.raw_csv_consolidator(rawfiles, sessions=sessions, sensors=sensors) annotation_data = s_annotation.annotation_csv_consolidator(annotationfiles,sessions=sessions, time_offsets=time_offset, sensors=sensors) raw_data = s_raw.preprocess_raw(raw_data, annotation_data, grace_period = timedelta(seconds=0), by='sensor') raw_data = s_raw.select_raw_by_ts(raw_data, lbound, rbound, by='sensor') annotation_data = s_annotation.annotation_select_by_ts(annotation_data, lbound, rbound, by='sensor') orientation_values_name, orientation_data = s_raw.transform_raw(raw_data, transform_type='orientation') # get orientation measurement post_distance_values_name, post_distance_data = s_raw.transform_raw(raw_data, transform_type='post-distance') # get post distance measurement datas = [raw_data, orientation_data, post_distance_data] annotations = [annotation_data, annotation_data, annotation_data] fig_to_save = s_viewer.get_multistep_view_plot(datas, annotations, titles=['raw','orientation','post distance'], subplots=True, sharex=True, appear='gray') fig_to_save.set_size_inches(30,10) filename = str(idx) + "_session" + str(session) + "_sensor" + str(sensor) + "_" + use + "_" + case + ".png" fig_to_save.savefig(folder + filename) pyplot.clf()
def main(): testfile_raw = "../puff_corrected_dataset/session7_DW.raw.csv" testfile_annotation = "../puff_corrected_dataset/session7.annotation.csv" raw_df = w_utils.raw_csv_importer(testfile_raw) annotation_df = s_annotation.annotation_csv_importer(testfile_annotation) mean_raw = raw_df.mean() std_raw = raw_df.std() # select by label labels = [[ 'right-puff', ], [ 'right-puff', ], [ 'walking', ], [ 'eating-a-meal', ], ['sitting', 'not-smoking', 'no-activity']] seeds = [0, 10, 2, 3, 10] for label, seed in zip(labels, seeds): lbound, rbound = s_annotation.generate_bounds_by_labels( annotation_df, duration=timedelta(seconds=30), labels=label, seed=seed) selected_a = s_annotation.select_annotation_by_ts(annotation_df, lbound=lbound, rbound=rbound) selected_raw = s_raw.select_raw_by_ts(raw_df, lbound=lbound, rbound=rbound) # test_filtering(selected_raw, selected_a) # test_linearRegression(selected_raw, selected_a) pyplot.figure() pyplot.suptitle(label) # test_preprocessing(selected_raw, selected_a, mean_raw, std_raw) test_peak_rate_computation(selected_raw, selected_a, mean_raw, std_raw) pyplot.show()
def main(): # generate legend plot fhandle = s_viewer.get_legends_plot() pyplot.show() # fname = s_info.puff_figure_folder + 'legend.png' # fhandle.savefig(fname) # pyplot.close(fhandle) sys.exit(1) for i in s_info.session_arr: # i=7 # read in raw and annotation annotation_file = 'session' + str(i) + '.annotation.csv' raw_files = [ 'session' + str(i) + '_' + code + '.raw.csv' for code in s_info.sensor_codes ] raw_datas = [ w_utils.raw_csv_importer(s_info.clean_dataset_folder + raw_file) for raw_file in raw_files ] consolidate_raw = w_utils.raw_data_consolidator( raw_datas, sessions=[ i, ] * len(raw_datas), sensors=s_info.sensor_codes) annotation_data = s_annotation.annotation_csv_importer( s_info.puff_corrected_folder + annotation_file) # use puff corrected annotation # annotation_data = s_annotation.annotation_csv_importer(s_info.clean_dataset_folder + annotation_file) # use clean annotation without puff correction # get all puff annotations puff_st_markers = ( annotation_data[s_annotation.puff_col] != 'no-puff') & ( (annotation_data[s_annotation.puff_col].shift(1) == 'no-puff') | pd.isnull(annotation_data[s_annotation.puff_col].shift(-1))) puff_et_markers = ( annotation_data[s_annotation.puff_col] != 'no-puff') & ( (annotation_data[s_annotation.puff_col].shift(-1) == 'no-puff') | pd.isnull(annotation_data[s_annotation.puff_col].shift(-1))) c = 0 for st, et in zip( annotation_data[puff_st_markers][s_annotation.st_col], annotation_data[puff_et_markers][s_annotation.et_col]): # get raw and annotation for current puff middle_time = st + (et - st) / 2 from datetime import timedelta lbound = middle_time - timedelta(seconds=15) rbound = middle_time + timedelta(seconds=15) selected_puff_raw = s_raw.select_raw_by_ts(consolidate_raw, lbound=lbound, rbound=rbound, by='sensor') selected_annotation = s_annotation.select_annotation_by_ts( annotation_data, lbound=lbound, rbound=rbound) selected_annotations = [ selected_annotation.copy() for s in s_info.sensor_codes ] consolidate_selected_annotation = s_annotation.annotation_data_consolidator( selected_annotations, sensors=s_info.sensor_codes) # plot multisensor figure and save them if annotation_data[annotation_data[s_annotation.st_col] == st][ s_annotation.puff_col] == 'left-puff': side = 'L' else: side = 'R' fig = s_viewer.get_multisensor_raw_plot( selected_puff_raw, consolidate_selected_annotation, subplots=False) fname = s_info.puff_figure_folder + 'session' + str( i) + '_puff' + str(c) + '_' + side + '.rawplot.png' fig.savefig(fname) pyplot.close(fig) print fname + " written" c += 1