We have successfully used a combination of configuration and customization in use cases such as Fraud Detection, IT Infrastructure Modeling, Communication Analysis, Source Code Refactoring, Workflow Analysis, Process Mining and more. Below are brief examples of two common scenarios where we used Graphlytic : Data Modeling and Communication Analysis.
Graph Modeling With Graphlytic
Video below shows how easy is to model graphs (nodes and relationships) with Graphlytic.
First I'm going to create four nodes - two of them with the "Company" label and the other two with the "Person" label. Then I'm going to create relationships based on the ownership structure - in this case Person 1 owning some part of both companies and Person 2 owning part of the Company 2.
Next I'm going to add the "name" property to each node with values like "Person 1", "Person 2" etc.
After modeling I'm going to style the visualization a little bit and save it to my visualization for some later work or for sharing with other users.
Communication And Process Analysis With Graphlytic
Over the years of using graphs for workflow, process, and communication analysis we have developed a set of features in Graphlytic that allows us to do this kind of work using graph models with large numbers of parallel relationships. This kind of model has it's pros and cons but the pros are in our opinion really good and the cons are at least manageable.
Graph model in such case is really simple:
- In workflow or process analysis : nodes are representing states that analyzed entities can be in and relationships are representing events where some entity has changed its state. Such relationship has to have at least the entity_id and timestamp properties.
- In communication analysis : nodes are representing entities that can communicate (e.g. people or machines) and relationships are representing communication (e.g. call or message). Such relationship has to have at least the entity_id and timestamp properties.
Of course this approach can be used only if your events are connecting exactly two nodes which is not always the case but we have found that most of the time it can be used and the result has some nice features:
- Simple graph model - most of the time there is only 1 type of node in the graph (1 label) e.g. "Person" in communication analysis or "State" in workflow/process analysis.
- Very few transformations during import and update of graph data - basically what we are importing are logs and every row from such log is represented with one relationship in the graph. This leads to easy data updating with a much lower chance of getting an inconsistent state in the graph.
- More data visualized with smaller and easy to understand graphs - unlike in traditional models used e.g. for fraud detection where events are modeled with nodes, the parallel model we use is roughly one-third of the size in number of nodes and relationships needed to communicate the same amount of source data.
Features implemented in Graphlytic for parallel models:
Virtual Relationship Models
it's not possible to effectively work with such model in visualization because the parallel relationships are cluttering the visualization. Graphlytic has a feature exactly for such case - Virtual Relationships models. With one click it's possible to merge parallel relationships into one relationship in the visualization representing all the parallel relationships. It's possible to merge all parallel relationships without considering the direction or it's possible to merge parallel relationships with the same direction (then there can be max two relationships between any two nodes with opposite direction).
- Documentation : Tools Panel
- Documentation : Virtual Properties
When the timestamp is stored on every relationship (date and time of the event occurrence) Graphlytic's Timeline feature can be used to visualize only some time interval. This way it's quite easy to compare visualizations for different time periods like months or days.
- Documentation : Timeline
This is how parallel model looks like in Neo4j browser:
This is how parallel models are handled in Graphlytic: