def permtest_ANOVA_paired(data_panda, behavMeasure, Conds, reps): # initialize vector to hold statistic on each iteration rand_vals = list() # get observed statistics (interaction) for two-way ANOVA aovrm2way = AnovaRM(data_panda, behavMeasure, 'Subject_ID', within=Conds) results_table = aovrm2way.fit() F_vals = results_table.anova_table['F Value'] # get observed interaction F-value: condition-task obs_stat = F_vals[2] # deep copy of panda structure shuffled_panda = data_panda.copy() # loop through repetitions for ii in range(reps): print('\r{} of {}'.format(ii, reps), end='') # H: shuffle column with behavioral measure of interest (PC or RT) WITHIN subject. # H: In essence, I am shuffling PC across conditions, but within subject shuffled_panda["behavMeasure_shuffled"] = shuffled_panda.groupby( "Subject_ID")[behavMeasure].transform(np.random.permutation) # H: get randomized statistic (interaction) for two-way ANOVA aovrm2way_rand = AnovaRM(shuffled_panda, "behavMeasure_shuffled", 'Subject_ID', within=Conds) results_table_rand = aovrm2way_rand.fit() F_vals_rand = results_table_rand.anova_table['F Value'] # get interaction F-value for shuffled structure: condition-task rand = F_vals_rand[2] # push back rand F value rand_vals.append(rand) rand_vals = np.array(rand_vals) # look at probability on either side of the distribution based on the observed statistic - this function is # therefore order invariant with respect to its inputs prob = np.mean(rand_vals > obs_stat) _ = plt.hist(rand_vals, bins='auto') # arguments are passed to np.histogram plt.show() print(f'p = {prob}') print(f'obs_stat = {obs_stat}') return obs_stat, prob
def test_repeated_measures_aggregate_func(): assert_raises(ValueError, AnovaRM, data.append(data), 'DV', 'id', within=['A', 'B', 'D']) m1 = AnovaRM(data.append(data), 'DV', 'id', within=['A', 'B', 'D'], aggregate_func=np.mean) m2 = AnovaRM(data.append(data), 'DV', 'id', within=['A', 'B', 'D'], aggregate_func=np.median) assert_raises(AssertionError, assert_equal, m1.aggregate_func, m2.aggregate_func) assert_frame_equal(m1.fit().anova_table, m2.fit().anova_table)
def three_sample_test(sample1, sample2, sample3, test): if test == "anova": #parametric, between-subjects. test_stat, p_val = scipy.stats.f_oneway(sample1, sample2, sample3) elif test =="rm-anova": #parametric, within-subjects. data = {"response": [], "id": [], "group": []} for i in range(len(sample1)): data["response"].append(sample1[i]) data["id"].append(i) data["group"].append("A") data["response"].append(sample2[i]) data["id"].append(i) data["group"].append("B") data["response"].append(sample3[i]) data["id"].append(i) data["group"].append("C") df = pd.DataFrame(data=data) anova_rm = AnovaRM(df,depvar="response",subject="id",within=["group"]) res = anova_rm.fit() test_stat = res.anova_table['F Value'][0] p_val = res.anova_table['Pr > F'][0] elif test == "kruskal-wallis": #nonparametric, between-subjects. test_stat, p_val = scipy.stats.kruskal(sample1, sample2, sample3) elif test == "friedman": #nonparametric, within-subjects. test_stat, p_val = scipy.stats.friedmanchisquare(sample1, sample2, sample3) return test_stat,p_val
def rm_one_way_anova(dataset: Dataset, design, combined_data: CombinedData): data = dataset.data xs = combined_data.get_explanatory_variables() ys = combined_data.get_explained_variables() assert (len(ys) == 1) y = ys[0] between_subjs = [] within_subjs = [] for x in xs: if "between subjects" in design and design[ "between subjects"] == x.metadata[name]: between_subjs.append(x.metadata[name]) if "within subjects" in design and design[ "within subjects"] == x.metadata[name]: within_subjs.append(x.metadata[name]) # import pdb; pdb.set_trace() id = dataset.pid_col_name aovrm2way = AnovaRM(data, depvar=y.metadata[name], subject=id, within=within_subjs) # aovrm2way = AnovaRM(data, depvar=y.metadata[name], subject=dataset.pid_col_name, within=within_subjs, between=between_subjs) # apparently not implemented in statsmodels # import pdb; pdb.set_trace() res2way = aovrm2way.fit()
def continuous_paired_group_repeated_measures_anova(**kwargs): data_frame = kwargs["data_frame"] dependable_variable = kwargs["dependable_variable"] conditions = kwargs["conditions"] # make one condition out of multiple, otherwise not supported by AnovaRM sLength = len(data_frame[dependable_variable]) data_frame.loc[:, 'condition'] = pd.Series(np.empty(sLength), index=data_frame.index) if isinstance(conditions, list) and len(conditions) > 1: for name, group in data_frame.groupby(conditions): data_frame.loc[ data_frame.groupby(conditions).get_group(name).index, "condition"] = "_".join(name) data_frame.drop(columns=conditions) # todo: list in conditions not supported map to signle condition required, reduce subject size other wise #aovrm = AnovaRM(data_frame, depvar=dependable_variable, subject='test_index', within=conditions) aovrm = AnovaRM(data_frame[data_frame["test_index"] < 1000], dependable_variable, 'test_index', within=["condition"], aggregate_func=np.mean) res = aovrm.fit() print(res) # todo: how to read pvalue res.summary()... return True, 100
def rm(self, data, dep_var, subject, within, aggregate_func=None): """ Repeated Measures ANOVA Parameters: ---------- data: DataFrame Contains at least 3 columns that are 'dependent variable', 'subject', and 'factor' respectively. dep_var: str Name of the 'dependent variable' column. subject: str Name of the 'subject' column. (subject identifier) within: a list of strings Names of the at least one 'factor' columns. Return: ------ aov_table: DataFrame ANOVA table """ aov_rm = AnovaRM(data, dep_var, subject, within, aggregate_func=aggregate_func) aov_table = aov_rm.fit().anova_table return aov_table
def anova(diff1, diff2, recall, within_factors): r = 'recall' if not recall: r = 'recognition' diff1 = rearange(diff1, 'short', within_factors = within_factors, recall = recall) diff2 = rearange(diff2, 'short', within_factors = within_factors, recall = recall) diffs_for_anova = pd.concat([diff1,diff2]) #perform anova anovarm = AnovaRM(diffs_for_anova, 'performance', 'sub_id', within = within_factors, aggregate_func = 'mean') res = anovarm.fit() #rounded p value p = round(res.anova_table['Pr > F'][0],4) print(F'ANOVA ON DIFFERENCES in memory performance - {r}', res) return diff1, diff2, diffs_for_anova
def rm_one_way(xs, y, key, df): aovrm2way = AnovaRM(df, depvar=y, subject=key, within=xs, aggregate_func='mean') res2way = aovrm2way.fit() return str(res2way)
def rm_one_way(xs, y, key, df): between_subjs = [] within_subjs = [] aovrm2way = AnovaRM(df, depvar=y, subject=key, within=xs, aggregate_func='mean') res2way = aovrm2way.fit() # import pdb; pdb.set_trace() return str(res2way)
def AnovaRM_with_post_hoc(data, dep_var, subject, within, only_significant = False): # One within anova = AnovaRM(data, dep_var, subject, within) print(anova.fit()) # Post-hoc with ttest pairwise_ttest_rel(data, dep_var, within = within, only_significant = only_significant )
def rm_one_way_anova(dataset: Dataset, predictions, design, combined_data: CombinedData): data = dataset.data xs = combined_data.get_explanatory_variables() ys = combined_data.get_explained_variables() assert (len(ys) == 1) y = ys[0] between_subjs = [] within_subjs = [] for x in xs: if "between subjects" in design and design[ "between subjects"] == x.metadata[name]: between_subjs.append(x.metadata[name]) if "within subjects" in design and design[ "within subjects"] == x.metadata[name]: within_subjs.append(x.metadata[name]) if predictions: if isinstance(predictions[0], list): prediction = predictions[0][0] else: prediction = predictions[0] else: prediction = None key = dataset.pid_col_name aovrm2way = AnovaRM(data, depvar=y.metadata[name], subject=key, within=within_subjs, aggregate_func='mean') # aovrm2way = AnovaRM(data, depvar=y.metadata[name], subject=dataset.pid_col_name, within=within_subjs, between=between_subjs) # apparently not implemented in statsmodels res2way = aovrm2way.fit() result_df = res2way.anova_table col_name = x.metadata[name] for row_name in result_df.index: if row_name == col_name: row_data = result_df.loc[row_name] test_statistic = row_data['F Value'] p_val = row_data['Pr > F'] dof = (row_data['Num DF'], row_data['Den DF']) test_result = TestResult(name=rm_one_way_anova_name, test_statistic=test_statistic, p_value=p_val, prediction=prediction, dof=dof, alpha=combined_data.alpha, table=result_df, x=x, y=y) return test_result
def rm_anova(data=None, subject=None, within=None, between=None, dv=None): """ Returns ANOVA table as dataframe. """ anova = AnovaRM(data=data, subject=subject, within=within, between=between, depvar=dv) fit = anova.fit() return fit.anova_table
def getRMAnova(dataSet, labels, verbose=False): tlabels = np.concatenate([[labels[j] for _,y in enumerate(x) ]for j,x in enumerate(dataSet)]) concatData = np.concatenate(dataSet) ids = np.concatenate([np.arange(len(x)) for _,x in enumerate(dataSet)]) d = {'id':ids, 'rt':concatData, 'cond':tlabels} df = pd.DataFrame(d) anovarm = AnovaRM(df, 'rt', 'id', within=['cond']) res = anovarm.fit() if verbose: print (res.summary()) return res
def rlrlRMANOVA(mes): # RL-RL ANOVA RM aexps = expandEvals(mes) print('********** RL Controller Error RMANOVA **********') aexps['s_id'] = (np.array(aexps.index.values.tolist()) + 1).tolist() avrm = AnovaRM(aexps, 'error', 's_id', within=['model']) rma = avrm.fit() print(rma) print('********** RL Controller Error RMANOVA **********') aexps['s_id'] = (np.array(aexps.index.values.tolist()) + 1).tolist() avrm = AnovaRM(aexps, 'rise_time', 's_id', within=['model']) rma = avrm.fit() print(rma) print('********** RL Controller Error RMANOVA **********') aexps['s_id'] = (np.array(aexps.index.values.tolist()) + 1).tolist() avrm = AnovaRM(aexps, 'energy', 's_id', within=['model']) rma = avrm.fit() print(rma)
def test_repeated_measures_aggregate_func(): assert_raises(ValueError, AnovaRM, data.append(data), 'DV', 'id', within=['A', 'B', 'D']) m1 = AnovaRM(data.append(data), 'DV', 'id', within=['A', 'B', 'D'], aggregate_func=np.mean) m2 = AnovaRM(data.append(data), 'DV', 'id', within=['A', 'B', 'D'], aggregate_func=np.median) assert_raises(AssertionError, assert_equal, m1.aggregate_func, m2.aggregate_func) assert_frame_equal(m1.fit().anova_table, m2.fit().anova_table)
def rank_multiple_normal_homoscedastic(data, alpha, verbose, order, effect_size, force_mode): """ Analyzes data using repeated measures ANOVA and Tukey HSD. """ stacked_data = data.stack().reset_index() stacked_data = stacked_data.rename(columns={ 'level_0': 'id', 'level_1': 'treatment', 0: 'result' }) anova = AnovaRM(stacked_data, 'result', 'id', within=['treatment']) pval = anova.fit().anova_table['Pr > F'].iat[0] if verbose: if pval >= alpha: print( "Fail to reject null hypothesis that there is no difference between the distributions (p=%f)" % pval) else: print( "Rejecting null hypothesis that there is no difference between the distributions (p=%f)" % pval) print( "Using Tukey HSD post hoc test.", "Differences are significant if the confidence intervals of the mean values are not overlapping." ) multicomp = MultiComparison(stacked_data['result'], stacked_data['treatment']) tukey_res = multicomp.tukeyhsd() # must create plot to get confidence intervals tukey_res.plot_simultaneous() # delete plot instead of showing plt.close() rankdf, effsize_method, reorder_pos = _create_result_df_skeleton( data, None, True, order, effect_size=effect_size, force_mode=force_mode) for population in rankdf.index: mean = data.loc[:, population].mean() ci_range = tukey_res.halfwidths[data.columns.get_loc(population)] lower, upper = mean - ci_range, mean + ci_range rankdf.at[population, 'ci_lower'] = lower rankdf.at[population, 'ci_upper'] = upper return _ComparisonResult(rankdf, pval, None, 'anova', 'tukeyhsd', effsize_method, reorder_pos)
def test_repeated_measures_aggregate_func(): double_data = pd.concat([data, data], axis=0) assert_raises(ValueError, AnovaRM, double_data, 'DV', 'id', within=['A', 'B', 'D']) m1 = AnovaRM(double_data, 'DV', 'id', within=['A', 'B', 'D'], aggregate_func=np.mean) m2 = AnovaRM(double_data, 'DV', 'id', within=['A', 'B', 'D'], aggregate_func=np.median) assert_raises(AssertionError, assert_equal, m1.aggregate_func, m2.aggregate_func) assert_frame_equal(m1.fit().anova_table, m2.fit().anova_table)
def anovaRM(self, depvar, subject, within=None, between=None, aggregate_func=None): """ Repeated measures Anova using least squares regression The full model regression residual sum of squares is used to compare with the reduced model for calculating the within-subject effect sum of squares. Currently, only fully balanced within-subject designs are supported. Calculation of between-subject effects and corrections for violation of sphericity are not yet implemented. Parameters ---------- depvar: str The dependent variable in data subject: str Specify the subject id within: list[str] The within-subject factors between: list[str] The between-subject factors, this is not yet implemented aggregate_func: {None, ‘mean’, callable} If the data set contains more than a single observation per subject and cell of the specified model, this function will be used to aggregate the data before running the Anova. None (the default) will not perform any aggregation; ‘mean’ is s shortcut to numpy.mean. An exception will be raised if aggregation is required, but no aggregation function was specified. Returns ---------- AnovaResults instance Notes ---------- This implementation currently only supports fully balanced designs. If the data contain more than one observation per subject and cell of the design, these observations need to be aggregated into a single observation before the Anova is calculated, either manually or by passing an aggregation function via the aggregate_func keyword argument. Note that if the input data set was not balanced before performing the aggregation, the implied heteroscedasticity of the data is ignored. References ---------- Rutherford, Andrew. Anova and ANCOVA: a GLM approach. John Wiley & Sons, 2011. """ res = AnovaRM(self.__data, depvar, subject, within, between, aggregate_func) res = res.fit() print(res)
def fit(self, data, depvar, subject, within=None, between=None, aggregate_func=None): """Estimate the model and compute ANOVA table. Parameters ---------- data : DataFrame depvar : str The dependent variable in `data` subject : str Specify the subject id within : list[str] The within-subject factors between : list[str] The between-subject factors, this is not yet implemented aggregate_func : {None, 'mean', callable} If the data set contains more than a single observation per subject and cell of the specified model, this function will be used to aggregate the data before running the Anova. `None` (the default) will not perform any aggregation; 'mean' is s shortcut to `numpy.mean`. An exception will be raised if aggregation is required, but no aggregation function was specified. Returns ------- results : AnovaResults instance Raises ------ ValueError If the data need to be aggregated, but `aggregate_func` was not specified. """ anova = AnovaRM(data=data, depvar=depvar, subject=subject, within=within, between=between, aggregate_func=aggregate_func) self._results = anova.fit()
def calculate_anova(df): pvals = [] num_subjs = 9 for vox in tqdm(df): vox = calculate_avg_across_models(vox) vox = np.append( vox, np.reshape(np.array(list(range(1, num_subjs + 1))), (num_subjs, 1)), 1) vox = pd.DataFrame(vox, columns=['bert', 'baseline', 'opennmt', 'subject']) sub_vox = vox.melt(id_vars=["subject"], var_name="model", value_name="corr") aovrm2way = AnovaRM(sub_vox, "corr", "model", within=["subject"]) mod = aovrm2way.fit() pval = mod.summary().tables[0]["Pr > F"]["subject"] pvals.append(pval) return pvals
def anova(data): data = pd.melt(data, id_vars='sub_id', var_name='cond', value_name='performance') # #perform anova anovarm = AnovaRM(data, 'performance', 'sub_id', within=['cond']) res = anovarm.fit() #rounded p value p = round(res.anova_table['Pr > F'][0], 2) F = round(res.anova_table['F Value'][0], 2) # print(F'ANOVA ON DIFFERENCES in memory performance - {r}', res) print(F, p) res2 = [[F, p]] return res2
def calculate_anova(args, all_corrs): dims = all_corrs[0][0].shape pvals = np.zeros((dims[0], dims[1], dims[2])) num_layers = 12 num_subjs = 9 print("LEN: " + str(len(all_corrs))) print("DIMS: " + str(all_corrs[0][0].shape)) for i in tqdm(range(dims[0])): for j in range(dims[1]): for k in range(dims[2]): vals_across_subjs_and_layers = [] for subj in range(num_subjs): for layer in range(num_layers): val = all_corrs[subj][layer][i][j][k] vals_across_subjs_and_layers.append( all_corrs[subj][layer][i][j][k]) # make dataframe df = pd.DataFrame({ 'voxel': np.ones(len(vals_across_subjs_and_layers)), 'corr': vals_across_subjs_and_layers, 'subject': np.repeat(list(range(1, num_subjs + 1)), num_layers), 'layer': np.tile(list(range(1, num_layers + 1)), num_subjs) }) aovrm2way = AnovaRM(df, 'voxel', 'corr', within=['subject', 'layer']) mod = aovrm2way.fit() pval = mod.summary().tables[0]["Pr > F"]["subject:layer"] pvals[i][j][k] = pval return pvals
def anova_group(means, recog): t = 'recall' if recog: t = 'recog' #melt df means = pd.melt(means,id_vars = 'sub_id', var_name = 'cond', value_name = 'performance') anovarm = AnovaRM(means, 'performance', 'sub_id', within = ['cond']) res = anovarm.fit() p = round(res.anova_table['Pr > F'][0],4) print(F'reaction times anova ({t})', res) return p
for i, row in dataset_spec.iterrows(): dataset_spec.at[i, 'condition'] = "spec" for i, row in dataset_sub.iterrows(): dataset_sub.at[i, 'condition'] = "sub" for i, row in dataset_rule.iterrows(): dataset_rule.at[i, 'condition'] = "rule" for i, row in dataset_gen.iterrows(): dataset_gen.at[i, 'condition'] = "gen" # concatenate all the dataframes frames = [dataset_spec, dataset_sub, dataset_rule, dataset_gen] result_df = pd.concat(frames) #perform the ANOVA aovrm = AnovaRM(result_df, 'OT', 'Subj_tr', within=['condition']) res = aovrm.fit() print(res) ################ ##### use ###### ### pingouin ### ################ import pingouin as pg from pingouin import mixed_anova, read_dataset df_ANOVA = result_df.rm_anova(dv='OT', within='condition', subject='Subj_tr', detailed=True)
print('') print('Valores atípicos (outliers): tan sólo tenemos uno') print('') print('Igualdad de varianzas de las diferencias ente niveles de tratamiento:') h**o = stats.levene(facebook['Visitantes'], pixel['Visitantes'], wTienda['Visitantes']) print(h**o) print( "El test de Levene para la prueba de igualdad de varianzas me da un p-valor = %f " % h**o.pvalue) print('Se cumple la hipótesis de homocedasticidad (hipótesis fuerte)') print('') print('Realizo ahora la prueba ANOVA-MR') aovrm = AnovaRM(longRM, 'Visitantes', 'Mes', ['Procedencia']) ajuste = aovrm.fit() print(ajuste.summary()) print( 'Obtengo un p-valor = 0.8436. Por tanto no rechazo la hipótesis nula de igualdad de medias' ) print( 'CONCLUSIÓN: en este subconjunto no importa la procedencia de la variable Visitantes, pues me proporcionan la misma información' ) print('') print('2º) Prueba estadística para muestras pareadas') print('Breve estudio descriptivo') print('Gráfico de cajas y bigotes:') bp2 = plt.boxplot([ gaCatalogo['Usuarios'], wCatalogo['Visitantes'][(len(wCatalogo['Visitantes']) -
values = [998, 511] sub_id = [i + 1 for i in range(N)] * len(P) mus = np.concatenate([np.repeat(value, N) for value in values]).tolist() rt = np.random.normal(mus, scale=112.0, size=N * len(P)).tolist() iv = np.concatenate([np.array([p] * N) for p in P]).tolist() df = pd.DataFrame({"id": sub_id, "rt": rt, "iv": iv}) # %% [markdown] {"slideshow": {"slide_type": "subslide"}} # Do the repeated measures ANOVA. # %% aovrm = AnovaRM(df, depvar="rt", subject="id", within=["iv"]) fit = aovrm.fit() fit.summary() # %% [markdown] {"slideshow": {"slide_type": "slide"}} # # dfply # %% [markdown] # For those of you who are familiar with R and the tidyverse, the [dfply package](https://github.com/kieferk/dfply) allows you to have dplyr-like piping in Python. The pipe operator for this package is `>>`, while the result of each computation step is given by `X`. `>>=` is used for in-place assignment. All the documentation is available at the link; I'm just going to go over some useful basics here. # %% from dfply import * diamonds >> head() # %% [markdown] {"slideshow": {"slide_type": "subslide"}} # ## Selection
def plotting_functions(m484, m479, m483, m478, m486, m480, m481,exp, n = 5): coef_subj = runs_length(exp, subject_IDs ='all', n = n) # coef_subj = recordings_n_back(m484, m479, m483, m478, m486, m480, m481, n = n) coef_subj = np.asarray(coef_subj) rewards = coef_subj[:,:,:n] choices = coef_subj[:,:,n:n*2] choices_X_reward = coef_subj[:,:,n*2:-1] _1_back_ch = choices[:, :, 0]#[:,1:] _other_back_ch = np.mean(choices[:, :,1:],2)#[:,1:] _1_back_rew_ch = choices_X_reward[:,:,0] _other_back_rew_ch = np.mean(choices_X_reward[:,:,1:],2) _all_back_rew = np.mean(rewards,2)#[:,1:] # subject_id = np.tile(np.arange(7), 7) # fraction_id = np.zeros(7*7) # k = 0 # for n in range(10): # fraction_id[n*7:n*7+7] = k # k+=1 subject_id = np.tile(np.arange(10), 9) fraction_id = np.zeros(90) k = 0 for n in range(10): fraction_id[n*9:n*9+9] = k k+=1 _1_back = np.concatenate(_1_back_ch.T,0) _1_back = {'Data':_1_back,'Sub_id': subject_id,'cond': fraction_id} _1_back = pd.DataFrame.from_dict(data = _1_back) aovrm = AnovaRM(_1_back, depvar = 'Data',subject = 'Sub_id', within=['cond']) res = aovrm.fit() _1_back = res.anova_table p_val_1_back = np.around(res.anova_table['Pr > F'][0]) _other_back_ch = np.concatenate(_other_back_ch.T,0) _other_back_ch = {'Data':_other_back_ch,'Sub_id': subject_id,'cond': fraction_id} _other_back_ch = pd.DataFrame.from_dict(data = _other_back_ch) aovrm = AnovaRM(_other_back_ch, depvar = 'Data',subject = 'Sub_id', within=['cond']) res = aovrm.fit() _other_back = res.anova_table p_val_other_back_ch = np.around(res.anova_table['Pr > F'][0]) _1_back_rew_ch = np.concatenate(_1_back_rew_ch.T,0) _1_back_rew_ch = {'Data':_1_back_rew_ch,'Sub_id': subject_id,'cond': fraction_id} _1_back_rew_ch = pd.DataFrame.from_dict(data = _1_back_rew_ch) aovrm = AnovaRM(_1_back_rew_ch, depvar = 'Data',subject = 'Sub_id', within=['cond']) res = aovrm.fit() _1_back_re_ch = res.anova_table p_val_1_back_rew_ch = np.around(res.anova_table['Pr > F'][0]) _other_back_rew_ch = np.concatenate(_other_back_rew_ch.T,0) _other_back_rew_ch = {'Data':_other_back_rew_ch,'Sub_id': subject_id,'cond': fraction_id} _other_back_rew_ch = pd.DataFrame.from_dict(data = _other_back_rew_ch) aovrm = AnovaRM(_other_back_rew_ch, depvar = 'Data',subject = 'Sub_id', within=['cond']) res = aovrm.fit() _other_back_reward_choice = res.anova_table p_val_1_back_other_back_rew_ch = np.around(res.anova_table['Pr > F'][0]) _all_back_rew = np.concatenate(_all_back_rew.T,0) _all_back_rew = {'Data':_all_back_rew,'Sub_id': subject_id,'cond': fraction_id} _all_back_rew = pd.DataFrame.from_dict(data = _all_back_rew) aovrm = AnovaRM(_all_back_rew, depvar = 'Data',subject = 'Sub_id', within=['cond']) res = aovrm.fit() _back_rew = res.anova_table p_val_1_back_all_back_rew = np.around(res.anova_table['Pr > F'][0]) _1_back_ch = np.mean(choices[:, :, 0],0) _1_back_ch_er = np.std(choices[:, :, 0],0)/np.sqrt(9) #_other_back_ch = np.mean(choices[:, :, 1:],2) _other_back_ch = np.mean(np.mean(choices[:, :,1:],2),0) _other_back_ch_err = np.std(np.mean(choices[:, :, 1:],2),0)/np.sqrt(9) #_all_back_rew = np.mean(rewards,2) _all_back_rew = np.mean(np.mean(rewards,2),0) _all_back_rew_err = np.std(np.mean(rewards,2),0)/np.sqrt(9) #_all_back_rew_ch = np.mean(choices_X_reward,2) _1_back_rew_ch = np.mean(choices_X_reward[:,:,0],0) _1_back_rew_ch_err = np.std(choices_X_reward[:,:,0],0)/np.sqrt(9) _all_back_rew_ch = np.mean(np.mean(choices_X_reward[:,:,1:],2),0) _all_back_rew_ch_err = np.std(np.mean(choices_X_reward[:,:,1:],2),0)/np.sqrt(9) isl = wes.Royal2_5.mpl_colors plt.figure(figsize = (10,4)) plt.subplot(1,5,1) plt.errorbar(np.arange(len(_all_back_rew)), _all_back_rew, yerr=_all_back_rew_err, fmt='o', color = isl[0]) plt.annotate(p_val_1_back_all_back_rew, xy = (10,np.max(_all_back_rew)+0.01)) plt.xlim(-1,10) plt.title(' N Rewards Back') plt.xticks(np.arange(10),np.arange(10)+1) plt.xlabel('Task') plt.subplot(1,5,2) #sns.boxplot(data =_1_back_ch, palette="Set3",showfliers = False) plt.errorbar(np.arange(len(_1_back_ch)), _1_back_ch, yerr=_1_back_ch_er, fmt='o', color = isl[3]) plt.annotate(p_val_1_back, xy = (10,np.max(_1_back_ch)+0.01)) plt.xlim(-1,10) plt.title(' 1 Choice Back') plt.xticks(np.arange(10),np.arange(10)+1) plt.xlabel('Task') plt.ylabel('Coefficient') plt.subplot(1,5,3) #sns.boxplot(data=_other_back_ch, palette="Set3",showfliers = False) plt.errorbar(np.arange(len(_other_back_ch)), _other_back_ch, yerr=_other_back_ch_err, fmt='o', color = isl[3]) plt.annotate(p_val_other_back_ch, xy = (10,np.max(_other_back_ch)+0.01)) plt.xlim(-1,10) plt.title(' 2+ Choices Back') plt.xticks(np.arange(10),np.arange(10)+1) plt.xlabel('Task') plt.ylabel('Coefficient') plt.subplot(1,5,4) #sns.boxplot(data=_all_back_rew_ch, palette="Set3",showfliers = False) plt.errorbar(np.arange(len(_1_back_rew_ch)), _1_back_rew_ch, yerr=_1_back_rew_ch_err, fmt='o', color = isl[4]) plt.annotate(p_val_1_back_rew_ch, xy = (10,np.max(_1_back_rew_ch)+0.01)) plt.xlim(-1,10) plt.title(' 1 Choice x Reward Back') plt.xticks(np.arange(10),np.arange(10)+1) plt.xlabel('Task') plt.ylabel('Coefficient') plt.subplot(1,5,5) #sns.boxplot(data=_all_back_rew_ch, palette="Set3",showfliers = False) plt.errorbar(np.arange(len(_all_back_rew_ch)), _all_back_rew_ch, yerr=_all_back_rew_ch_err, fmt='o', color = isl[4]) plt.annotate(p_val_1_back_other_back_rew_ch, xy = (10,np.max(_all_back_rew_ch)+0.01)) plt.xlim(-1,10) plt.xticks(np.arange(10),np.arange(10)+1) plt.xlabel('Task') plt.title(' 2 Choices x Rewards Back') plt.ylabel('Coefficient') sns.despine() plt.tight_layout()
ANOVA_list.append([ID, 'nogo', 'congruent', individ_acc[1]]) ANOVA_list.append([ID, 'go', 'incongruent', individ_acc[2]]) ANOVA_list.append([ID, 'nogo', 'incongruent', individ_acc[3]]) for i in range(4): all_accuracies[i].append(individ_acc[i]) #ANOVA data = pd.DataFrame(ANOVA_list, columns=['pid', 'response', 'congruency', 'SbjACC']) gpResult = data.groupby(['response', 'congruency']).SbjACC.mean().reset_index() print(gpResult) curr_ANOVA = AnovaRM(data, 'SbjACC', 'pid', within=['response', 'congruency']) curr_ANOVA = curr_ANOVA.fit() print(curr_ANOVA) #Overall Analysis all_accuracies_average = [] for i in range(len(all_accuracies)): all_accuracies_average.append( sum(all_accuracies[i]) / len(all_accuracies[i])) print(all_accuracies_average) all_accuracies_average = [ all_accuracies_average[0], all_accuracies_average[2], all_accuracies_average[1], all_accuracies_average[3] ]
(g.set_axis_labels('Awareness', 'Probability').set( ylim=(0, 0.85)).set_titles("{row_name} | {col_name}").despine(left=True)) for ii, (target, df_sub) in enumerate(df_plot.groupby('attention')): # formula = 'prob ~ C(correctness)*C(awareness)*C(confidence)' # model = ols(formula, df_sub).fit() # aov_table = anova_lm(model, typ=2) # s = f"{target}, F({model.df_model: .0f},{model.df_resid: .0f}) = {model.fvalue: .3f}, p = {model.f_pvalue: .4f}" # print(s) # g.axes[ii][0].annotate(s,xy=(-0.45,.8)) g.axes[ii][0].set(ylabel=f'Probability | {target}') g.savefig(os.path.join(figure_dir, 'att.png'), dpi=400, bbox_inches='tight') df_plot['level'] = df_plot['correctness'] + ', ' + df_plot[ 'awareness'] + ', ' + df_plot['confidence'] for target, df_sub in df_plot.groupby(['attention']): temp = {} df_sub = df_sub.sort_values(['sub', 'window', 'level']) for level, df_sub_sub in df_sub.groupby(['level']): # print(df_sub_sub.shape) temp[level] = df_sub_sub['prob'].values for_j = pd.DataFrame(temp) for_j.to_csv(os.path.join(saving_dir, f'{target} for jsp.csv')) #,na_rep='NAN') aovrm = AnovaRM(df_sub, 'prob', 'sub', within=['awareness', 'confidence', 'correctness']) res = aovrm.fit().summary().tables[0] res.to_csv(os.path.join(saving_dir, f'ANVOA report {target}.csv'))
spark.sparkContext.setLogLevel("ERROR") print "\nspark session created sucessfully:: \n" dataset = spark.read.csv("/home/fidel/mltest/bank.csv", header=True, inferSchema=True) dataset.printSchema() df = pd.read_csv("/home/fidel/mltest/bank.csv", delimiter=";") print df.describe() ######creating the box plot # boxplot = df.boxplot('age', by='marital', figsize=(12, 8)) df_anova = dataset.toPandas() mod = ols("age ~ housing", data=df_anova).fit() aov_table = sm.stats.anova_lm(mod, typ=2) print aov_table # using 1st test anovarm = AnovaRM(df_anova, "age", "default", within=["marital"]) fit = anovarm.fit() fit.summary() # 2nd method
ANOVA_list.append([ID, 'nogo', 'congruent', individ_acc[1]]) ANOVA_list.append([ID, 'go', 'incongruent', individ_acc[2]]) ANOVA_list.append([ID, 'nogo', 'incongruent', individ_acc[3]]) for i in range(4): all_accuracies[i].append(individ_acc[i]) #ANOVA data = pd.DataFrame(ANOVA_list, columns=['pid', 'response', 'congruency', 'SbjACC']) gpResult = data.groupby(['response', 'congruency']).SbjACC.mean().reset_index() print(gpResult) prev_ANOVA = AnovaRM(data, 'SbjACC', 'pid', within=['response', 'congruency']) prev_ANOVA = prev_ANOVA.fit() print(prev_ANOVA) all_accuracies_average = [] for i in range(len(all_accuracies)): all_accuracies_average.append( sum(all_accuracies[i]) / len(all_accuracies[i])) print(all_accuracies_average) #plot the relationship labels = ('congruent go', 'congruent nogo', 'incongruent go', 'incongruent nogo') y_pos = np.arange(len(labels))