<p align="center">
<img src="DyLoPro.png" alt="DyLoPro logo" width="400" height="400">
</p>
#
The *DyLoPro Python Library* is a **visual analytics** tool that allows
**Process Mining (PM)**[^1] practitioners to efficiently and comprehensively
explore the **dynamics** in **event logs** over time, prior to applying PM
techniques. These **comprehensive exploration capabilities** are provided
by extensive set of plotting functionalities, visualizing the
dynamics over time from different **process perspectives**.
[^1]: van der Aalst, W. (2016). Data Science in Action. In: Process Mining. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-662-49851-4_1
https://en.wikipedia.org/wiki/Process_mining
> DyLoPro library is ready-to-use and efficient software implementation of the
> identically named **_DyLoPro framework_**, introduced in the paper
> ***DyLoPro: Profiling the Dynamics of Event Logs***, which will be
> presented at the [BPM 2023](https://bpm2023.sites.uu.nl/) conference in
> Utrecht, and accordingly published in its main proceedings.
> A preprint of the (already peer-reviewed) BPM paper can be found
> [here](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf).
_DyLoPro is a comprehensive visual analytics framework designed to
explore event log dynamics over time. DyLoPro’s comprehensiveness
is achieved through the incorporation of the main process
perspectives - the control-flow, data (including resources) and
performance, along two orthogonal dimensions of log concepts and
representation types. It incorporates six log concepts to capture
all essential information from event logs, including variants and
directly-follows relations for the control-flow perspective, and
categorical and numeric case and event features for the data
perspective. These six log concepts can be represented using
five representation types, including four performance-oriented
ones (throughput time, number of events per case, outcome, and
directly-follows-relations’ performance) and one generic type.
With this two-dimensional approach, end users can gain a nuanced
and holistic view of event log dynamics, efficiently identifying
patterns, temporary or permanent changes, and trends of interest
from multiple perspectives. Upon identification, they can further
analyze these patterns and trends, ultimately leading to more
appropriate application of downstream process mining techniques._
## Documentation
You can consult the documentation of DyLoPro [__here__](https://DyLoPro.readthedocs.io).
The following terms are used interchangeably throughout the documentation:
- *'case'* and *'trace'*
- *'time period'*, *'time bucket'* and *'time interval'*
## Installation
You can install DyLoPro using:
```bash
pip install DyLoPro
```
The DyLoPro PyPi page can be consulted [here](https://pypi.org/project/DyLoPro/).
## Requirements
__DyLoPro__ depends on the following Python packages:
- numpy *(version >=1.21.5)*
- pandas *(version >=2.0.2)*
- matplotlib *(version >=3.7.1)*
- tqdm *(version >=4.63.0)*
If (some of) these requirements are not satisfied yet, then these packages will automatically be installed when [installing __DyLoPro__](#installation).
## Get Started
### Assumptions & Terminology
For the moment, DyLoPro assumes flat event logs, and does not cater to object-centric
event logs. DyLoPro also regards events to be the atomic unit of the event log.
In other words, the execution of a single event is recorded as a single row in the
resulting event log. For the terminology and definitions employed by the
'DyLoPro' Python package, please refer to *Section 3 (Preliminaries)* of the
[corresponding academic paper](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf).
### Step 1: Initializing a ``DynamicLogPlots`` instance
Assuming that you have already loaded an event log into a pd.DataFrame called
e.g. ``event_log``.
After having imported the DyLoPro package, a ``DynamicLogPlots`` instance has to
be initialized. The ``DynamicLogPlots`` class provides one single source of
access to all of DyLoPro's visualization methods, and thereby serves as the
interface between the your python environment and DyLoPro’s underlying
computational logic.
```python
import DyLoPro as dlp
plot_object = dlp.DynamicLogPlots(event_log,
case_id_key,
activity_key,
timestamp_key,
categorical_casefeatures,
numerical_casefeatures,
categorical_eventfeatures,
numerical_eventfeatures,
start_date,
end_date,
outcome)
```
After running this block of code, DyLoPro will verify the validity
of the event log and all arguments specified.
- If everything checks out,
the event log is preprocessed into an internal format that allows DyLoPro to
efficiently compute and visualize all aggregations on an on-demand basis.
Afterwards, a ``DynamicLogPlots`` object is initialized, and all
visualization methods can be accessed by invoking the corresponding methods
on this instance.
- If an error is detected, DyLoPro will raise an error with a dedicated error
message describing what went wrong and how it can be resolved.
The formatting requirements of the event log, and of all of the arguments
needed to initialize a ``DynamicLogPlots`` instance (see code block above)
can be consulted [__here__](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots).
### Step 2: Accessing all visualization methods
Assuming [Step 1](#step-1-initializing-a-dynamiclogplots-instance) is
successfully completed, you can now easily access all visualization methods
by simply invoking the appropriate methods on ``plot_object``.
As already mentioned, DyLoPro is the implementation of the identically named
_DyLoPro framework_. [Below](#framework-to-package-mapping), you will find a
concise summary of the framework, followed by a comprehensive explanation of
its implementation as a Python package. This section will guide you through
leveraging all the available visualization capabilities. For a more
detailed explanation on the framework, please refer to Section 4 of the
[*paper*](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf).
Addtionally, the detailed notebooks containing the
[case studies](#case-studies) conducted on a number of commonly used
real-life event logs might also improve your understanding on how to
use and access DyLoPro's variety of plotting methods.
#### Framework to package mapping
___
DyLoPro provides functionality to construct and visualize time series, i.e.
the log dynamics, for a variety of **_log concepts_**. For each
*log concept*, the dynamics can be represented using five different
**_representation types_**.
- __log concepts__: the main dimensions along which we capture event log
dynamics.
- __representation types__: how the event log dynamics should be represented
and analyzed for each log concept.
##### __Brief Summary Framework__
___
The framework formalizes this procedure in three stages:
1. __Log Discretization__: Subdividing the event log into a chronologically
ordered set of sub-logs. This is done in two consecutive steps:
1. Given that the log encompasses data spanning a temporal interval
denoted as T, split up T in a chronologically ordered set of
equal-length time intervals.
1. Create the ordered set of sub-logs by assigning each case to exactly
one of these time intervals.
1. __Domain Definition__:
* Defining along which *log concept* to capture
log dynamics, and how to represent these dynamics. This boils down to
defining the *log concept* and *representation type* respectively.
* The resulting *log concept - representation type* combination translates
into a unique domain-specific mapping function.
1. __Time Series Construction & Visualization__:
* Applying the resulting mapping function to each of the chronologically
ordered sub-logs. Thereby creating (multiple) time serie(s).
* Visualizing the constructed time series.
##### __Framework Implementation DyLoPro Package__
___
As already mentioned, all visualization methods can be accessed by invoking
the appropriate methods on your initialized ``DynamicLogPlots`` instance.
All of __DyLoPro__'s plotting methods construct time series by deriving
real-valued measures for a choronologically ordered set of sublogs.
The three-stage framework is implemented in this package as follows:
* Each of the plotting methods that can be invoked, pertains to exactly one
**log concept**.
* Given a certain *log concept*, and hence (one of its) associated plotting
methods, the **representation type** can be passed on to that method
by specifying the ``plt_type`` argument. The five representation types proposed
in [the paper](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf)
correspond to the followig argument values for the ``plt_type`` parameter.
1. __Isolated__ : ``plt_type='univariate'``
1. __Throughput Time (TT)__ : ``plt_type='type_tt'``
1. __Case Length (NEPC)__ : ``plt_type='type_events_case'``
1. __Outcome__ : ``plt_type='type_outcome'``
1. __DFR Performance__ : ``plt_type='type_dfr_performance'``
* __Log Discretization__: Also the *Log Discretization* can be specified as
as arguments of each plotting method.
1. ``frequency`` parameter: Determine the frequency by which the cases
are grouped together.
1. ``case_assignment`` parameter: Determines the condition upon which each
case is assigned to a certain time interval.
E.g. if `frequency='weekly'` and `case_assignment='first_event'`, each case
is assigned to the one-week time interval in which its first event occurs
and hence each sublog will consist of all cases that were initialized in
one particular week.
Each method is also equipped with an additional set of optional
configuration parameters, providing even more customization options to the
user. For more information about the parameters corresponding to these
methods, please consult the [documentation](#documentation).
The table underneath lists the plotting methods corresponding to each of
the *log concepts* proposed in the *DyLoPro framework*. You can directly
navigate to the detailled documentation of each methodd by clicking on it.
| | Log Concept | Method 1 | Method 2 |
| ---| :-----------: |:-------------:| :-------: |
| 1 | Variants | [``topK_variants_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.topK_variants_evol) | [``variants_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.variants_evol) |
| 2 | Directly-Follows Relations | [``topK_dfr_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.topK_dfr_evol) | [``dfr_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.dfr_evol) |
| 3 | Categorical Case Feature | [``topK_categorical_caseftr_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.topK_categorical_caseftr_evol) | / |
| 4 | Numerical Case Features | [``num_casefts_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.num_casefts_evol) | / |
| 5 | Categorical Event Feature | [``topK_categorical_eventftr_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.topK_categorical_eventftr_evol) | / |
| 6 | Numerical Event Features | [``num_eventfts_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.num_eventfts_evol) | / |
Finally, it is also well-worth mentioning that the extensive capabilities
proposed in the the *DyLoPro framework* are not meant to be exhaustive.
The visualization methods offered by the **DyLoPro package** are
consequently meant to be continuously extended and improved. Please find
the visualization methods extending the framework listed below:
- ``distinct_variants_evol()`` : __NOTE__: Deprecated. Will be removed in
future versions. Use the ``distinct_variants_AdvancedEvol()`` instead.
- ``distinct_variants_AdvancedEvol()``
## Citing DyLoPro
A Demo paper presenting the DyLoPro package is currently in the making.
The DyLoPro package is the software implementation of the identically named
_DyLoPro framework_ proposed in the paper
***DyLoPro: Profiling the Dynamics of Event Logs***. This paper will be
presented at the [BPM 2023](https://bpm2023.sites.uu.nl/) conference in
Utrecht, and accordingly published in its main proceedings.
In the meantime, if you are using __DyLoPro__ in your scientiic work, please
cite __DyLoPro__ as follows:
> *B. Wuyts, H. Weytjens, S. vanden Broucke, J. De Weerdt, DyLoPro:
Profiling the dynamics of event logs, in: Business Process Management,
Springer International Publishing, 2023*
The full citation will be provided as soon as it is available. A preprint of the (already peer-reviewed) BPM paper can be found [here](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf).
## Case Studies
The DyLoPro package has already been used to conduct an extensive analysis
of the dynamics present in a number of commonly used real-life event logs.
These case studies, conducted for the
[BPM paper](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf),
can be found [here](https://github.com/BrechtWts/DyLoPro_CaseStudies).
## Contributing
Contributions are welcome, and they are greatly appreciated! Every little bit
helps, and credit will always be given.
You can contribute in many ways. For more information, please refer to the *CONTRIBUTING.md* file.
## Release Notes
Please consult HISTORY.md for the release notes.
## License
Free software: GNU General Public License v3
## Credits
This package was created with Cookiecutter and the `audreyr/cookiecutter-pypackage` project template.
- Cookiecutter: https://github.com/audreyr/cookiecutter
- `audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage
# History
## 0.1.1 (2023-07-05)
### Changed
- Improved the README.md file.
### Added
- Correctly formatted docstrings of all modules, including the utility files.
- Documentation page on readthedocs.org.
### Deprecated
- 0.1.1 will be the last version that contains the
``distinct_variants_evol()`` plotting method, and will be removed in the
next minor update. Reason being: the method solely duplicates a small part
of the visualization capabilities offered by the
``distinct_variants_AdvancedEvol()`` method. Use the more extensive
``distinct_variants_AdvancedEvol()`` visualization method instead.
## 0.1.0 (2023-06-21)
- First release on PyPI.
Raw data
{
"_id": null,
"home_page": "https://github.com/BrechtWts/DyLoPro",
"name": "DyLoPro",
"maintainer": "",
"docs_url": null,
"requires_python": ">=3.6",
"maintainer_email": "",
"keywords": "DyLoPro",
"author": "Brecht Wuyts",
"author_email": "brecht.wuyts@kuleuven.be",
"download_url": "https://files.pythonhosted.org/packages/13/cb/4e9152446c1dfad9dbdee17b8e92ca60aabe74a306df6045d375d132a7f7/DyLoPro-0.1.1.tar.gz",
"platform": null,
"description": "<p align=\"center\">\n <img src=\"DyLoPro.png\" alt=\"DyLoPro logo\" width=\"400\" height=\"400\">\n</p>\n\n#\n\nThe *DyLoPro Python Library* is a **visual analytics** tool that allows \n**Process Mining (PM)**[^1] practitioners to efficiently and comprehensively \nexplore the **dynamics** in **event logs** over time, prior to applying PM \ntechniques. These **comprehensive exploration capabilities** are provided \nby extensive set of plotting functionalities, visualizing the \ndynamics over time from different **process perspectives**. \n\n[^1]: van der Aalst, W. (2016). Data Science in Action. In: Process Mining. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-662-49851-4_1\n \n https://en.wikipedia.org/wiki/Process_mining\n\n> DyLoPro library is ready-to-use and efficient software implementation of the \n> identically named **_DyLoPro framework_**, introduced in the paper \n> ***DyLoPro: Profiling the Dynamics of Event Logs***, which will be \n> presented at the [BPM 2023](https://bpm2023.sites.uu.nl/) conference in \n> Utrecht, and accordingly published in its main proceedings. \n> A preprint of the (already peer-reviewed) BPM paper can be found \n> [here](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf).\n\n_DyLoPro is a comprehensive visual analytics framework designed to \nexplore event log dynamics over time. DyLoPro\u00e2\u20ac\u2122s comprehensiveness \nis achieved through the incorporation of the main process \nperspectives - the control-flow, data (including resources) and \nperformance, along two orthogonal dimensions of log concepts and \nrepresentation types. It incorporates six log concepts to capture \nall essential information from event logs, including variants and \ndirectly-follows relations for the control-flow perspective, and \ncategorical and numeric case and event features for the data \nperspective. These six log concepts can be represented using \nfive representation types, including four performance-oriented \nones (throughput time, number of events per case, outcome, and \ndirectly-follows-relations\u00e2\u20ac\u2122 performance) and one generic type. \nWith this two-dimensional approach, end users can gain a nuanced \nand holistic view of event log dynamics, efficiently identifying \npatterns, temporary or permanent changes, and trends of interest \nfrom multiple perspectives. Upon identification, they can further \nanalyze these patterns and trends, ultimately leading to more \nappropriate application of downstream process mining techniques._\n\n\n## Documentation\nYou can consult the documentation of DyLoPro [__here__](https://DyLoPro.readthedocs.io). \n\nThe following terms are used interchangeably throughout the documentation:\n- *'case'* and *'trace'*\n- *'time period'*, *'time bucket'* and *'time interval'*\n\n## Installation\nYou can install DyLoPro using:\n```bash\npip install DyLoPro\n```\n\nThe DyLoPro PyPi page can be consulted [here](https://pypi.org/project/DyLoPro/).\n\n## Requirements \n__DyLoPro__ depends on the following Python packages: \n- numpy *(version >=1.21.5)*\n- pandas *(version >=2.0.2)*\n- matplotlib *(version >=3.7.1)*\n- tqdm *(version >=4.63.0)*\n\nIf (some of) these requirements are not satisfied yet, then these packages will automatically be installed when [installing __DyLoPro__](#installation).\n\n\n## Get Started \n\n### Assumptions & Terminology \n\nFor the moment, DyLoPro assumes flat event logs, and does not cater to object-centric \nevent logs. DyLoPro also regards events to be the atomic unit of the event log. \nIn other words, the execution of a single event is recorded as a single row in the \nresulting event log. For the terminology and definitions employed by the \n'DyLoPro' Python package, please refer to *Section 3 (Preliminaries)* of the \n[corresponding academic paper](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf).\n\n### Step 1: Initializing a ``DynamicLogPlots`` instance\nAssuming that you have already loaded an event log into a pd.DataFrame called \ne.g. ``event_log``.\nAfter having imported the DyLoPro package, a ``DynamicLogPlots`` instance has to \nbe initialized. The ``DynamicLogPlots`` class provides one single source of \naccess to all of DyLoPro's visualization methods, and thereby serves as the \ninterface between the your python environment and DyLoPro\u00e2\u20ac\u2122s underlying \ncomputational logic.\n\n```python\nimport DyLoPro as dlp\nplot_object = dlp.DynamicLogPlots(event_log, \n case_id_key, \n activity_key, \n timestamp_key,\n categorical_casefeatures, \n numerical_casefeatures, \n categorical_eventfeatures, \n numerical_eventfeatures, \n start_date, \n end_date, \n outcome)\n```\n\nAfter running this block of code, DyLoPro will verify the validity \nof the event log and all arguments specified. \n- If everything checks out, \nthe event log is preprocessed into an internal format that allows DyLoPro to \nefficiently compute and visualize all aggregations on an on-demand basis. \nAfterwards, a ``DynamicLogPlots`` object is initialized, and all \nvisualization methods can be accessed by invoking the corresponding methods \non this instance. \n\n- If an error is detected, DyLoPro will raise an error with a dedicated error \nmessage describing what went wrong and how it can be resolved. \n\nThe formatting requirements of the event log, and of all of the arguments \nneeded to initialize a ``DynamicLogPlots`` instance (see code block above) \ncan be consulted [__here__](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots).\n\n### Step 2: Accessing all visualization methods\nAssuming [Step 1](#step-1-initializing-a-dynamiclogplots-instance) is \nsuccessfully completed, you can now easily access all visualization methods \nby simply invoking the appropriate methods on ``plot_object``.\n\nAs already mentioned, DyLoPro is the implementation of the identically named \n_DyLoPro framework_. [Below](#framework-to-package-mapping), you will find a \nconcise summary of the framework, followed by a comprehensive explanation of \nits implementation as a Python package. This section will guide you through \nleveraging all the available visualization capabilities. For a more \ndetailed explanation on the framework, please refer to Section 4 of the \n[*paper*](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf).\n\nAddtionally, the detailed notebooks containing the \n[case studies](#case-studies) conducted on a number of commonly used \nreal-life event logs might also improve your understanding on how to \nuse and access DyLoPro's variety of plotting methods.\n\n#### Framework to package mapping \n___\nDyLoPro provides functionality to construct and visualize time series, i.e. \nthe log dynamics, for a variety of **_log concepts_**. For each \n*log concept*, the dynamics can be represented using five different \n**_representation types_**. \n\n- __log concepts__: the main dimensions along which we capture event log \ndynamics.\n- __representation types__: how the event log dynamics should be represented \nand analyzed for each log concept.\n\n##### __Brief Summary Framework__\n___\nThe framework formalizes this procedure in three stages: \n\n1. __Log Discretization__: Subdividing the event log into a chronologically \n ordered set of sub-logs. This is done in two consecutive steps:\n 1. Given that the log encompasses data spanning a temporal interval \n denoted as T, split up T in a chronologically ordered set of \n equal-length time intervals.\n 1. Create the ordered set of sub-logs by assigning each case to exactly \n one of these time intervals. \n\n1. __Domain Definition__:\n * Defining along which *log concept* to capture \n log dynamics, and how to represent these dynamics. This boils down to \n defining the *log concept* and *representation type* respectively.\n * The resulting *log concept - representation type* combination translates \n into a unique domain-specific mapping function. \n\n1. __Time Series Construction & Visualization__: \n * Applying the resulting mapping function to each of the chronologically\n ordered sub-logs. Thereby creating (multiple) time serie(s).\n * Visualizing the constructed time series. \n\n##### __Framework Implementation DyLoPro Package__\n___\nAs already mentioned, all visualization methods can be accessed by invoking \nthe appropriate methods on your initialized ``DynamicLogPlots`` instance. \nAll of __DyLoPro__'s plotting methods construct time series by deriving \nreal-valued measures for a choronologically ordered set of sublogs. \n\nThe three-stage framework is implemented in this package as follows: \n\n* Each of the plotting methods that can be invoked, pertains to exactly one \n **log concept**.\n* Given a certain *log concept*, and hence (one of its) associated plotting \n methods, the **representation type** can be passed on to that method \n by specifying the ``plt_type`` argument. The five representation types proposed \n in [the paper](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf) \n correspond to the followig argument values for the ``plt_type`` parameter.\n 1. __Isolated__ : ``plt_type='univariate'``\n 1. __Throughput Time (TT)__ : ``plt_type='type_tt'``\n 1. __Case Length (NEPC)__ : ``plt_type='type_events_case'``\n 1. __Outcome__ : ``plt_type='type_outcome'``\n 1. __DFR Performance__ : ``plt_type='type_dfr_performance'``\n* __Log Discretization__: Also the *Log Discretization* can be specified as \n as arguments of each plotting method.\n 1. ``frequency`` parameter: Determine the frequency by which the cases \n are grouped together.\n 1. ``case_assignment`` parameter: Determines the condition upon which each \n case is assigned to a certain time interval.\n\n E.g. if `frequency='weekly'` and `case_assignment='first_event'`, each case \n is assigned to the one-week time interval in which its first event occurs \n and hence each sublog will consist of all cases that were initialized in \n one particular week. \n\n Each method is also equipped with an additional set of optional \n configuration parameters, providing even more customization options to the \n user. For more information about the parameters corresponding to these \n methods, please consult the [documentation](#documentation).\n\n\nThe table underneath lists the plotting methods corresponding to each of \nthe *log concepts* proposed in the *DyLoPro framework*. You can directly \nnavigate to the detailled documentation of each methodd by clicking on it. \n\n| | Log Concept | Method 1 | Method 2 |\n| ---| :-----------: |:-------------:| :-------: |\n| 1 | Variants | [``topK_variants_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.topK_variants_evol) | [``variants_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.variants_evol) |\n| 2 | Directly-Follows Relations | [``topK_dfr_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.topK_dfr_evol) | [``dfr_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.dfr_evol) |\n| 3 | Categorical Case Feature | [``topK_categorical_caseftr_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.topK_categorical_caseftr_evol) | / |\n| 4 | Numerical Case Features | [``num_casefts_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.num_casefts_evol) | / |\n| 5 | Categorical Event Feature | [``topK_categorical_eventftr_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.topK_categorical_eventftr_evol) | / |\n| 6 | Numerical Event Features | [``num_eventfts_evol()``](https://dylopro.readthedocs.io/en/latest/DyLoPro.html#DyLoPro.DynamicLogPlotting.DynamicLogPlots.num_eventfts_evol) | / |\n\nFinally, it is also well-worth mentioning that the extensive capabilities \nproposed in the the *DyLoPro framework* are not meant to be exhaustive. \nThe visualization methods offered by the **DyLoPro package** are \nconsequently meant to be continuously extended and improved. Please find \nthe visualization methods extending the framework listed below:\n\n- ``distinct_variants_evol()`` : __NOTE__: Deprecated. Will be removed in \n future versions. Use the ``distinct_variants_AdvancedEvol()`` instead. \n- ``distinct_variants_AdvancedEvol()``\n\n## Citing DyLoPro\nA Demo paper presenting the DyLoPro package is currently in the making. \n\nThe DyLoPro package is the software implementation of the identically named \n_DyLoPro framework_ proposed in the paper \n***DyLoPro: Profiling the Dynamics of Event Logs***. This paper will be \npresented at the [BPM 2023](https://bpm2023.sites.uu.nl/) conference in \nUtrecht, and accordingly published in its main proceedings. \n\nIn the meantime, if you are using __DyLoPro__ in your scientiic work, please \ncite __DyLoPro__ as follows:\n\n> *B. Wuyts, H. Weytjens, S. vanden Broucke, J. De Weerdt, DyLoPro: \nProfiling the dynamics of event logs, in: Business Process Management, \nSpringer International Publishing, 2023*\n\nThe full citation will be provided as soon as it is available. A preprint of the (already peer-reviewed) BPM paper can be found [here](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf).\n\n## Case Studies\nThe DyLoPro package has already been used to conduct an extensive analysis \nof the dynamics present in a number of commonly used real-life event logs. \n\nThese case studies, conducted for the \n[BPM paper](https://github.com/BrechtWts/DyLoPro/blob/master/DyLoPro_Framework_Preprint.pdf), \ncan be found [here](https://github.com/BrechtWts/DyLoPro_CaseStudies).\n\n## Contributing \nContributions are welcome, and they are greatly appreciated! Every little bit\nhelps, and credit will always be given.\n\nYou can contribute in many ways. For more information, please refer to the *CONTRIBUTING.md* file. \n\n## Release Notes\nPlease consult HISTORY.md for the release notes. \n\n## License\nFree software: GNU General Public License v3\n\n\n## Credits \n\nThis package was created with Cookiecutter and the `audreyr/cookiecutter-pypackage` project template.\n- Cookiecutter: https://github.com/audreyr/cookiecutter\n- `audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage\n\n# History\n\n## 0.1.1 (2023-07-05)\n### Changed \n- Improved the README.md file. \n### Added \n- Correctly formatted docstrings of all modules, including the utility files. \n- Documentation page on readthedocs.org. \n### Deprecated \n- 0.1.1 will be the last version that contains the \n ``distinct_variants_evol()`` plotting method, and will be removed in the \n next minor update. Reason being: the method solely duplicates a small part \n of the visualization capabilities offered by the \n ``distinct_variants_AdvancedEvol()`` method. Use the more extensive \n ``distinct_variants_AdvancedEvol()`` visualization method instead.\n\n## 0.1.0 (2023-06-21)\n- First release on PyPI.\n",
"bugtrack_url": null,
"license": "GNU General Public License v3",
"summary": "Dynamic Log Profiling package",
"version": "0.1.1",
"project_urls": {
"Homepage": "https://github.com/BrechtWts/DyLoPro"
},
"split_keywords": [
"dylopro"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "340ffcc410e6106cf0444d9f5c08e247fb8c8f7b1eacbbafe4b2860c53931415",
"md5": "708e42c47123ba9366a31efca7515541",
"sha256": "7e3c5380588dd3ed95e64ae62505c905fef3bc535b506a28d845437cbe3901d8"
},
"downloads": -1,
"filename": "DyLoPro-0.1.1-py2.py3-none-any.whl",
"has_sig": false,
"md5_digest": "708e42c47123ba9366a31efca7515541",
"packagetype": "bdist_wheel",
"python_version": "py2.py3",
"requires_python": ">=3.6",
"size": 60227,
"upload_time": "2023-07-18T15:56:26",
"upload_time_iso_8601": "2023-07-18T15:56:26.704644Z",
"url": "https://files.pythonhosted.org/packages/34/0f/fcc410e6106cf0444d9f5c08e247fb8c8f7b1eacbbafe4b2860c53931415/DyLoPro-0.1.1-py2.py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "13cb4e9152446c1dfad9dbdee17b8e92ca60aabe74a306df6045d375d132a7f7",
"md5": "6de57e1416bb2c179a9197dcd0fb634f",
"sha256": "274f3f89afc693a1e227f1bd9f424f2cde3a177fe424ea172e2232e7d16b5cfc"
},
"downloads": -1,
"filename": "DyLoPro-0.1.1.tar.gz",
"has_sig": false,
"md5_digest": "6de57e1416bb2c179a9197dcd0fb634f",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.6",
"size": 64087,
"upload_time": "2023-07-18T15:56:29",
"upload_time_iso_8601": "2023-07-18T15:56:29.086669Z",
"url": "https://files.pythonhosted.org/packages/13/cb/4e9152446c1dfad9dbdee17b8e92ca60aabe74a306df6045d375d132a7f7/DyLoPro-0.1.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-07-18 15:56:29",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "BrechtWts",
"github_project": "DyLoPro",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"tox": true,
"lcname": "dylopro"
}
JSON
