def plot_brain_substates_start_end(trial_num_states, lst_start_and_end_indices, obs, vmin, vmax, state_number, time_bins, name, trial_type, save_figures, file, title, kind_prepro, run): if len(lst_start_and_end_indices) > 8: print( 'number of substates is to large (>8), please use other function or select manually, maximal 8' ) else: allenMap, allenIndices = load_matrix('') sub_state_number_list = [ x for x in range(0, len(lst_start_and_end_indices)) ] figsize = get_figsize(lst_start_and_end_indices) fig, ax = plt.subplots(1, len(lst_start_and_end_indices), figsize=figsize, tight_layout=False) for i in range(len(lst_start_and_end_indices)): average_obs_per_sub_state = (np.mean( obs[lst_start_and_end_indices[i][0]: lst_start_and_end_indices[i][1], :], axis=0)) if i == len(lst_start_and_end_indices) - 1: plot_area_values(fig, ax[i], allenMap, allenIndices, average_obs_per_sub_state, vmin=vmin, vmax=vmax, haveColorBar=True) else: plot_area_values(fig, ax[i], allenMap, allenIndices, average_obs_per_sub_state, vmin=vmin, vmax=vmax, haveColorBar=False) ax[i].set_title('state {}, substate {} '.format( state_number, sub_state_number_list[i])) if save_figures: new = name + ' plots results {} {} {}'.format( trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/brainmap_sub_{}_{}_{}_{}_{}_{}_{}_run{}.png'.format( name, trial_type, time_bins, title, get_date(), state_number, kind_prepro, run)) plt.show()
def plot_transistion_matrix(hmm, time_bins, save_figures, name, trial_type, trial_num_states, file, type_fit, run): """ function to plot the Transition Matrix and the masked transition matrix (diagonal elements) :param hmm: model :param time_bins: number of frames :return: fig """ trans_matrix = hmm.transitions.transition_matrix fig = plt.figure(figsize=(6, 5)) sns.heatmap(trans_matrix, cmap='viridis', alpha=0.8) plt.title('learned Transition Matrix: {}, {}, {}, {}, {}'.format( name, trial_type, time_bins, trial_num_states, type_fit)) plt.ylabel('state number') if save_figures: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/Trans.Mat_{}_{}_{}_run{}.png'.format( name, trial_type, get_date(), run, bbox_inches="tight")) return fig
def plot_fitting_curve(hmm_lls, optimizer, save_figures, file, name, trial_type, time_bins, trial_num_states, title, kind_prepro, run): fig = plt.figure(figsize=(8, 6)) plt.plot(hmm_lls, label="EM") #if true_ll is known: # plt.plot([0, N_iters], true_ll * np.ones(2), ':k', label="True") plt.xlabel('{} Iteration'.format(optimizer)) plt.ylabel("Log Probability") plt.legend(loc="lower right") if save_figures: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/fit_{}_{}_{}_{}_{}_run{}.png'.format( name, trial_type, title, kind_prepro, get_date(), run, bbox_inches='tight', )) return fig
def plot_brain_states_nan(trial_num_states, lst_average_obs_per_state, vmin, vmax, time_bins, name, trial_type, delay, save_figures, file, title, kind_prepro, run): """ function to plot the brain states. each brainstate is one image and each is saved individually, including the possibility of empty (non existing) states """ allenMap, allenIndices = load_matrix('') state_number_list = [x for x in range(0, trial_num_states)] for i in range(len(lst_average_obs_per_state)): sum_mean_all_roi = sum(lst_average_obs_per_state[i]) if sum_mean_all_roi == 0: print('state {} does not exist!'.format(i)) else: fig, ax = plt.subplots(1, 1, figsize=(6, 6), tight_layout=False) plot_area_values(fig, ax, allenMap, allenIndices, lst_average_obs_per_state[i], vmin=vmin, vmax=vmax, haveColorBar=True) ax.set_title( 'activity of the 27 Rois: {}, {}, {}\n{}s, {}, state {} '. format(name, trial_type, time_bins, delay, title, state_number_list[i])) if save_figures: new = name + ' plots results {} {} {}'.format( trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/brainmap_{}_{}_{}_{}_{}_{}_{}_run{}.png'.format( name, trial_type, time_bins, title, get_date(), state_number_list[i], kind_prepro, run)) # plot the as png exported legend plt.rcParams["axes.grid"] = False plt.figure(figsize=(4, 2)) img = plt.imread('legend.png') plt.imshow(img) plt.axis('off') if save_figures: new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/legend.png') plt.show()
def bar_plot_single(mini, maxi, arr, trial_type, name, kind, e_model, obs, save_figure, file, run): maxi = maxi + 1 # python counting ind = np.arange(maxi - mini) # the x locations for the groups width = 0.5 # the width of the bars: can also be len(x) sequence # Höhe der Bars lst_arr_bar = [] for i in range(mini, maxi): lst_arr_bar.append(arr[arr == i].size) def autolabel(rects, ax): """ Attach a text label above each bar displaying its height """ for rect in rects: height = rect.get_height() ax.text(rect.get_x() + rect.get_width() / 2., 1. * height, '%d' % int(height), ha='center', va='bottom') return autolabel lst_bar_hights = lst_arr_bar.copy() fig, ax = plt.subplots(1, figsize=(4, 4), sharey=True) rect = ax.bar(ind, lst_bar_hights, width, color='g', alpha=0.5) ax.axhline(0, color='grey', linewidth=0.8) ax.set_ylabel('occurrence') ax.set_title( 'Occurrence:\nNumbers of states\n{}, {}, {}\ntime steps {}\n{}'.format( trial_type, name, kind, obs.shape[0], e_model)) ax.set_xticks(ind) ax.set_xticklabels(([str(x) for x in range(mini, maxi)])) autolabel(rect, ax) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots hyperparameter' subdirectory(file, new) plt.savefig(new + '/{}_{}_{}_{}_{}_{}_run{}.png'.format(name, trial_type, kind, obs.shape[0], get_date(), e_model, run, bbox_inches="tight")) return fig
def plot_brain_states_1(trial_num_states, lst_average_obs_per_state, vmin, vmax, time_bins, name, trial_type, save_figures, file, title, run): """ function to plot the brainstates in one row and stored as one image, color bar only at the last map """ allenMap, allenIndices = load_matrix('') state_number_list = [x for x in range(0, trial_num_states)] if trial_num_states > 8: print( 'number of states is to large (squeezed plot), please use other plot function' ) else: figsize = get_figsize(lst_average_obs_per_state) fig, ax = plt.subplots(1, trial_num_states, figsize=figsize, tight_layout=False) for i in range(len(lst_average_obs_per_state)): if i == len(lst_average_obs_per_state) - 1: plot_area_values(fig, ax[i], allenMap, allenIndices, lst_average_obs_per_state[i], vmin=vmin, vmax=vmax, haveColorBar=True) else: plot_area_values(fig, ax[i], allenMap, allenIndices, lst_average_obs_per_state[i], vmin=vmin, vmax=vmax, haveColorBar=False) ax[i].set_title('state {} '.format(state_number_list[i])) if save_figures: new = name + ' plots results {} {} {}'.format( trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/brainmap_1_{}_{}_{}_{}_{}_{}_run{}.png'.format( name, trial_type, time_bins, title, get_date(), state_number_list[i], run)) plt.show()
def plot_transition_matrices(hmm, time_bins, save_figures, name, trial_type, trial_num_states, delay, file, type_fit, kind_prepro, run): """ function to plot the Transition Matrix and the masked transition matrix (diagonal elements) :param hmm: fitted model :param time_bins: number of frames for the viterbi algo :param save_figures: true or false, depending if the figures have to be safed :param name: mouse name (eg. M5) :param trial_type: trial typ (eg. Hit) :param trial_num_states: number of hidden states (the model is fitted to) :param file: the current working directory :param run: integer: to prevent overwriting of runs with identical params :return: fig """ trans_matrix = hmm.transitions.transition_matrix trans_matrix_zero_diag = np.copy(trans_matrix) np.fill_diagonal(trans_matrix_zero_diag, 0) fig, ax = plt.subplots(1, 2, figsize=(10, 4)) ax[0] = sns.heatmap(trans_matrix, ax=ax[0], cmap='viridis', alpha=0.8) ax[0].set_title( 'learned Transition Matrix:\n {}, {}, {}, {}, {}s, {}'.format( name, trial_type, time_bins, trial_num_states, delay, type_fit)) ax[0].set_ylabel('state number') ax[1] = sns.heatmap(trans_matrix_zero_diag, mask=trans_matrix_zero_diag == 0, ax=ax[1], cmap='viridis', alpha=0.8) ax[1].set_title('masked diagonal:\n same details as unmasked') ax[1].set_ylabel('state number') if save_figures: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig( new + '/Trans.Mats_{}_{}_{}_{}_run{}.png'.format(name, trial_type, get_date(), kind_prepro, run, bbox_inches="tight")) return fig
def plot_state_sequence(viterbi_states, trial_num_states, time_bins, name, trial_type, delay, title, kind_prepro, type_fit, save_figures, file, run): """ :param viterbi_states: most probable state sequence (list) :param trial_num_states integer, number of hidden states (to produce a list of integers up to that number) (trial_num_states) :return: figure of the state sequence """ trial_lst_states = [i + 1 for i in range(0, trial_num_states)] plt.rcParams["axes.grid"] = False cmap_trial = gradient_cmap(color_function(trial_lst_states)) fig = plt.figure(figsize=(8, 2)) plt.imshow(viterbi_states[None, :], aspect="auto", cmap=cmap_trial, vmin=0, vmax=len(color_function(trial_lst_states)) - 1, extent=(0, time_bins, 0.8, 0.82), alpha=1) plt.xlim(0, time_bins) plt.ylabel("Viterbi ") plt.yticks([]) plt.xlabel("frames") plt.title('state sequence: {}, {}, {}, {}, {}s, {}, {}, {} '.format( name, trial_type, time_bins, trial_num_states, delay, title, kind_prepro, type_fit)) plt.tight_layout() if save_figures: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig( new + '/sequence {}_{}_{}_{}_{}_run{}.png'.format(name, trial_type, title, kind_prepro, get_date(), run, bbox_inches="tight")) return fig
def plot_data_1(obs, name, trial_type, frames, delay, save_figure, file, title, run): """ function to plot the prepared data for individual selection for averaged and concatenated data. This is necessary because the plot_data function has as argument the trial index which could be missing if only averaged or concatenated data is used. For single trial this is optional, also plot_data can be used :param obs: :param name: :param trial_type: :param frames: :param save_figure: :param file: :param title: :param run: :return: """ lim = 1.05 * abs(obs).max() fig = plt.figure(figsize=(10, 10)) for d in range(obs.shape[1]): plt.plot(obs[:, d] + lim * d, '-k') plt.xlim(0, obs.shape[0]) plt.xlabel("time steps") plt.yticks(lim * np.arange(obs.shape[1]), ['x{}'.format(d + 1) for d in range(obs.shape[1])]) plt.ylabel('observations') plt.title('{}, {} trials, {} time steps, {}s delay, {}'.format( name, trial_type, frames, delay, title)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots data' subdirectory(file, new) plt.savefig(new + '/{}_{}_{}_{}_run{}.png'.format( name, trial_type, title, get_date(), run, bbox_inches="tight")) return fig
def plot_brain_substates_1(trial_num_states, lst_sub_states, obs, vmin, vmax, state_number, time_bins, name, trial_type, save_figures, file, title, run): """ function with a double loop for more then 8 states (does not work probably) """ allenMap, allenIndices = load_matrix('') sub_state_number_list = [x for x in range(0, len(lst_sub_states))] figsize = get_figsize(lst_sub_states) number_of_rows = int(np.ceil(len(lst_sub_states) / 8)) print(number_of_rows) fig, ax = plt.subplots(number_of_rows, 8, figsize=figsize, tight_layout=False) for j in range(number_of_rows): for i in range(8): average_obs_per_sub_state = (np.mean(obs[lst_sub_states[(j * 8) + i], :], axis=0)) plot_area_values(fig, ax[j, i], allenMap, allenIndices, average_obs_per_sub_state, vmin=vmin, vmax=vmax, haveColorBar=False) ax[j, i].set_title('state {}, substate {} '.format( state_number, sub_state_number_list[i])) if save_figures: new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/brainmap_sub_{}_{}_{}_{}_{}_{}_run{}.png'.format( name, trial_type, time_bins, title, get_date(), state_number, run)) plt.show()
def bar_plot(mini, maxi, Hit, CR, FA, Early, Miss, All, name, kind, e_model, obs, save_figure, file, run): maxi = maxi + 1 # python counting ind = np.arange(maxi - mini) # the x locations for the groups width = 0.5 # the width of the bars: can also be len(x) sequence # Höhe der Bars lst_Hit_bar = [] for i in range(mini, maxi): lst_Hit_bar.append(Hit[Hit == i].size) lst_CR_bar = [] for i in range(mini, maxi): lst_CR_bar.append(CR[CR == i].size) lst_FA_bar = [] for i in range(mini, maxi): lst_FA_bar.append(FA[FA == i].size) lst_Early_bar = [] for i in range(mini, maxi): lst_Early_bar.append(Early[Early == i].size) lst_Miss_bar = [] for i in range(mini, maxi): lst_Miss_bar.append(Miss[Miss == i].size) lst_All_bar = [] for i in range(mini, maxi): lst_All_bar.append(All[All == i].size) def autolabel(rects, ind): """ Attach a text label above each bar displaying its height """ for rect in rects: height = rect.get_height() ax[ind].text(rect.get_x() + rect.get_width() / 2., 1. * height, '%d' % int(height), ha='center', va='bottom') return autolabel lst_bar_hights = [ lst_Hit_bar, lst_CR_bar, lst_FA_bar, lst_Early_bar, lst_Miss_bar, lst_All_bar ] lst_trial_typs = ['Hit', 'CR', 'FA', 'Early', 'Miss', 'All'] fig, ax = plt.subplots(1, 6, figsize=(16, 4), sharey=True) for i in range(6): rect = ax[i].bar(ind, lst_bar_hights[i], width, color='g', alpha=0.5) ax[i].axhline(0, color='grey', linewidth=0.8) ax[0].set_ylabel('occurrence') ax[i].set_title( 'Occurrence:\nNumbers of states\n{}, {}, {}\ntime steps {}\n{}'. format(lst_trial_typs[i], name, kind, obs.shape[0], e_model)) ax[i].set_xticks(ind) ax[i].set_xticklabels(([str(x) for x in range(mini, maxi)])) autolabel(rect, ind=i) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots hyperparameter' subdirectory(file, new) plt.savefig(new + '/{}_{}_{}_{}_{}_run{}.png'.format(name, kind, obs.shape[0], e_model, get_date(), run, bbox_inches="tight")) return fig
def plots_of_eollh_llh_AIC_vs_statenumbers_2(lst_loops, lst_table, max_num_states, e_model, kind, obs, save_figure, name, trial_type, file, run): if e_model == 'autoregressive': e_model = 'autoreg.' lst_table_short = [lst_table[i] for i in lst_loops] i = 0 for item in lst_table_short: loop = lst_loops[i] lst_y = [ np.asarray(item.iloc[0].values), np.asarray(item.iloc[1].values) ] label_y = ['e/o cross sum', 'normal'] lst_y2 = [np.asarray(item.iloc[2].values)] label_y2 = 'AIC' txt = 'E-model: {}\nprepro.: {}'.format(e_model, kind) txt1 = '{}\n{} trials\ntime steps: {}\ndim: {} '.format( name, trial_type, obs.shape[0], obs.shape[1]) x = number_states(max_num_states) colors = ['r', 'g'] fig, ax1 = plt.subplots(1, figsize=(8, 4)) for n, colors in enumerate(colors): ax1.plot(x, lst_y[n], color=colors, label=label_y[n]) ax1.set_xlabel('number of states') ax1.set_ylabel('log likelihood') ax1.set_title( 'log likelihoods/AIC \nfor different state numbers, loop {}, run {}' .format(loop, run)) ax1.legend(bbox_to_anchor=(1.09, 1), loc=2, borderaxespad=0.0) ax1.text(x=1.11, y=0.11, transform=ax1.transAxes, s=txt, fontsize=10, bbox=dict(facecolor='w', alpha=0.15), horizontalalignment='left', verticalalignment='top') ax1.text(x=1.11, y=0.40, transform=ax1.transAxes, s=txt1, fontsize=10, bbox=dict(facecolor='w', alpha=0.15), horizontalalignment='left', verticalalignment='top') ax1.set_facecolor('whitesmoke') ax1.grid(color='lavender', which='both', linestyle='-', linewidth=1.8) fig.subplots_adjust(right=0.75) ax2 = ax1.twinx() ax2.plot(x, lst_y2[0], color='darkgrey', linestyle='--', label=label_y2) ax2.set_ylabel(label_y2) ax2.legend(bbox_to_anchor=(1.09, 0.85), loc=2, borderaxespad=0.0) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots hyperparameter' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_{}_run{}.png'.format(name, trial_type, get_date(), loop, kind, run, bbox_inches="tight")) i += 1 return fig
def plot_brain_substates_2(trial_num_states, lst_sub_states, obs, vmin, vmax, state_number, time_bins, name, trial_type, save_figures, file, title, kind_prepro, run): """ function with a double loop for more then 8 states """ allenMap, allenIndices = load_matrix('') sub_state_number_list = [x for x in range(0, len(lst_sub_states))] figsize = get_figsize_2(lst_sub_states) number_of_rows = int(np.ceil(len(lst_sub_states) / 8)) fig, ax = plt.subplots(number_of_rows, 8, figsize=figsize, tight_layout=False) ax = ax.ravel() for i in range(len(lst_sub_states)): if len(lst_sub_states) < 8: if i == len(lst_sub_states) - 1: average_obs_per_sub_state = (np.mean(obs[lst_sub_states[i], :], axis=0)) plot_area_values(fig, ax[i], allenMap, allenIndices, average_obs_per_sub_state, vmin=vmin, vmax=vmax, haveColorBar=True) else: average_obs_per_sub_state = (np.mean(obs[lst_sub_states[i], :], axis=0)) plot_area_values(fig, ax[i], allenMap, allenIndices, average_obs_per_sub_state, vmin=vmin, vmax=vmax, haveColorBar=False) else: if i == 7 or i == 15 or i == 23: average_obs_per_sub_state = (np.mean(obs[lst_sub_states[i], :], axis=0)) plot_area_values(fig, ax[i], allenMap, allenIndices, average_obs_per_sub_state, vmin=vmin, vmax=vmax, haveColorBar=True) else: average_obs_per_sub_state = (np.mean(obs[lst_sub_states[i], :], axis=0)) plot_area_values(fig, ax[i], allenMap, allenIndices, average_obs_per_sub_state, vmin=vmin, vmax=vmax, haveColorBar=False) ax[i].set_title('state {}, substate {} '.format( state_number, sub_state_number_list[i])) if save_figures: new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/brainmap_sub_{}_{}_{}_{}_{}_{}_{}_run{}.png'.format( name, trial_type, time_bins, title, kind_prepro, get_date(), state_number, run)) plt.show()
def plot_brain_states_2_nan(trial_num_states, lst_average_obs_per_state, vmin, vmax, time_bins, name, trial_type, save_figures, file, title, kind_prepro, run): """ function with a double loop for more then 8 states , saved as one image, including the possibility of empty states """ allenMap, allenIndices = load_matrix('') state_number_list = [x for x in range(0, trial_num_states)] figsize_2 = get_figsize_2(lst_average_obs_per_state) number_of_rows = int(np.ceil(len(lst_average_obs_per_state) / 8)) fig, ax = plt.subplots(number_of_rows, 8, figsize=figsize_2, tight_layout=False) ax = ax.ravel() for i in range(len(lst_average_obs_per_state)): sum_mean_all_roi = sum(lst_average_obs_per_state[i]) if sum_mean_all_roi == 0: print('state {} does not exist!'.format(i)) else: if len(lst_average_obs_per_state) < 8: if i == len(lst_average_obs_per_state) - 1: plot_area_values(fig, ax[i], allenMap, allenIndices, lst_average_obs_per_state[i], vmin=vmin, vmax=vmax, haveColorBar=True) else: plot_area_values(fig, ax[i], allenMap, allenIndices, lst_average_obs_per_state[i], vmin=vmin, vmax=vmax, haveColorBar=False) else: if i == 7 or i == 15 or i == 23: plot_area_values(fig, ax[i], allenMap, allenIndices, lst_average_obs_per_state[i], vmin=vmin, vmax=vmax, haveColorBar=True) else: plot_area_values(fig, ax[i], allenMap, allenIndices, lst_average_obs_per_state[i], vmin=vmin, vmax=vmax, haveColorBar=False) ax[i].set_title('state {} '.format(state_number_list[i])) ax[i].set_yticks([]) ax[i].set_xticks([]) if save_figures: new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/brainmap_2_{}_{}_{}_{}_{}_{}_run{}.png'.format( name, trial_type, time_bins, title, get_date(), kind_prepro, run)) plt.show()
def plot_brain_states_1_nan(trial_num_states, lst_average_obs_per_state, vmin, vmax, time_bins, name, trial_type, save_figures, file, title, kind_prepro, run): """ function to plot the brain states in one row and stored as one image, including the option of empty states """ allenMap, allenIndices = load_matrix('') state_number_list = [x for x in range(0, trial_num_states)] if trial_num_states > 8: print( 'number of states is to large (squeezed plot), please use other plot function' ) else: figsize = get_figsize(lst_average_obs_per_state) fig, ax = plt.subplots(1, trial_num_states, figsize=figsize, tight_layout=False) for i in range(len(lst_average_obs_per_state)): sum_mean_all_roi = sum(lst_average_obs_per_state[i]) if sum_mean_all_roi == 0: print('state {} does not exist!'.format(i)) else: if i == trial_num_states - 1: plot_area_values(fig, ax[i], allenMap, allenIndices, lst_average_obs_per_state[i], vmin=vmin, vmax=vmax, haveColorBar=True) else: plot_area_values(fig, ax[i], allenMap, allenIndices, lst_average_obs_per_state[i], vmin=vmin, vmax=vmax, haveColorBar=False) ax[i].set_title('state {} '.format(state_number_list[i])) ax[i].set_yticks([]) ax[i].set_xticks([]) if save_figures: new = name + ' plots results {} {} {}'.format( trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/brainmap_1_{}_{}_{}_{}_{}_{}_run{}.png'.format( name, trial_type, time_bins, title, get_date(), kind_prepro, run)) plt.show()
def plot_data(obs, name, trial_type, frames, delay, trial_index, save_figure, file, title, run, kind_data, kind_prepro): """ plots the data (2d array, dF/F) before proprocessing :param obs: 2d array :param name: string, mouse (M5, M6 etc) :param trial_type string, trial type (Hit, FA etc) :param frames integer number of time steps :param title string, which data (averaged, single trial, conc) :param run integer, run number to avoid overwriting :param save_figure boolsche variable (True if input = 'yes', False otherwise) :param trial_index integer, index of single trial :param file current working directory (function: get_file_and_label ) :param title string, which type of data: average, single or concatenated :param kind_data integer, 0,1,2 depending on type of data (0=average, 1=single, 2=conc) :param kind_prepro string, 'nil' for no preprocessing, 'FA' for FA, 'PCA' for PCA :return: figure """ lim = 1.05 * abs(obs).max() fig = plt.figure(figsize=(10, 10)) for d in range(obs.shape[1]): plt.plot(obs[:, d] + lim * d, '-k') plt.xlim(0, obs.shape[0]) plt.xlabel("time steps") plt.yticks(lim * np.arange(obs.shape[1]), ['x{}'.format(d + 1) for d in range(obs.shape[1])]) if kind_data == 0: if kind_prepro == 'nil': plt.ylabel('observations') plt.title('{}, {} trials, {} time steps, {}s delay, {}, '.format( name, trial_type, frames, delay, title)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots data' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_run{}.png'.format(name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind_prepro == 'FA': plt.ylabel('factors') plt.title('{}, {} trials, {} time steps, {}s delay, {}, FA'.format( name, trial_type, frames, delay, title)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots preprocessed' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_FA_run{}.png'.format(name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind_prepro == 'PCA': plt.ylabel('components') plt.title( '{}, {} trials, {} time steps, {}s delay, {}, PCA'.format( name, trial_type, frames, delay, title)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots preprocessed' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_PCA_run{}.png'.format(name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind_data == 1: title_plot = 'single trial, number: {}'.format(trial_index) if kind_prepro == 'nil': plt.ylabel('observations') plt.title('{}, {} trials, {} time steps, {}s delay, {}'.format( name, trial_type, frames, delay, title_plot)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots data' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_run{}.png'.format(name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind_prepro == 'FA': plt.ylabel('factors') plt.title('{}, {} trials, {} time steps, {}s delay, {}, FA'.format( name, trial_type, frames, delay, title_plot)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots preprocessed' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_FA_run{}.png'.format(name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind_prepro == 'PCA': plt.ylabel('components') plt.title( '{}, {} trials, {} time steps, {}s delay, {}, PCA'.format( name, trial_type, frames, delay, title_plot)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots preprocessed' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_PCA_run{}.png'.format(name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind_data == 2: if kind_prepro == 'nil': plt.ylabel('observations') plt.title('{}, {} trials, {} time steps, {}s delay, {}'.format( name, trial_type, frames, delay, title)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots data' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_run{}.png'.format(name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind_prepro == 'FA': plt.ylabel('factors') plt.title('{}, {} trials, {} time steps, {}s delay, {}, FA'.format( name, trial_type, frames, delay, title)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots preprocessed' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_FA_run{}.png'.format(name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind_prepro == 'PCA': plt.ylabel('components') plt.title( '{}, {} trials, {} time steps, {}s delay, {}, PCA'.format( name, trial_type, frames, delay, title)) if save_figure: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots preprocessed' subdirectory(file, new) plt.savefig( new + '/{}_{}_{}_{}_PCA_run{}.png'.format(name, trial_type, title, get_date(), run, bbox_inches="tight")) return fig
def plot_posterior_prob(hmm, obs_vit, time_bins, trial_num_states, name, trial_type, delay, title, kind_prepro, type_fit, save_figures, file, run): """ function that calculates the posterior probability (alpha matrix), informing about the probability of a specific state at a given time step having seen the observations up to that that time step. This probabilities for each hidden state is plotted. :param hmm: fitted model :param obs_vit the observation data used for the viterbi algorithm :param time_bins: number of frames for the viterbi algo :param save_figures: true or false, depending if the figures have to be safed :param name: mouse name (eg. M5) :param trial_type: trial typ (eg. Hit) :param trial_num_states: number of hidden states (the model is fitted to) :param file: the current working directory :param title: typ of data (averaged or single, for viterbi) :param run: integer: to prevent overwriting of runs with identical params :return: fig """ # posterior state probability, alpha matrix in forward pass posterior_probs = hmm.expected_states(obs_vit)[0] print( 'shape of the array holding the posterior probabilities of each hidden state\nand time step: {}' .format(np.shape(posterior_probs))) trial_lst_states = [i + 1 for i in range(0, trial_num_states)] # color function zur defintion der colors für trial und true number of states colors_trial = color_function(trial_lst_states) xticks_lst = np.arange(0, time_bins + 1, step=10) fig = plt.figure(figsize=(12, 3.5), dpi=80, facecolor='w', edgecolor='k') plt.style.use('seaborn') for k in range(trial_num_states): plt.plot(posterior_probs[:, k], label="State " + str(k + 1), lw=2, color=colors_trial[k]) plt.ylim((-0.01, 1.01)) plt.xticks(xticks_lst) plt.yticks([0, 0.5, 1], fontsize=10) plt.xlabel("frames") plt.ylabel("p(state)") plt.title('posterior Probability: {}, {}, {}, {}, {}s ,{}, {}, {}'.format( name, trial_type, time_bins, trial_num_states, delay, title, kind_prepro, type_fit)) if save_figures: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig( new + '/post_prob_{}_{}_{}_{}_{}_run{}.png'.format(name, trial_type, title, kind_prepro, get_date(), run, bbox_inches="tight")) return posterior_probs, fig
def plot_occupation_duration(trial_num_states, vit_durs_stacked, name, trial_type, time_bins, delay, title, kind_prepro, type_fit, lst_viterbi_total_occupancy_time, save_figures, file, run): """ :return: """ trial_lst_states = [i + 1 for i in range(0, trial_num_states)] # color function zur defintion der colors für trial und true number of states colors_trial = color_function(trial_lst_states) # x Achsen defintion x_trial = [] for i in range(len(trial_lst_states)): x_trial.append('state {}'.format(i)) # trial states viterbi (not permuted) fig, ax = plt.subplots(1, 2, figsize=(14, 4)) # plt.style.use('seaborn') ax[0].hist(vit_durs_stacked, label=['state ' + str(s) for s in range(trial_num_states)], color=colors_trial, alpha=1) ax[0].set_xlabel('Duration') ax[0].set_ylabel('Frequency') ax[0].legend() ax[0].set_title( 'Histogram State Durations: {}, {}, {}, {}, {}s, {}, {}\n {} '.format( name, trial_type, time_bins, trial_num_states, delay, title, kind_prepro, type_fit)) rect1 = ax[1].bar(x_trial, lst_viterbi_total_occupancy_time, width=0.4, label=x_trial, color=colors_trial, alpha=1) ax[1].set_ylabel('total occupancy time') ax[1].set_title( 'occupancy time: {}, {}, {}, {}, {}s, {}, {}\n {} '.format( name, trial_type, time_bins, trial_num_states, delay, title, kind_prepro, type_fit)) autolabel(rect1, ax) if save_figures: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots results {} {} {}'.format(trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig( new + '/occupancy {}_{}_{}_{}_{}_run{}.png'.format(name, trial_type, title, kind_prepro, get_date(), run, bbox_inches="tight")) # the lengend for later use, new: there is an extra function "generate_legend" in map_to_brain #export_legend(legend) return fig
def plot_obs_with_state_sequence(trial_num_states, obs, viterbi_states, time_bins, name, trial_type, delay, title, save_figures, file, kind, run): """ plot the obs before FA, underlayed with viterbi sequence color plot :return: fig """ trial_lst_states = [i + 1 for i in range(0, trial_num_states)] cmap_trial = gradient_cmap(color_function(trial_lst_states)) lim = 1.05 * abs(obs).max() if kind == 0: fig = plt.figure(figsize=(10, 10)) else: fig = plt.figure(figsize=(10, 5)) for d in range(obs.shape[1]): plt.plot(obs[:, d] + lim * d, '-k') plt.imshow(viterbi_states[None, :], aspect="auto", cmap=cmap_trial, vmin=0, vmax=len(color_function(trial_lst_states)) - 1, extent=(0, time_bins, -lim, obs.shape[1] * lim), alpha=0.2) plt.xlim(0, obs.shape[0]) plt.xlabel("frames") plt.yticks(lim * np.arange(obs.shape[1]), ['x{}'.format(d + 1) for d in range(obs.shape[1])]) if kind == 0: plt.ylabel('observations before preprocessing') plt.title('observations {}, {}, {}, {}, {}s, {}'.format( name, trial_type, time_bins, trial_num_states, delay, title)) if save_figures: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots results {} {} {}'.format( trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/observations {}_{}_{}_{}_run{}.png'.format( name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind == 1: plt.ylabel('factors') plt.title('factors {}, {}, {}, {}, {}s, {}'.format( name, trial_type, time_bins, trial_num_states, delay, title)) if save_figures: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots results {} {} {}'.format( trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/factors {}_{}_{}_{}_run{}.png'.format( name, trial_type, title, get_date(), run, bbox_inches="tight")) elif kind == 2: plt.ylabel('components') plt.title('components {}, {}, {}, {}, {}s, {}'.format( name, trial_type, time_bins, trial_num_states, delay, title)) if save_figures: # create new subdirectory name, function subdirectory creates that subdirectory if it does not already # exist new = name + ' plots results {} {} {}'.format( trial_type, time_bins, trial_num_states) subdirectory(file, new) plt.savefig(new + '/components {}_{}_{}_{}_run{}.png'.format( name, trial_type, title, get_date(), run, bbox_inches="tight")) return fig