def __set_df(self, gzip_path, gzip_filename):
if not self.with_gzip:
return ResultsToDataframe(self.results_reader).create_full_df()
assert (self.key == 'global')
assert gzip_path
assert gzip_filename
gzip_results_reader = GzipResultsReader(gzip_path, gzip_filename)
return ResultsToDataframe(
self.results_reader).create_full_df(gzip_results_reader)
def __init__(self, path, mode='global', datasets_names=None):
assert (len(self.HEIGHT_RATIOS) == len(self.PLOTS_MATRIX))
PDFSCommon.check_valid_mode(mode)
self.df_NM = ResultsToDataframe(ResultsReader(mode,
"NM")).create_full_df()
self.df_M = ResultsToDataframe(ResultsReader(mode,
"M")).create_full_df()
self.col_index = None # iteration variable
super(PDFS2, self).__init__(path + mode + "/", mode, datasets_names)
def __calculate_percentage(self):
for value in range(1, self.data_columns_count + 1): # [1, ... ]
data_col_key = ResultsToDataframe.data_column_key(value)
percentage_col_key = ResultsToDataframe.percentage_column_key(value)
new_percentage_col_key = 'new_' + percentage_col_key
base_coder_total = PandasMethods.coder_df(self.df, "CoderBase")[data_col_key].iloc[0]
self.df[new_percentage_col_key] = 100 * (self.df[data_col_key] / base_coder_total)
self.__check_difference(percentage_col_key, new_percentage_col_key)
# rename percentages column
self.df.rename(columns={new_percentage_col_key: percentage_col_key}, inplace=True)
def min_value_for_each_threshold(self, coder_name, column_index):
data_column_key = ResultsToDataframe.data_column_key(column_index)
coder_df = PandasMethods.coder_df(self.df, coder_name)
new_df = pd.DataFrame(columns=self.df.columns)
for index, threshold in enumerate(ExperimentsUtils.THRESHOLDS):
new_df.loc[index] = PandasMethods.get_min_row(coder_df, data_column_key, threshold).values
return new_df
def calculate_relative_diff(row_df_pca, row_df_apca, col_index):
data_column_key = ResultsToDataframe.data_column_key(col_index)
size_pca, size_apca = row_df_pca[data_column_key], row_df_apca[
data_column_key]
relative_diff = MathUtils.relative_difference(size_pca, size_apca)
coder_name = 'PCA' if size_pca < size_apca else 'APCA'
return round(relative_diff, 2), coder_name
def get_values(coder_name, col_index, panda_utils):
percentage_column_key = ResultsToDataframe.percentage_column_key(
col_index)
# print panda_utils.df
df = panda_utils.min_value_for_each_threshold(coder_name, col_index)
values = df[percentage_column_key].values
df_min = df[percentage_column_key].min()
df_max = df[percentage_column_key].max()
return values, df_min, df_max
def __init__(self, path, datasets_names=None):
assert (len(self.HEIGHT_RATIOS) == len(self.PLOTS_MATRIX))
self.df_M_local = ResultsToDataframe(ResultsReader(
'local', "M")).create_full_df()
self.df_M_global = ResultsToDataframe(ResultsReader(
'global', "M")).create_full_df()
self.path = path
self.dataset_names = datasets_names or ExperimentsUtils.datasets_with_multiple_files(
)
self.mode = 'local'
# iteration variables
self.dataset_id = None
self.dataset_name = None
self.filename = None
self.pdf_name = None
self.col_index = None
self.pd_utils_3_global = None
self.latex_table_data = {}
def min_value_for_threshold(self, coder_name, column_index, threshold, nth=None):
assert(threshold in ExperimentsUtils.THRESHOLDS)
data_column_key = ResultsToDataframe.data_column_key(column_index)
coder_df = PandasMethods.coder_df(self.df, coder_name) if coder_name is not None else self.df
min_row = PandasMethods.get_min_row(coder_df, data_column_key, threshold, nth)
return min_row
def create_plots(coders_array, _, panda_utils_NM, panda_utils_M, col_index, options={}):
key = ResultsToDataframe.data_column_key(col_index)
klass = RelativeDifferenceStats
return RelativeDifferenceStats.create_plot_common(coders_array, panda_utils_NM, panda_utils_M, col_index, key, klass, options)
def parse_total_bits(row_df, col_index):
total_bits_key = ResultsToDataframe.data_column_key(col_index)
total_bits = row_df[total_bits_key]
return int(total_bits)
def parse_percentage(row_df, col_index):
percentage_key = ResultsToDataframe.percentage_column_key(col_index)
percentage = round(row_df[percentage_key] / 100, 2)
return percentage
def calculate_RD(row_df_best, row_df_compare, col_index):
data_column_key = ResultsToDataframe.data_column_key(col_index)
size_best, size_compare = row_df_best[data_column_key], row_df_compare[
data_column_key]
relative_diff = MathUtils.relative_difference(size_compare, size_best)
return round(relative_diff, 2)