Skip to content

ergminer.discovery

ergminer.discover_erg(log, case_id_col='case_id', activity_col='activity_name', timestamp_col='timestamp', resource_col=None, activity_mapping=None, delay_config=None, case_attributes=None, remove_incomplete_traces=True, min_events_per_trace=2, erg_name='Mined_ERG', verbose=False)

Mine an Event Relationship Graph (ERG) from an event log DataFrame.

Parameters:

Name Type Description Default
log DataFrame

Event log DataFrame (as returned by read_csv() or format_dataframe()).

 required
case_id_col str

Column name for case identifiers.

 'case_id'
activity_col str

Column name for activity names.

 'activity_name'
timestamp_col str

Column name for timestamps.

 'timestamp'
resource_col Optional[str]

Column name for resource identifiers (optional).

 None
activity_mapping Optional[Dict[str, str]]

Manual mapping of activity names to queueing types (optional).

 None
delay_config Optional['DelayConfig']

DelayConfig instance to control distribution fitting behaviour (optional, uses defaults).

 None
case_attributes Optional[List[str]]

Extra case-level attribute columns to use for guard detection (optional).

 None
remove_incomplete_traces bool

Drop incomplete/partial traces before mining.

 True
min_events_per_trace int

Minimum events a trace must have to be kept.

 2
erg_name str

Name embedded in the resulting ERG object.

 'Mined_ERG'
verbose bool

Print step-by-step progress to stdout.

 False

Returns:

Type Description
'ERG'

Fully mined ERG object.
Source code in src\ergminer\discovery.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
def discover_erg(
    log: pd.DataFrame,
    case_id_col: str = 'case_id',
    activity_col: str = 'activity_name',
    timestamp_col: str = 'timestamp',
    resource_col: Optional[str] = None,
    activity_mapping: Optional[Dict[str, str]] = None,
    delay_config: Optional['DelayConfig'] = None,
    case_attributes: Optional[List[str]] = None,
    remove_incomplete_traces: bool = True,
    min_events_per_trace: int = 2,
    erg_name: str = 'Mined_ERG',
    verbose: bool = False,
) -> 'ERG':
    """Mine an Event Relationship Graph (ERG) from an event log DataFrame.

    Args:
        log:                      Event log DataFrame (as returned by ``read_csv()``
                                  or ``format_dataframe()``).
        case_id_col:              Column name for case identifiers.
        activity_col:             Column name for activity names.
        timestamp_col:            Column name for timestamps.
        resource_col:             Column name for resource identifiers (optional).
        activity_mapping:         Manual mapping of activity names to queueing
                                  types (optional).
        delay_config:             ``DelayConfig`` instance to control distribution
                                  fitting behaviour (optional, uses defaults).
        case_attributes:          Extra case-level attribute columns to use for
                                  guard detection (optional).
        remove_incomplete_traces: Drop incomplete/partial traces before mining.
        min_events_per_trace:     Minimum events a trace must have to be kept.
        erg_name:                 Name embedded in the resulting ``ERG`` object.
        verbose:                  Print step-by-step progress to stdout.

    Returns:
        Fully mined ``ERG`` object.
    """
    from .erg_miner import ERGMiner

    miner = ERGMiner(verbose=verbose, delay_config=delay_config)
    erg = miner.mine(
        dataframe=log,
        case_id_col=case_id_col,
        activity_col=activity_col,
        timestamp_col=timestamp_col,
        resource_col=resource_col,
        activity_mapping=activity_mapping,
        case_attributes=case_attributes,
        remove_incomplete_partial_traces=remove_incomplete_traces,
        min_events_per_trace=min_events_per_trace,
        erg_name=erg_name,
    )
    return erg