In [23]:
%run evaltools.ipynb
In [ ]:
In [24]:
sns.set_style("whitegrid")
context = "talk"
sns.set_context(context)
sns.axes_style()
sns.set_style("whitegrid", {"axes.edgecolor": "0.0", "grid.linestyle": ":"})
# sns.set_context("paper")
In [25]:
datapath
df = read_data(datapath)
output_fn_prefix = "../graphics/paper/"
# this is going to remove unwanted data from the dataset
# df = select_df(df, older_than="2017-10-03 23:00", note="mix 2 cylinder surface + sphere error", remove=True, print_log=True)
df = select_df(df, older_than="2017-10-05 12:00", note_contains="mix 2", remove=True, print_log=True)
df = select_df(df, older_than="2017-10-05 17:00", note_contains="mix 4", remove=True, print_log=True)
In [26]:
df_error = show_violin_separated(df)
In [ ]:
In [27]:
# for k in df.keys():
# print(k)
In [28]:
list_filter(df.keys(), contain="note")
Out[28]:
In [29]:
mw_surf_key = "Wilcoxon Mann Whitney surface error < 0.1 %"
mw_vol_key = "Wilcoxon Mann Whitney vol error < 0.1 %"
maximal_error = 0.001
data = {
"config output note": [],
"wilcoxon volume": [],
"spearman volume": [],
"wilcoxon surface" : [],
"spearman surface" : [],
mw_surf_key: [],
mw_vol_key: [],
"number of samples": [],
"surface mean err": [],
"volume mean err": [],
# "surface mean err test": [],
# "volume mean err test": [],
# "mannwhitneyu volume test": [],
# "mannwhitneyu surface test": [],
}
for note in np.unique(df["config output note"]):
dfs = df[df["config output note"] == note]
# vw, vs, sw, ss = statistic_tests(dfs)
sw, vw = wilcoxon_from_df(dfs)
sm, vm = mannthitneyu_from_df(dfs, maximal_error)
ss, vs = spearman_from_df(dfs)
data["config output note"].append(note)
data["wilcoxon volume"].append(vw.pvalue)
data["spearman volume"].append(vs.pvalue)
data["wilcoxon surface"].append(sw.pvalue)
data["spearman surface"].append(ss.pvalue)
data["number of samples"].append(len(dfs))
# if len(dfs) > 3:
# serrt = np.abs((dfs["surface [mm^2]"] - dfs["numeric surface [mm^2]"]) / dfs["surface [mm^2]"] )
# verrt = np.abs((dfs["volume [mm^3]"] - dfs["numeric volume [mm^3]"]) / dfs["volume [mm^3]"] )
# surf_sh = scipy.stats.mannwhitneyu(serrt, np.ones_like(serrt)*maximal_error, alternative="less")[1]
# vol_sh = scipy.stats.mannwhitneyu(verrt, np.ones_like(verrt)*maximal_error, alternative="less")[1]
# # surf_sh = np.mean(err)
# # surf_sh = scipy.stats.shapiro(dfs["surface [mm^2]"] - dfs["numeric surface [mm^2]"])
# else:
# surf_sh = NaN
# vol_sh = NaN
# serrt = NaN
# verrt = NaN
# Wilcoxon–Mann–Whitney test
data[mw_surf_key].append(sm)
data[mw_vol_key].append(vm)
# data["mannwhitneyu surface test"].append(surf_sh)
# data["mannwhitneyu volume test"].append(vol_sh)
data["surface mean err"].append(np.mean(dfs["surface error [-]"]))
data["volume mean err"].append(np.mean(dfs["volume error [-]"]))
# data["surface mean err test"].append(np.mean(serrt))
# data["volume mean err test"].append(np.mean(verrt))
# show_error(dfs, radius_method=note)
pd.set_option("display.max_rows",101)
pd.DataFrame(data)
pd.DataFrame(data)
Out[29]:
In [30]:
df_graph = show_box(select_df(df, "mix 2 cylinder surface + sphere error"))
df_graph = show_box(select_df(df, "mix 4 cylinder surface + sphere error"))
df_graph = show_box(select_df(df, "mix 6 cylinder surface + sphere error"))
In [ ]:
In [31]:
current_palette = sns.color_palette("deep")
sns.palplot(current_palette)
sns.set_palette(current_palette)
In [32]:
df_graph = show_violin_separated(select_df(df, "mix 4 cylinder surface"))
plt.figure()
df_graph = show_violin_separated(select_df(df, "mix 4 cylinder volume"))
plt.figure()
df_graph = show_violin_separated(select_df(df, "mix 4 cylinder surface + sphere error"))
In [ ]:
In [33]:
# radius_method.find("surface")
In [34]:
dpi = paper_dpi
date = "2017-10-05 21:00"
# for radius_method in available_radius_methods:
for radius_method in [
"inscribed",
"cylinder volume + sphere error",
"cylinder surface + sphere error",
"cylinder surface",
]:
dfs = df[
df[note_key] == "element number " + radius_method
# df["generators Unconnected cylinders radius_distribution_mean"] == 5
]
dfs = dfs[dfs["measurement resolution"] > 10]
dfs = dfs[dfs["element number"] > 10]
dfs = dfs[dfs["measurement resolution"] != 15]
dfs = dfs[dfs["measurement resolution"] != 25]
l1 = len(dfs)
dfs = newer_data(dfs, date)
print("{}/{}".format(len(dfs), l1))
if len(dfs) < 1:
continue
sns.set_context(context)
# surface
if radius_method.find("volume") < 0:
ykey="surface error [mm^2]"
ykey="surface error [%]"
dfs_group = dfs[["element number", "measurement_resolution", ykey]].sort_values(by="element number").groupby(by="measurement_resolution")
# .plot(x="element_number")
fig, ax = plt.subplots(
# figsize=(5,3)
)
# dfs_group.plot(x="element_number", y="surface error [%]", ax=ax)
for label, dfi in dfs_group:
#dfi.plot(x="element number", y=ykey, ax=ax, label="resolution={}".format(label))
dfi.groupby(by="element number").mean().reset_index().plot(x="element number", y=ykey, ax=ax, label="resolution={}".format(label))
# df.vals.plot(x="element_number", ax=ax, label=label)
#plt.legend()
plt.ylabel(ykey)
plt.suptitle(radius_method)
fn = output_fn_prefix + "sensitivity_element_number_surface_" + radius_method
savefig(fn, dataframe=dfs)
# plt.savefig(fn + ".pdf", bbox_inches='tight')
# plt.savefig(fn + ".png", bbox_inches='tight', dpi=dpi)
# volume
if radius_method.find("surface") < 0:
ykey="volume error [mm^3]"
ykey="volume error [%]"
dfs_group = dfs[["element number", "measurement_resolution", ykey]].sort_values(by="element number").groupby(by="measurement_resolution")
# .plot(x="element_number")
fig, ax = plt.subplots(
# figsize=(5,3)
)
# dfs_group.plot(x="element_number", y="surface error [%]", ax=ax)
for label, dfi in dfs_group:
dfi.groupby(by="element number").mean().reset_index().plot(x="element number", y=ykey, ax=ax, label="resolution={}".format(label))
# df.vals.plot(x="element_number", ax=ax, label=label)
#plt.legend()
plt.ylabel(ykey)
plt.suptitle(radius_method)
fn = output_fn_prefix + "sensitivity_element_number_volume_" + radius_method
savefig(fn, dataframe=dfs)
# plt.savefig(fn + ".pdf", bbox_inches='tight')
# plt.savefig(fn + ".png", bbox_inches='tight', dpi=dpi)
In [35]:
# dfs["volume error [%]"]
In [ ]:
In [ ]:
In [ ]:
In [36]:
radius_method = "inscribed"
dfs = df[
df[note_key] == "element number " + radius_method
# df["generators Unconnected cylinders radius_distribution_mean"] == 5
]
k1 = "volume error [%]"
k2 = "measurement_resolution"
k2 in dfs.keys()
sns.lmplot(y=k1, x=k2, data=dfs, order=4,
truncate=True
# logx=True
)
Out[36]:
In [37]:
op.dirname(fn)
Out[37]:
In [38]:
notec = "proof mix"
def create_dir_if_necessary(fn):
if not op.exists(op.dirname(fn)):
import os
os.makedirs(op.dirname(fn))
# notec = "element number"
# notec = "mix 4"
def manwh(dfs, x, y, maximal_error):
serr = np.abs((dfs[x] - dfs[y]) / dfs[x] )
mw = scipy.stats.mannwhitneyu(serr, np.ones_like(serr)*maximal_error, alternative="less")[1]
return mw
def show_anal_vs_num(dfs, x, y, fn, maximal_error=None, save_xls=False, save_subset=True, fn1_fmt=[], fn2_fmt=[]):
create_dir_if_necessary(fn)
sns.lmplot(data=dfs, x=x, y=y, ci=None, line_kws={"c":sns.color_palette()[1], "alpha":0.1})
# sns.lmplot(data=dfs, x="volume [mm^3]", y="numeric volume [mm^3]")
fn1 = fn.format(*fn1_fmt)
fn2 = fn.format(*fn2_fmt) + "_bland_altman"
if save_xls:
if save_subset:
dfs[[x,y]].to_excel(fn1 + ".xls")
else:
dfs.to_excel(fn1 + ".xls")
savefig(fn1)
plt.figure()
mean, diff = bland_altman_plot(dfs[x], dfs[y], c=sns.color_palette()[0])
# plt.suptitle("Bland-Altman plot")
savefig(fn2)
if save_xls:
if save_subset:
dfsav = dfs[[x,y]]
dfsav["Average of two measures"] = mean
dfsav["Difference between two measures"] = mean
dfsav.to_excel(fn2 + ".xls")
if maximal_error is not None:
print(x)
print(manwh(dfs, x, y, maximal_error))
fn = output_fn_prefix + "Figure2/Fig2{}_num_volume_to_anal_volume"
x = "volume [mm^3]"
y = "numeric volume [mm^3]"
dfs = select_df(df, note=notec + " cylinder volume + sphere error")
dfs = dfs[dfs["measurement resolution"] > 20]
show_anal_vs_num(dfs, x, y, fn, maximal_error=maximal_error, fn1_fmt=["B"], fn2_fmt=["D"], save_xls=True)
# dfs1 = [dfs[note]]
In [39]:
x="surface [mm^2]"
y="numeric surface [mm^2]"
fn = output_fn_prefix + "Figure2/Fig2{}_num_surface_to_anal_surface"
# dfs_surface = select_df(df, note=notec + " cylinder surface + sphere error")
dfs_surface = select_df(df, note=notec + " cylinder surface")
show_anal_vs_num(dfs_surface, x, y, fn, maximal_error=maximal_error, fn1_fmt=["A"], fn2_fmt=["C"], save_xls=True)
# sns.lmplot(data=dfs, x="surface [mm^2]", y="numeric surface [mm^2]", line_kws={"c":sns.color_palette()[1], "alpha":0.1})
# # sns.lmplot(data=dfs, x="volume [mm^3]", y="numeric volume [mm^3]")
# savefig("../graphics/num_surface_to_anal_surface")
In [40]:
dfmanual = pd.read_excel("/home/mjirik/Dropbox/science/clanky/2017-tonar/output_rows_modified_newnoise_MB_4-9-2017_errors.xls", skip_footer=1)
In [41]:
for key in dfmanual.keys():
print(key)
In [42]:
maximal_uct_error = 0.20
ren = {
u"uct surface density [mm^-1] (povrchová hustota objektů ve stacku, tj. celkový povrch dělený objemem stacku)": "Micro-CT surface density [mm^-1]",
"measurement surface d. [mm^-1]": "analytic surface density [mm^-1]",
u"uct volume fraction [] (objemový podíl objektů ve stacku)": "Micro-CT volume fraction []",
"measurement volume d. []": "analytic volume fraction []"
}
dfmanualr = dfmanual.rename(columns=ren)
fn = output_fn_prefix + "Figure7/Fig7{}_uct_surface_to_anal_surface"
# dfmanualr["uct surface density [mm^-1]"]
show_anal_vs_num(dfmanualr, "analytic surface density [mm^-1]", "Micro-CT surface density [mm^-1]", fn, maximal_error=maximal_uct_error, save_xls=True, fn1_fmt=["A"], fn2_fmt=["C"])
fn = output_fn_prefix + "Figure7/Fig7{}_uct_volume_to_anal_volume"
show_anal_vs_num(dfmanualr, "analytic volume fraction []", "Micro-CT volume fraction []", fn, maximal_error=maximal_uct_error, fn1_fmt=["B"], fn2_fmt=["D"], save_xls=True)
In [43]:
# notec = "element number"
# == puvodni definice datasetu
dfs = select_df(df, note_contains=notec)
dfs = select_df(dfs, note_contains="surface", remove=True)
dfs = select_df(dfs, note_contains="join", remove=True)
dfs = dfs[dfs["measurement resolution"] > 20]
# ==
# dfs = select_df(dfs, note_contains="mix 4", remove)
save_subset = True
save_all_data = False
xl = "radius method"
yl = "volume error [%]"
anall = "volume [mm^3]"
numerl = "numeric volume [mm^3]"
fn = output_fn_prefix + "Figure2/Fig2F_boxplot_volume"
# def error_boxplot(dfs, yl, xl, fn=None, anall=None, numerl=None, save_all_data=False, save_subset=True)
g = sns.boxplot(data=dfs, y=yl, x=xl, showfliers=False)
labels = [mtext.get_text() for mtext in g.get_xticklabels()]
# pn = labels[2].find("+")
labels[2] = "cylinder volume +\n sphere error"
g.set_xticklabels(labels, rotation=5)
# g.set_xlabel = "compensation method"
# g.set_xlabel("measurement compensation method")
plt.xlabel("")
if save_subset:
savefig(fn)
dfs[[xl, yl, anall, numerl]].to_excel(fn + ".xls")
if save_all_data:
# save all whole data table
savefig(fn, dataframe=dfs)
In [ ]:
In [44]:
dfs = select_df(df, note_contains=notec)
dfs = select_df(dfs, note_contains="volume", remove=True)
dfs = select_df(dfs, note_contains="join", remove=True)
dfs = dfs[dfs["measurement resolution"] > 20]
xl = "radius method"
yl = "surface error [%]"
anall = "surface [mm^2]"
numerl = "numeric surface [mm^2]"
fn = output_fn_prefix + "Figure2/Fig2E_boxplot_surface"
# dfs = select_df(dfs, note_contains="mix 4", remove)
g = sns.boxplot(data=dfs, y=yl, x=xl, showfliers=False)
labels = [mtext.get_text() for mtext in g.get_xticklabels()]
# labels[2] = "cylinder volume +\n sphere error"
g.set_xticklabels(labels, rotation=5)
plt.xlabel("")
if save_subset:
savefig(fn)
dfs[[xl, yl, anall, numerl]].to_excel(fn + ".xls")
if save_all_data:
# save all whole data table
savefig(fn, dataframe=dfs)
In [ ]:
In [45]:
dfs = select_df(df, note_contains=notec)
# dfs = select_df(dfs, note_contains="volume", remove=True)
dfs = select_df(dfs, note_contains="join", remove=True)
dfs = dfs[dfs["measurement resolution"] > 20]
mw_surf_key = "Wilcoxon Mann Whitney surface error < 0.1 %"
mw_vol_key = "Wilcoxon Mann Whitney vol error < 0.1 %"
maximal_error = 0.001
data = {
"config output note": [],
# "wilcoxon volume": [],
"spearman volume": [],
# "wilcoxon surface" : [],
"spearman surface" : [],
mw_surf_key: [],
mw_vol_key: [],
"number of samples": [],
"surface mean err": [],
"volume mean err": [],
# "surface mean err test": [],
# "volume mean err test": [],
# "mannwhitneyu volume test": [],
# "mannwhitneyu surface test": [],
}
for note in np.unique(dfs["config output note"]):
dfsi = dfs[dfs["config output note"] == note]
# vw, vs, sw, ss = statistic_tests(dfs)
sw, vw = wilcoxon_from_df(dfsi)
sm, vm = mannthitneyu_from_df(dfsi, maximal_error)
ss, vs = spearman_from_df(dfsi)
data["config output note"].append(note)
# data["wilcoxon volume"].append(vw.pvalue)
data["spearman volume"].append(vs.pvalue)
# data["wilcoxon surface"].append(sw.pvalue)
data["spearman surface"].append(ss.pvalue)
data["number of samples"].append(len(dfsi))
# if len(dfs) > 3:
# serrt = np.abs((dfs["surface [mm^2]"] - dfs["numeric surface [mm^2]"]) / dfs["surface [mm^2]"] )
# verrt = np.abs((dfs["volume [mm^3]"] - dfs["numeric volume [mm^3]"]) / dfs["volume [mm^3]"] )
# surf_sh = scipy.stats.mannwhitneyu(serrt, np.ones_like(serrt)*maximal_error, alternative="less")[1]
# vol_sh = scipy.stats.mannwhitneyu(verrt, np.ones_like(verrt)*maximal_error, alternative="less")[1]
# # surf_sh = np.mean(err)
# # surf_sh = scipy.stats.shapiro(dfs["surface [mm^2]"] - dfs["numeric surface [mm^2]"])
# else:
# surf_sh = NaN
# vol_sh = NaN
# serrt = NaN
# verrt = NaN
# Wilcoxon–Mann–Whitney test
data[mw_surf_key].append(sm)
data[mw_vol_key].append(vm)
# data["mannwhitneyu surface test"].append(surf_sh)
# data["mannwhitneyu volume test"].append(vol_sh)
data["surface mean err"].append(np.mean(dfsi["surface error [-]"]))
data["volume mean err"].append(np.mean(dfsi["volume error [-]"]))
# data["surface mean err test"].append(np.mean(serrt))
# data["volume mean err test"].append(np.mean(verrt))
# show_error(dfs, radius_method=note)
# pd.set_option("display.max_rows",101)
pd.DataFrame(data)
pd.DataFrame(data)
# mann-whitney by měl vycházet pod 0.05
Out[45]:
In [46]:
uu = g.get_xticklabels()
mtext = uu[0]
mtext.get_text()
Out[46]:
In [47]:
# bland_altman_plot
In [48]:
sns.color_palette()[1]
Out[48]:
In [49]:
# zip(list(dfs_group))
# for radius_method in available_radius_methods:
# radius_method = "inscribed"
# dfs = df[
# df[note_key] == "element number " + radius_method
# # df["generators Unconnected cylinders radius_distribution_mean"] == 5
# ]
dfs = select_df(df, note_contains="element number ")
dfs = select_df(dfs, note_contains="join", remove=True)
dfs = select_df(dfs, note_contains="volume", remove=True)
l1 = len(dfs)
dfs = newer_data(dfs, date)
print("{}/{}".format(len(dfs), l1))
if len(dfs) < 1:
print "blbe"
# continue
xkey="measurement resolution"
ykey="surface error [%]"
# .plot(x="element_number")
sns.set_context("talk")
dfs_group = dfs[[ykey, xkey, note_key]].sort_values(by=xkey).groupby(by=note_key)
fig, ax = plt.subplots(
# figsize=(5,3)
)
# dfs_group.plot(x="element_number", y="surface error [%]", ax=ax)
for label, dfi in dfs_group:
dfi.groupby(by=xkey).mean().abs().reset_index().plot(x=xkey, y=ykey, ax=ax, label="{}".format(label[15:]))
plt.ylabel(ykey)
plt.xlabel(xkey)
fn = output_fn_prefix + "sensitivity_surface_error_to_measurement_resolution"
savefig(fn, dataframe=dfs)
# dfs_group.plot(x=xkey, y=ykey)
xkey="measurement resolution"
ykey="volume error [%]"
# .plot(x="element_number")
sns.set_context("talk")
dfs = select_df(df, note_contains="element number ")
dfs = select_df(dfs, note_contains="join", remove=True)
dfs = select_df(dfs, note_contains="surface", remove=True)
dfs_group = dfs[[ykey, xkey, note_key]].sort_values(by=xkey).groupby(by=note_key)
fig, ax = plt.subplots(
# figsize=(5,3)
)
# dfs_group.plot(x="element_number", y="surface error [%]", ax=ax)
for label, dfi in dfs_group:
dfi.groupby(by=xkey).mean().abs().reset_index().plot(x=xkey, y=ykey, ax=ax, label="{}".format(label[15:]))
plt.ylabel(ykey)
plt.xlabel(xkey)
fn = output_fn_prefix + "sensitivity_volume_error_to_measurement_resolution"
savefig(fn, dataframe=dfs)
In [50]:
sns.lmplot(data=dfs, x="measurement resolution", y="volume error [%]", hue=note_key, order=1, logx=True)
# dfs
Out[50]:
In [51]:
# dfi.groupby(by="measurement_resolution").mean().abs().reset_index().plot(x=xkey, y=ykey, ax=ax, label="resolution={}".format(label))
# dfi
In [52]:
# dfs_group = dfs[["surface error [%]", "measurement_resolution" ]].sort_values(by="measurement_resolution")#.groupby(by="surface error")
# dfs_group
# label
# dfi
In [53]:
dfs = select_df(df, note_contains= "volume fraction")
# dfs = df[
# df[note_key] == "volume fraction overlap inscribed"
# ]
# np.unique(df[note_key])
dfs["numeric volume [mm^3]"]
print(list_filter(dfs.keys(), contain="area"))
# print(list_filter(dfs.keys(), contain="frac"))
volume_fraction = dfs["numeric volume [mm^3]"] / dfs["measurement area volume [mm^3]"]
dfs["volume fraction"] = volume_fraction
print(volume_fraction)
dfs[[note_key, "volume fraction"]]
Out[53]:
ke stažení zde Tenhle má cca 1000 objektů a výpočet zabere kolem 5ti hodin. Ještě se snažím vytvořit větší zaplnění. Až se dostanu přes 50% vygeneruju i obrázky.
In [54]:
id_of_requested_table = 0
dfcinfo = pd.read_html("hardinfo_report.html")[id_of_requested_table]
# df
dfcinfo[(dfcinfo[0] == "Operating System") | (dfcinfo[0] == "Memory") | (dfcinfo[0] == "Processor")]
# memory_str = df[df[0] == "Memory" ].iloc[0][1]
# memory_str[0:memory_str.find(" (")]
Out[54]:
In [55]:
import imtools
import imtools.dili as dili
dfs = select_df(df, note_contains="generated")
req_keys = list(dili.list_contains(dfs.keys(), "time [s]"))
req_keys.append(note_key)
dfsm = dfs[req_keys].groupby(by=note_key).agg(["min", "max", "mean", "std"])
display(dfsm)
In [56]:
dfsm.describe()
Out[56]:
In [57]:
# element number inscribed
dfs = select_df(df, newer_than="2017-10-05", note="element number inscribed")
req_keys = list(dili.list_contains(dfs.keys(), "time [s]"))
req_keys.append(note_key)
dfsm = dfs[req_keys].groupby(by=note_key).agg(["min", "max", "mean", "std"])
display(dfsm)
# display(sns.lmplot(data=dfs, x="element number", y="processing_info step1_total_time_s"))
# display(sns.lmplot(data=dfs[dfs["element number"] == 50], x="measurement_resolution", y="processing_info step1_total_time_s", order=3))
display(sns.lmplot(data=dfs[dfs["element number"] >= 40], x="measurement resolution", y="step 1 time [s]", order=3))
display(sns.lmplot(data=dfs[dfs["measurement resolution"] >= 60], x="element number", y="step 1 time [s]", order=3))
# dili.list_contains(dfs.keys(), "resolution")
In [58]:
import collections
def ordered_dict_to_dict(config):
"""
Use dict instead of ordered dict in structure.
"""
if type(config) == collections.OrderedDict:
config = dict(config)
if type(config) == list:
for i in range(0, len(config)):
config[i] = ordered_dict_to_dict(config[i])
elif type(config) == dict:
for key in config:
config[key] = ordered_dict_to_dict(config[key])
return config
# run_lists
In [59]:
# Save measured
notec = "generated"
dfs = select_df(df, note_contains=notec)
dfs.to_excel(output_fn_prefix + "Dataset1.xls")
dfs.to_csv(output_fn_prefix + "Dataset1.csv")
In [60]:
%run paper_experiments_params.ipynb
config = get_paper_config()
In [61]:
import pprint
pp = pprint.PrettyPrinter(indent=2)
# pp.pprint(config)
config
isinstance(1, collections.Iterable)
new_config = ordered_dict_to_dict(config)
# pp.pprint(new_config)
import yaml
print(yaml.dump(new_config, default_flow_style=False))
# dict(config)
# def sprint(structure, indent=):
# for item in structure
In [62]:
# Analytic to numeric
notec = "proof mix"
dfs = select_df(df, note_contains=notec)
dfs.to_excel(output_fn_prefix + "Dataset2.xls")
dfs.to_csv(output_fn_prefix + "Dataset2.csv")
config_select = select_configs(configs, [notec])
config = config_select[0]
new_config = ordered_dict_to_dict(config)
# pp.pprint(new_config)
print(yaml.dump(new_config, default_flow_style=False))
In [63]:
# Sensitivity
notec = "element number"
dfs = select_df(df, note_contains=notec)
dfs.to_excel(output_fn_prefix + "Dataset3.xls")
dfs.to_csv(output_fn_prefix + "Dataset3.csv")
config_select = select_configs(configs, [notec])
config = config_select[0]
new_config = ordered_dict_to_dict(config)
# pp.pprint(new_config)
print(yaml.dump(new_config, default_flow_style=False))