def test_case_statistics(self):
from pm4py.statistics.traces.pandas import case_statistics
df = self.get_dataframe()
case_statistics.get_cases_description(df)
case_statistics.get_variants_df(df)
case_statistics.get_variant_statistics(df)
#case_statistics.get_variant_statistics_with_case_duration(df)
case_statistics.get_events(df, "N77802")
case_statistics.get_variants_df_with_case_duration(df)
case_statistics.get_variants_df_and_list(df)
case_statistics.get_kde_caseduration(df)
def get_case_statistics(self, parameters=None):
"""
Gets the statistics on cases
Parameters
-------------
parameters
Possible parameters of the algorithm
Returns
-------------
list_cases
List of cases
"""
if parameters is None:
parameters = {}
parameters[
constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = self.activity_key
parameters[
constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY] = self.activity_key
if self.reduced_grouped_dataframe is not None:
parameters[
constants.GROUPED_DATAFRAME] = self.reduced_grouped_dataframe
# parameters["max_ret_cases"] = ws_constants.MAX_NO_CASES_TO_RETURN
parameters["sort_by_column"] = parameters[
"sort_by_column"] if "sort_by_column" in parameters else "caseDuration"
parameters["sort_ascending"] = parameters[
"sort_ascending"] if "sort_ascending" in parameters else False
if "variant" in parameters:
var_to_filter = parameters["variant"]
# TODO: TECHNICAL DEBT
# quick turnaround for bug
var_to_filter = var_to_filter.replace(" start", "+start")
var_to_filter = var_to_filter.replace(" START", "+START")
var_to_filter = var_to_filter.replace(" complete", "+complete")
var_to_filter = var_to_filter.replace(" COMPLETE", "+COMPLETE")
filtered_dataframe = variants_filter.apply(
self.get_reduced_dataframe(), [var_to_filter],
parameters=parameters)
return [
casestats.include_key_in_value_list(
case_statistics.get_cases_description(
filtered_dataframe, parameters=parameters))
] + [self.get_log_summary_dictio()]
else:
return [
casestats.include_key_in_value_list(
case_statistics.get_cases_description(
self.get_reduced_dataframe(), parameters=parameters))
] + [self.get_log_summary_dictio()]
def get_cases(path, log_name, managed_logs, parameters=None):
if parameters is None:
parameters = {}
no_samples = parameters[
PARAMETER_NO_SAMPLES] if PARAMETER_NO_SAMPLES in parameters else DEFAULT_MAX_NO_SAMPLES
use_transition = parameters[
PARAMETER_USE_TRANSITION] if PARAMETER_USE_TRANSITION in parameters else DEFAULT_USE_TRANSITION
window_size = parameters[
PARAMETER_NUM_RET_ITEMS] if PARAMETER_NUM_RET_ITEMS in parameters else DEFAULT_WINDOW_SIZE
start = parameters[PARAMETER_START] if PARAMETER_START in parameters else 0
activity_key = DEFAULT_NAME_KEY if not use_transition else PARAMETER_PM4PYWS_CLASSIFIER
filters = parameters[FILTERS] if FILTERS in parameters else []
parameters[pm4py_constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = activity_key
folder = os.path.join(path, log_name)
columns = get_columns_to_import(
filters, [CASE_CONCEPT_NAME, DEFAULT_NAME_KEY, DEFAULT_TIMESTAMP_KEY],
use_transition=use_transition)
parquet_list = parquet_importer.get_list_parquet(folder)
cases_list = []
events = 0
cases = 0
count = 0
for index, pq in enumerate(parquet_list):
pq_basename = Path(pq).name
if pq_basename in managed_logs:
count = count + 1
df = get_filtered_parquet(pq,
columns,
filters,
use_transition=use_transition,
parameters=parameters,
force_classifier_insertion=True)
events = events + len(df)
cases = cases + df[CASE_CONCEPT_NAME].nunique()
stats = case_statistics.get_cases_description(df)
c_list = []
for x, y in stats.items():
c_list.append({
"caseId": x,
"caseDuration": y["caseDuration"],
"startTime": y["startTime"],
"endTime": y["endTime"]
})
cases_list = sorted(cases_list + c_list,
key=lambda x: x["caseDuration"],
reverse=True)
cases_list = cases_list[start:min(len(cases_list), window_size)]
if count >= no_samples:
break
return {"cases_list": cases_list, "events": events, "cases": cases}
def get_case_duration(path, log_name, managed_logs, parameters=None):
if parameters is None:
parameters = {}
no_samples = parameters[
PARAMETER_NO_SAMPLES] if PARAMETER_NO_SAMPLES in parameters else DEFAULT_MAX_NO_SAMPLES
use_transition = parameters[
PARAMETER_USE_TRANSITION] if PARAMETER_USE_TRANSITION in parameters else DEFAULT_USE_TRANSITION
activity_key = DEFAULT_NAME_KEY if not use_transition else "@@classifier"
filters = parameters[FILTERS] if FILTERS in parameters else []
parameters[pm4py_constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = activity_key
parameters[pm4py_constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY] = activity_key
max_no_of_points_to_sample = parameters[
"max_no_of_points_to_sample"] if "max_no_of_points_to_sample" in parameters else 100000
folder = os.path.join(path, log_name)
columns = get_columns_to_import(filters,
[CASE_CONCEPT_NAME, DEFAULT_TIMESTAMP_KEY],
use_transition=use_transition)
parquet_list = parquet_importer.get_list_parquet(folder)
overall_list = []
count = 0
for index, pq in enumerate(parquet_list):
pq_basename = Path(pq).name
if pq_basename in managed_logs:
count = count + 1
df = get_filtered_parquet(pq,
columns,
filters,
use_transition=use_transition,
parameters=parameters)
cases = case_statistics.get_cases_description(df,
parameters=parameters)
duration_values = [x["caseDuration"] for x in cases.values()]
overall_list = overall_list + duration_values
if count >= no_samples:
break
overall_list = sorted(overall_list)
if len(overall_list) > max_no_of_points_to_sample:
overall_list = points_subset.pick_chosen_points_list(
max_no_of_points_to_sample, overall_list)
return overall_list
def average_case_duration(
df: pd.DataFrame,
t1: Union[datetime, str],
t2: Union[datetime, str],
r: str,
parameters: Optional[Dict[str, Any]] = None) -> float:
"""
The average duration of cases completed during a given time slot in which a given resource was involved.
Metric RBI 4.4 in Pika, Anastasiia, et al.
"Mining resource profiles from event logs." ACM Transactions on Management Information Systems (TMIS) 8.1 (2017): 1-30.
Parameters
-----------------
df
Dataframe
t1
Left interval
t2
Right interval
r
Resource
Returns
----------------
metric
Value of the metric
"""
if parameters is None:
parameters = {}
resource_key = exec_utils.get_param_value(
Parameters.RESOURCE_KEY, parameters,
xes_constants.DEFAULT_RESOURCE_KEY)
from pm4py.algo.filtering.pandas.attributes import attributes_filter
parameters_filter = {
attributes_filter.Parameters.ATTRIBUTE_KEY: resource_key
}
df = attributes_filter.apply(df, [r], parameters=parameters_filter)
from pm4py.algo.filtering.pandas.timestamp import timestamp_filter
df = timestamp_filter.filter_traces_intersecting(df,
t1,
t2,
parameters=parameters)
from pm4py.statistics.traces.pandas import case_statistics
cd = case_statistics.get_cases_description(df,
parameters=parameters).values()
return mean(x["caseDuration"] for x in cd)
def execute_script():
aa = time.time()
dataframe = csv_import_adapter.import_dataframe_from_path_wo_timeconversion(
inputLog, sep=',')
dataframe = csv_import_adapter.convert_caseid_column_to_str(
dataframe, case_id_glue=CASEID_GLUE)
dataframe = csv_import_adapter.convert_timestamp_columns_in_df(
dataframe, timest_format=TIMEST_FORMAT, timest_columns=TIMEST_COLUMNS)
dataframe = dataframe.sort_values([CASEID_GLUE, TIMEST_KEY])
dataframe_fa = attributes_filter.filter_df_keeping_spno_activities(
dataframe,
activity_key=ACTIVITY_KEY,
max_no_activities=MAX_NO_ACTIVITIES)
bb = time.time()
print("importing log time=", (bb - aa))
parameters_cde = {
constants.PARAMETER_CONSTANT_CASEID_KEY: CASEID_GLUE,
constants.PARAMETER_CONSTANT_TIMESTAMP_KEY: TIMEST_KEY,
"sort_by_column": "caseDuration",
"sort_ascending": False,
"max_ret_cases": 1000
}
cases_desc = case_statistics.get_cases_description(
dataframe, parameters=parameters_cde)
print(cases_desc)
bb2 = time.time()
print("calculating and printing cases_desc = ", (bb2 - bb))
calculate_process_schema_from_df(dataframe_fa, "NOFILTERS_FREQUENCY.svg",
"NOFILTERS_PERFORMANCE.svg")
GENERATED_IMAGES.append("NOFILTERS_FREQUENCY.svg")
GENERATED_IMAGES.append("NOFILTERS_PERFORMANCE.svg")
if DELETE_VARIABLES:
del dataframe_fa
cc = time.time()
print(
"saving initial Inductive Miner process schema along with frequency metrics=",
(cc - bb2))
dataframe_cp = case_filter.filter_on_case_performance(
dataframe,
case_id_glue=CASEID_GLUE,
timestamp_key=TIMEST_KEY,
min_case_performance=100000,
max_case_performance=10000000)
dataframe_cp_fa = attributes_filter.filter_df_keeping_spno_activities(
dataframe_cp,
activity_key=ACTIVITY_KEY,
max_no_activities=MAX_NO_ACTIVITIES)
dataframe_cp = None
if DELETE_VARIABLES:
del dataframe_cp
calculate_process_schema_from_df(dataframe_cp_fa,
"FILTER_CP_FREQUENCY.svg",
"FILTER_CP_PERFORMANCE.svg")
GENERATED_IMAGES.append("FILTER_CP_FREQUENCY.svg")
GENERATED_IMAGES.append("FILTER_CP_PERFORMANCE.svg")
if DELETE_VARIABLES:
del dataframe_cp_fa
dd = time.time()
print("filtering on case performance and generating process schema=",
(dd - cc))
if ENABLE_ATTRIBUTE_FILTER:
parameters_att = {
constants.PARAMETER_CONSTANT_CASEID_KEY: CASEID_GLUE,
constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY: ATTRIBUTE_TO_FILTER,
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: ATTRIBUTE_TO_FILTER,
"positive": True
}
dataframe_att = attributes_filter.apply(dataframe,
ATTRIBUTE_VALUES_TO_FILTER,
parameters=parameters_att)
# dataframe_att = attributes_filter.apply_auto_filter(dataframe, parameters=parameters_att)
print(
"all the activities in the log",
attributes_filter.get_attribute_values(dataframe_att,
ACTIVITY_KEY))
dataframe_att_fa = attributes_filter.filter_df_keeping_spno_activities(
dataframe_att,
activity_key=ACTIVITY_KEY,
max_no_activities=MAX_NO_ACTIVITIES)
if DELETE_VARIABLES:
del dataframe_att
calculate_process_schema_from_df(dataframe_att_fa,
"FILTER_ATT_FREQUENCY.svg",
"FILTER_ATT_PERFORMANCE.svg")
GENERATED_IMAGES.append("FILTER_ATT_FREQUENCY.svg")
GENERATED_IMAGES.append("FILTER_ATT_PERFORMANCE.svg")
if DELETE_VARIABLES:
del dataframe_att_fa
ee = time.time()
print("filtering on attribute values and generating process schema=",
(ee - dd))
ee = time.time()
parameters_sa = {
constants.PARAMETER_CONSTANT_CASEID_KEY: CASEID_GLUE,
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: ACTIVITY_KEY
}
parameters_ea = {
constants.PARAMETER_CONSTANT_CASEID_KEY: CASEID_GLUE,
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: ACTIVITY_KEY
}
start_act = start_activities_filter.get_start_activities(
dataframe, parameters=parameters_sa)
print("start activities in the log = ", start_act)
end_act = end_activities_filter.get_end_activities(
dataframe, parameters=parameters_ea)
print("end activities in the log = ", end_act)
ff = time.time()
print("finding start and end activities along with their count", (ff - ee))
if ENABLE_STARTACT_FILTER:
dataframe_sa = start_activities_filter.apply(dataframe,
STARTACT_TO_FILTER,
parameters=parameters_sa)
# dataframe_sa = start_activities_filter.apply_auto_filter(dataframe, parameters=parameters_sa)
start_act = start_activities_filter.get_start_activities(
dataframe_sa, parameters=parameters_sa)
print("start activities in the filtered log = ", start_act)
dataframe_sa_fa = attributes_filter.filter_df_keeping_spno_activities(
dataframe_sa,
activity_key=ACTIVITY_KEY,
max_no_activities=MAX_NO_ACTIVITIES)
if DELETE_VARIABLES:
del dataframe_sa
calculate_process_schema_from_df(dataframe_sa_fa,
"FILTER_SA_FREQUENCY.svg",
"FILTER_SA_PERFORMANCE.svg")
GENERATED_IMAGES.append("FILTER_SA_FREQUENCY.svg")
GENERATED_IMAGES.append("FILTER_SA_PERFORMANCE.svg")
if DELETE_VARIABLES:
del dataframe_sa_fa
gg = time.time()
if ENABLE_STARTACT_FILTER:
print("filtering start activities time=", (gg - ff))
if ENABLE_ENDACT_FILTER:
dataframe_ea = end_activities_filter.apply(dataframe,
ENDACT_TO_FILTER,
parameters=parameters_ea)
# dataframe_ea = end_activities_filter.apply_auto_filter(dataframe, parameters=parameters_ea)
end_act = end_activities_filter.get_end_activities(
dataframe_ea, parameters=parameters_ea)
print("end activities in the filtered log = ", end_act)
dataframe_ea_fa = attributes_filter.filter_df_keeping_spno_activities(
dataframe_ea,
activity_key=ACTIVITY_KEY,
max_no_activities=MAX_NO_ACTIVITIES)
if DELETE_VARIABLES:
del dataframe_ea
calculate_process_schema_from_df(dataframe_ea_fa,
"FILTER_EA_FREQUENCY.svg",
"FILTER_EA_PERFORMANCE.svg")
GENERATED_IMAGES.append("FILTER_EA_FREQUENCY.svg")
GENERATED_IMAGES.append("FILTER_EA_PERFORMANCE.svg")
if DELETE_VARIABLES:
del dataframe_ea_fa
hh = time.time()
if ENABLE_ENDACT_FILTER:
print("filtering end activities time=", (hh - gg))
if REMOVE_GENERATED_IMAGES:
for image in GENERATED_IMAGES:
os.remove(image)