viz_fuzzy_model: Visualize Process Model
In PlaypowerLabs/fuzzymineR: Build Fuzzy Process Model from Event Data

Description Usage Arguments Details Graph Customization See Also Examples

View source: R/viz_fuzzy_model.R

Takes a metrics mined by mine_fuzzy_model function and a number of other configurable parameters, creates a process model for it.

viz_fuzzy_model(
  metrics,
  node_sig_threshold = 0,
  edge_sig_threshold = 0.4,
  edge_sig_to_corr_ratio = 0.75,
  preserve_threshold = 0.4,
  offset_threshold = 0.1,
  node_sig_weights = c(freq = 1, routing = 1),
  sig_weights = c(freq = 1, dist = 1),
  corr_weights = c(prox = 1, end_point = 1, originator = 1, data_type = 1, data_value =
    1)
)

`metrics`	A list of metrics created by mine_fuzzy_model
`node_sig_threshold`	Numeric Value between 0 and 1 which specifies threshold level for preserving nodes in the process model. Nodes having significance value less than this will be either clustered or isolated nodes will be removed from the graph
`edge_sig_threshold`	Numeric Value between 0 and 1 which specifies threshold to filter edges. Edges having local importance less than this threshold will be removed from the process model.
`edge_sig_to_corr_ratio`	Numeric Value between 0 and 1 which specifies the weights for edge significance metrics and edge correlation metrics. Higher the value, more importance is given to the significance metrics.
`preserve_threshold`	Numeric Value between 0 and 1 which is used for removing the conflicting edges.
`offset_threshold`	Numeric Value between 0 and 1 which is used to remove less significant edge in case of conflicting edges or to determine concurrency
`node_sig_weights`	Numeric Vector of length 2. Each value is between 0 and 1 determining the weights given to frequency metric and routing metric respectively.
`sig_weights`	Numeric vector of length 2. Each value between 0 and 1 which determinesthe weights of freqency binary metric and distance metric respectively.
`corr_weights`	Numeric vector of length 5. Each value between 0 and 1. It represents weights of proximity, endpoint, originator, data type and data value correlation respectively.

viz_fuzzy_model generates a fuzzy process map based on the configurable parameters that are provided by the user. For creating a process model, the metrics are aggregated into two types of metrics - aggregated node metrics and aggregated edge metrics. These 2 aggregated metrics contain the weighted sum of the metrics that we provide as input and which were mined by the function mine_fuzzy_model. By default, all the metrics are given equal weigth but we can change as per your requirments.

For gaining more knowledge about these aggregate metrics and what are their importance please visit Fuzzy Mining - Adaptive Process Simplification Based on Multi-Perspective Metrics. All detailed description is provided here. After reading this you will gain insights about how much weights you should give to each of the metrics given your usage and event data structure.

One of the most powerful feature of this fuzzy process model is that it is fully customizable. We can change the filtering parameters and can get more simplistic graph which contains only the most significant information. Configurable filtering parameters are - node_sig_threshold, edge_sig_threshold, preserve_threshold and offset_threshold.

This is the most important feature of fuzzy process model which would not be possible by other traditional mining algorithms. Simplification of graph takes place by these 3 steps which are explained in detail so that the user can get the idea about what filtering parameters they should set so that they get the desired simplified process model.

Step 1 : Removing Conflicting Edges

When there is an edge from A to B and also from B to A then they are said to be in conflict. Now these conflicting edges can be categorised into - Concurrent edges, One strong Edge and other weak edge, length-2 loop. For this we have 2 filtering parameters - preserve threshold and offset threshold.

First we calculate Relative Significance for each of the conflicting edges. This gives us the local significance of that edge with respect to others. It's mathematical formulation can be given as :

rel(A,B)=(sig(A,B))/(2*∑ sig(A,X)) + (sig(A,B))/(2*∑ sig(X,B))

rel(B,A)=(sig(B,A))/(2*∑ sig(B,X)) + (sig(B,A))/(2*∑ sig(X,A))

rel(A,B) gives the local importance of the edge from A to B with respect to all the outgoing edges from A and all the incoming edges to B. If the value of rel(A,B) is higher, than the importance of that edge with respect to A and B is more. Similar reasoning goes with rel(B,A).

Case 1 : If both rel(A,B) and rel(B,A) is more than preserve threshold than these edges form a length-2 loop.

rel(A,B) ≥ preserve_threshold \& rel(B,A) ≥ preserve_threshold => length-2 loop

Case 2 : If one of the edges have relative significance less than the preserve threshold and difference between both the relative significance is less than the offset threshold means that there is concurrency between both the activities. Hence we remove both the edges.

Case 3 : If one of the edges have relative significance less than the preserve threshold and difference between both the relative significance is more than the offset threshold than we remove the weaker edge(one which has lower relative significance).

Step 2 : Edge Filtering

In this step we first calculate relative significance for all the edges and remove the edges whose relative significance is lower than the edge_sig_threshold parameter. At last to make sure that the graph remains connected we revive single edge for the nodes whose all the edges were removed due to edge filtering.

Step 3 : Node Filtering and Clustering of nodes

In this step, we mark the nodes whose aggregate node significance is less than the node_sig_threshold. We than cluster the nodes if possible and remove the isolated nodes from the process model. We preserve the ordering relation of the node that is removed by transitivity.

create_eventlog, mine_fuzzy_model

## Not run: 
#' library(fuzzymineR)
data("artificial_loan_process")
log <- create_eventlog(artificial_loan_process,
                       case_id = "case",
                       activity_id = "event",
                       timestamp = "completeTime")
metrics <- mine_fuzzy_model(log)
viz_fuzzy_model(metrics = metrics,
    node_sig_threshold = 0,
    edge_sig_threshold = 0.3,
    edge_sig_to_corr_ratio = 0.75)

## End(Not run)