diff options
| author | CoprDistGit <infra@openeuler.org> | 2023-06-20 06:44:23 +0000 |
|---|---|---|
| committer | CoprDistGit <infra@openeuler.org> | 2023-06-20 06:44:23 +0000 |
| commit | 1751874959888a71282e1ab6b142fac042b08c76 (patch) | |
| tree | caa6cb38ff6f1075e62a83a76c9c730fb86b8480 | |
| parent | 669d3d9d929136b49a6c69838a33c669cd8246b4 (diff) | |
automatic import of python-ADLStreamopeneuler20.03
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-adlstream.spec | 766 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 768 insertions, 0 deletions
@@ -0,0 +1 @@ +/ADLStream-0.1.5.tar.gz diff --git a/python-adlstream.spec b/python-adlstream.spec new file mode 100644 index 0000000..d6956af --- /dev/null +++ b/python-adlstream.spec @@ -0,0 +1,766 @@ +%global _empty_manifest_terminate_build 0 +Name: python-ADLStream +Version: 0.1.5 +Release: 1 +Summary: ADLStream is a novel asynchronous dual-pipeline deep learning framework for data stream mining +License: MIT +URL: https://adlstream.readthedocs.io +Source0: https://mirrors.aliyun.com/pypi/web/packages/43/9e/74c6d88156419176e9d3bb3bc12cbdec3258ba8816e081b12a40b9d514e3/ADLStream-0.1.5.tar.gz +BuildArch: noarch + +Requires: python3-numpy +Requires: python3-tensorflow +Requires: python3-tensorflow-addons +Requires: python3-keras-tcn +Requires: python3-matplotlib +Requires: python3-scikit-learn +Requires: python3-kafka-python + +%description +# ADLStream + +[](https://pypi.org/project/ADLStream/) +[](https://adlstream.readthedocs.io/en/latest/?badge=latest) + +[](https://pepy.tech/project/adlstream) +[](https://www.python.org/downloads/release/python-360/) +[](https://github.com/psf/black) + +##### Asynchronous dual-pipeline deep learning framework for online data stream mining. + + +ADLStream is a novel asynchronous dual-pipeline deep learning framework for data stream mining. +This system has two separated layers for training and testing that work simultaneously in order to provide quick predictions and perform frequent updates of the model. +The dual-layer architecture allows to alleviate the computational cost problem of complex deep learning models, such as convolutional neural networks, for the data streaming context, in which speed is essential. + +<p align="center"> + <img width="100%" src="https://raw.githubusercontent.com/pedrolarben/ADLStream/master/docs/img/ADLStream.png"> +</p> + +Complete documentation and API of ADLStream can be found in [adlstream.readthedocs.io](https://adlstream.readthedocs.io). + + +- [ADLStream](#adlstream) + - [Asynchronous dual-pipeline deep learning framework for online data stream mining.](#asynchronous-dual-pipeline-deep-learning-framework-for-online-data-stream-mining) + - [Installation Guide](#installation-guide) + - [GPU support](#gpu-support) + - [Hardware requirements](#hardware-requirements) + - [Software requirements](#software-requirements) + - [Installing ADLStream](#installing-adlstream) + - [Getting Started](#getting-started) + - [1. Create the stream](#1-create-the-stream) + - [2. Create the stream generator.](#2-create-the-stream-generator) + - [3. Configure the evaluation process.](#3-configure-the-evaluation-process) + - [4. Configure model and create ADLStream](#4-configure-model-and-create-adlstream) + - [5. Run ADLStream & Results](#5-run-adlstream--results) + - [Research papers related](#research-papers-related) + - [Contributing](#contributing) + - [License](#license) + - [Authors](#authors) + - [Contributors](#contributors) + +## Installation Guide + +### GPU support + +Ideally, ADLStream should be run in a two GPU computer. +However, it is not compulsory and ADLStream can be also run in CPU. + +ADLStream uses [Tensorflow](https://www.tensorflow.org/). +If you are interested in running ADLStream in GPU, the [tensorflow>=2.1.0](https://www.tensorflow.org/install/gpu +) GPU specifications are querired. + +If you don't want to use GPU go to [Installing ADLStream](#installing-adlstream). + +#### Hardware requirements + + * Computer with at least 2 NVIDIA® GPU card with CUDA® Compute Capability 3.5 or higher + +#### Software requirements + +The following NVIDIA® software must be installed on your system: + + * NVIDIA® GPU drivers —CUDA 10.0 requires 418.x or higher. + * CUDA® Toolkit —TensorFlow supports CUDA 10.1 (TensorFlow >= 2.1.0) + * CUPTI ships with the CUDA Toolkit. + * cuDNN SDK (>= 7.6) + * (Optional) TensorRT 6.0 to improve latency and throughput for inference on some models. + +### Installing ADLStream + +You can install ADLStream and its dependencies from PyPI with: + +```bash +pip install ADLStream +``` + +We strongly recommend that you install ADLStream in a dedicated virtualenv, to avoid conflicting with your system packages. + +To use ADLStream: + +```python +import ADLStream +``` + +## Getting Started + +These instructions explain how to use ADLStream framework with a simple example. + +In this example we will use a LSTM model for time series forecasting in streaming. + +#### 1. Create the stream + +Fist of all we will need to create the stream. +Stream objects can be created using the classes from `ADLStream.data.stream`. We can choose different options depending on the source of our stream (from a csv file, a Kafka cluster, etc). + +In this example, we will use the `FakeStream`, which implements a sine wave. + +```python +import ADLStream + +stream = ADLStream.data.stream.FakeStream( + num_features=6, stream_length=1000, stream_period=100 +) +``` + +More precisely, this stream will return a maximun of 1000 instances. The stream sends one message every 100 milliseconds (0.1 seconds). + +#### 2. Create the stream generator. + +Once we have our source stream, we need to create our stream generator. +A `StreamGenerator` is an object that will preprocess the `stream` and convert the messages into input (`x`) and target (`y`) data of the deep learning model. +There are different options to choose under `ADLStream.data` and, if needed, we can create our custom `StreamGenerator` by inheriting `BaseStreamGenerator`. + +As our problem is time series forecasting, we will use the `MovingWindowStreamGenerator`, which performs the moving-window preprocessing method. + +```python +stream_generator = ADLStream.data.MovingWindowStreamGenerator( + stream=stream, past_history=12, forecasting_horizon=3, shift=1 +) +``` + +For the example we have set the past history to 12 and the model will predict the next 3 elements. + +#### 3. Configure the evaluation process. + +In order to evaluate the performance of the model, we need to create a validator object. +There exist different alternative for data-stream validation, some of the most common one can be found under `ADLStream.evaluation`. +Furthermore, custom evaluators can be easily implemented by inheriting `BaseEvaluator`. + +In this case, we are going to create a `PrequentialEvaluator` which implements the idea that more recent examples are more important using a decaying factor. + +```python +evaluator = ADLStream.evaluation.PrequentialEvaluator( + chunk_size=10, + metric="MAE", + fadding_factor=0.98, + results_file="ADLStream.csv", + dataset_name="Fake Data", + show_plot=True, + plot_file="test.jpg", +) +``` + +As can be seen, we are using the mean absolute error (MAE) metrics. Other options can be found in `ADLStream.evaluation.metrics`. +The evaluator will save the progress of the error metric in `results_file` and will also plot the progress and saved the image in `plot_file`. + +#### 4. Configure model and create ADLStream + +Finally we will create our `ADLStream` object specifying the model to use. + +The required model arguments are the architecture, the loss and the optimizer. In addition, we can provides a dict with the model parameters to customize its architecture. +All the available model architecture and its parameters can be found in `ADLStream.models`. + +For the example we are using a deep learning model with 3 stacked LSTM layers of 16, 32 and 64 units followed by a fully connected block of two layers with 16 and 8 neurons. + +```python +model_architecture = "lstm" +model_loss = "mae" +model_optimizer = "adam" +model_parameters = { + "recurrent_units": [16, 32, 64], + "recurrent_dropout": 0, + "return_sequences": False, + "dense_layers": [16, 8], + "dense_dropout": 0, +} + +adls = ADLStream.ADLStream( + stream_generator=stream_generator, + evaluator=evaluator, + batch_size=60, + num_batches_fed=20, + model_architecture=model_architecture, + model_loss=model_loss, + model_optimizer=model_optimizer, + model_parameters=model_parameters, + log_file="ADLStream.log", +) +``` + +#### 5. Run ADLStream & Results + +Once we came the ADLStream object created, we can initiate it by calling its `run` function. + +```python +adls.run() +``` + +The processes will start and the progress will be plot obtaining a result similar to this one + + + +Complete API reference can be found [here](https://adlstream.readthedocs.io). + +## Research papers related + +Here it is the original paper that you can cite to reference ADLStream + +* [Lara-Benítez, Pedro, Manuel Carranza-garcía, et al. ‘Asynchronous Dual-pipeline Deep Learning Framework for Online Data Stream Classification’. Integrated Computer-Aided Engineering. 1 Jan. 2020 : 101 – 119.](https://doi.org/10.3233/ICA-200617) + +Any other study using ADLStream framework will be listed here. + +* [Lara-Benítez, Pedro, et al. "On the performance of deep learning models for time series classification in streaming." International Workshop on Soft Computing Models in Industrial and Environmental Applications. Springer, Cham, 2020.](http://arxiv.org/abs/2003.02544v2.pdf) + +## Contributing + +Read [CONTRIBUTING.md](CONTRIBUTING.md). We appreciate all kinds of help. + +## License + +This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details + +## Authors + +* **Pedro Lara-Benítez** - [LinkedIn](www.linkedin.com/in/pedrolarben) +* **Manuel Carranza-García** - [LinkedIn](https://www.linkedin.com/in/manuelcarranzagarcia96/) +* **Jorge García-Gutiérrez** +* **José C. Riquelme** + +### Contributors +* [@pedrolarben](https://github.com/pedrolarben) +* [@carranza96](https://github.com/carranza96) +* [@preinaj](https://github.com/preinaj) + + + + + + + +%package -n python3-ADLStream +Summary: ADLStream is a novel asynchronous dual-pipeline deep learning framework for data stream mining +Provides: python-ADLStream +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-ADLStream +# ADLStream + +[](https://pypi.org/project/ADLStream/) +[](https://adlstream.readthedocs.io/en/latest/?badge=latest) + +[](https://pepy.tech/project/adlstream) +[](https://www.python.org/downloads/release/python-360/) +[](https://github.com/psf/black) + +##### Asynchronous dual-pipeline deep learning framework for online data stream mining. + + +ADLStream is a novel asynchronous dual-pipeline deep learning framework for data stream mining. +This system has two separated layers for training and testing that work simultaneously in order to provide quick predictions and perform frequent updates of the model. +The dual-layer architecture allows to alleviate the computational cost problem of complex deep learning models, such as convolutional neural networks, for the data streaming context, in which speed is essential. + +<p align="center"> + <img width="100%" src="https://raw.githubusercontent.com/pedrolarben/ADLStream/master/docs/img/ADLStream.png"> +</p> + +Complete documentation and API of ADLStream can be found in [adlstream.readthedocs.io](https://adlstream.readthedocs.io). + + +- [ADLStream](#adlstream) + - [Asynchronous dual-pipeline deep learning framework for online data stream mining.](#asynchronous-dual-pipeline-deep-learning-framework-for-online-data-stream-mining) + - [Installation Guide](#installation-guide) + - [GPU support](#gpu-support) + - [Hardware requirements](#hardware-requirements) + - [Software requirements](#software-requirements) + - [Installing ADLStream](#installing-adlstream) + - [Getting Started](#getting-started) + - [1. Create the stream](#1-create-the-stream) + - [2. Create the stream generator.](#2-create-the-stream-generator) + - [3. Configure the evaluation process.](#3-configure-the-evaluation-process) + - [4. Configure model and create ADLStream](#4-configure-model-and-create-adlstream) + - [5. Run ADLStream & Results](#5-run-adlstream--results) + - [Research papers related](#research-papers-related) + - [Contributing](#contributing) + - [License](#license) + - [Authors](#authors) + - [Contributors](#contributors) + +## Installation Guide + +### GPU support + +Ideally, ADLStream should be run in a two GPU computer. +However, it is not compulsory and ADLStream can be also run in CPU. + +ADLStream uses [Tensorflow](https://www.tensorflow.org/). +If you are interested in running ADLStream in GPU, the [tensorflow>=2.1.0](https://www.tensorflow.org/install/gpu +) GPU specifications are querired. + +If you don't want to use GPU go to [Installing ADLStream](#installing-adlstream). + +#### Hardware requirements + + * Computer with at least 2 NVIDIA® GPU card with CUDA® Compute Capability 3.5 or higher + +#### Software requirements + +The following NVIDIA® software must be installed on your system: + + * NVIDIA® GPU drivers —CUDA 10.0 requires 418.x or higher. + * CUDA® Toolkit —TensorFlow supports CUDA 10.1 (TensorFlow >= 2.1.0) + * CUPTI ships with the CUDA Toolkit. + * cuDNN SDK (>= 7.6) + * (Optional) TensorRT 6.0 to improve latency and throughput for inference on some models. + +### Installing ADLStream + +You can install ADLStream and its dependencies from PyPI with: + +```bash +pip install ADLStream +``` + +We strongly recommend that you install ADLStream in a dedicated virtualenv, to avoid conflicting with your system packages. + +To use ADLStream: + +```python +import ADLStream +``` + +## Getting Started + +These instructions explain how to use ADLStream framework with a simple example. + +In this example we will use a LSTM model for time series forecasting in streaming. + +#### 1. Create the stream + +Fist of all we will need to create the stream. +Stream objects can be created using the classes from `ADLStream.data.stream`. We can choose different options depending on the source of our stream (from a csv file, a Kafka cluster, etc). + +In this example, we will use the `FakeStream`, which implements a sine wave. + +```python +import ADLStream + +stream = ADLStream.data.stream.FakeStream( + num_features=6, stream_length=1000, stream_period=100 +) +``` + +More precisely, this stream will return a maximun of 1000 instances. The stream sends one message every 100 milliseconds (0.1 seconds). + +#### 2. Create the stream generator. + +Once we have our source stream, we need to create our stream generator. +A `StreamGenerator` is an object that will preprocess the `stream` and convert the messages into input (`x`) and target (`y`) data of the deep learning model. +There are different options to choose under `ADLStream.data` and, if needed, we can create our custom `StreamGenerator` by inheriting `BaseStreamGenerator`. + +As our problem is time series forecasting, we will use the `MovingWindowStreamGenerator`, which performs the moving-window preprocessing method. + +```python +stream_generator = ADLStream.data.MovingWindowStreamGenerator( + stream=stream, past_history=12, forecasting_horizon=3, shift=1 +) +``` + +For the example we have set the past history to 12 and the model will predict the next 3 elements. + +#### 3. Configure the evaluation process. + +In order to evaluate the performance of the model, we need to create a validator object. +There exist different alternative for data-stream validation, some of the most common one can be found under `ADLStream.evaluation`. +Furthermore, custom evaluators can be easily implemented by inheriting `BaseEvaluator`. + +In this case, we are going to create a `PrequentialEvaluator` which implements the idea that more recent examples are more important using a decaying factor. + +```python +evaluator = ADLStream.evaluation.PrequentialEvaluator( + chunk_size=10, + metric="MAE", + fadding_factor=0.98, + results_file="ADLStream.csv", + dataset_name="Fake Data", + show_plot=True, + plot_file="test.jpg", +) +``` + +As can be seen, we are using the mean absolute error (MAE) metrics. Other options can be found in `ADLStream.evaluation.metrics`. +The evaluator will save the progress of the error metric in `results_file` and will also plot the progress and saved the image in `plot_file`. + +#### 4. Configure model and create ADLStream + +Finally we will create our `ADLStream` object specifying the model to use. + +The required model arguments are the architecture, the loss and the optimizer. In addition, we can provides a dict with the model parameters to customize its architecture. +All the available model architecture and its parameters can be found in `ADLStream.models`. + +For the example we are using a deep learning model with 3 stacked LSTM layers of 16, 32 and 64 units followed by a fully connected block of two layers with 16 and 8 neurons. + +```python +model_architecture = "lstm" +model_loss = "mae" +model_optimizer = "adam" +model_parameters = { + "recurrent_units": [16, 32, 64], + "recurrent_dropout": 0, + "return_sequences": False, + "dense_layers": [16, 8], + "dense_dropout": 0, +} + +adls = ADLStream.ADLStream( + stream_generator=stream_generator, + evaluator=evaluator, + batch_size=60, + num_batches_fed=20, + model_architecture=model_architecture, + model_loss=model_loss, + model_optimizer=model_optimizer, + model_parameters=model_parameters, + log_file="ADLStream.log", +) +``` + +#### 5. Run ADLStream & Results + +Once we came the ADLStream object created, we can initiate it by calling its `run` function. + +```python +adls.run() +``` + +The processes will start and the progress will be plot obtaining a result similar to this one + + + +Complete API reference can be found [here](https://adlstream.readthedocs.io). + +## Research papers related + +Here it is the original paper that you can cite to reference ADLStream + +* [Lara-Benítez, Pedro, Manuel Carranza-garcía, et al. ‘Asynchronous Dual-pipeline Deep Learning Framework for Online Data Stream Classification’. Integrated Computer-Aided Engineering. 1 Jan. 2020 : 101 – 119.](https://doi.org/10.3233/ICA-200617) + +Any other study using ADLStream framework will be listed here. + +* [Lara-Benítez, Pedro, et al. "On the performance of deep learning models for time series classification in streaming." International Workshop on Soft Computing Models in Industrial and Environmental Applications. Springer, Cham, 2020.](http://arxiv.org/abs/2003.02544v2.pdf) + +## Contributing + +Read [CONTRIBUTING.md](CONTRIBUTING.md). We appreciate all kinds of help. + +## License + +This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details + +## Authors + +* **Pedro Lara-Benítez** - [LinkedIn](www.linkedin.com/in/pedrolarben) +* **Manuel Carranza-García** - [LinkedIn](https://www.linkedin.com/in/manuelcarranzagarcia96/) +* **Jorge García-Gutiérrez** +* **José C. Riquelme** + +### Contributors +* [@pedrolarben](https://github.com/pedrolarben) +* [@carranza96](https://github.com/carranza96) +* [@preinaj](https://github.com/preinaj) + + + + + + + +%package help +Summary: Development documents and examples for ADLStream +Provides: python3-ADLStream-doc +%description help +# ADLStream + +[](https://pypi.org/project/ADLStream/) +[](https://adlstream.readthedocs.io/en/latest/?badge=latest) + +[](https://pepy.tech/project/adlstream) +[](https://www.python.org/downloads/release/python-360/) +[](https://github.com/psf/black) + +##### Asynchronous dual-pipeline deep learning framework for online data stream mining. + + +ADLStream is a novel asynchronous dual-pipeline deep learning framework for data stream mining. +This system has two separated layers for training and testing that work simultaneously in order to provide quick predictions and perform frequent updates of the model. +The dual-layer architecture allows to alleviate the computational cost problem of complex deep learning models, such as convolutional neural networks, for the data streaming context, in which speed is essential. + +<p align="center"> + <img width="100%" src="https://raw.githubusercontent.com/pedrolarben/ADLStream/master/docs/img/ADLStream.png"> +</p> + +Complete documentation and API of ADLStream can be found in [adlstream.readthedocs.io](https://adlstream.readthedocs.io). + + +- [ADLStream](#adlstream) + - [Asynchronous dual-pipeline deep learning framework for online data stream mining.](#asynchronous-dual-pipeline-deep-learning-framework-for-online-data-stream-mining) + - [Installation Guide](#installation-guide) + - [GPU support](#gpu-support) + - [Hardware requirements](#hardware-requirements) + - [Software requirements](#software-requirements) + - [Installing ADLStream](#installing-adlstream) + - [Getting Started](#getting-started) + - [1. Create the stream](#1-create-the-stream) + - [2. Create the stream generator.](#2-create-the-stream-generator) + - [3. Configure the evaluation process.](#3-configure-the-evaluation-process) + - [4. Configure model and create ADLStream](#4-configure-model-and-create-adlstream) + - [5. Run ADLStream & Results](#5-run-adlstream--results) + - [Research papers related](#research-papers-related) + - [Contributing](#contributing) + - [License](#license) + - [Authors](#authors) + - [Contributors](#contributors) + +## Installation Guide + +### GPU support + +Ideally, ADLStream should be run in a two GPU computer. +However, it is not compulsory and ADLStream can be also run in CPU. + +ADLStream uses [Tensorflow](https://www.tensorflow.org/). +If you are interested in running ADLStream in GPU, the [tensorflow>=2.1.0](https://www.tensorflow.org/install/gpu +) GPU specifications are querired. + +If you don't want to use GPU go to [Installing ADLStream](#installing-adlstream). + +#### Hardware requirements + + * Computer with at least 2 NVIDIA® GPU card with CUDA® Compute Capability 3.5 or higher + +#### Software requirements + +The following NVIDIA® software must be installed on your system: + + * NVIDIA® GPU drivers —CUDA 10.0 requires 418.x or higher. + * CUDA® Toolkit —TensorFlow supports CUDA 10.1 (TensorFlow >= 2.1.0) + * CUPTI ships with the CUDA Toolkit. + * cuDNN SDK (>= 7.6) + * (Optional) TensorRT 6.0 to improve latency and throughput for inference on some models. + +### Installing ADLStream + +You can install ADLStream and its dependencies from PyPI with: + +```bash +pip install ADLStream +``` + +We strongly recommend that you install ADLStream in a dedicated virtualenv, to avoid conflicting with your system packages. + +To use ADLStream: + +```python +import ADLStream +``` + +## Getting Started + +These instructions explain how to use ADLStream framework with a simple example. + +In this example we will use a LSTM model for time series forecasting in streaming. + +#### 1. Create the stream + +Fist of all we will need to create the stream. +Stream objects can be created using the classes from `ADLStream.data.stream`. We can choose different options depending on the source of our stream (from a csv file, a Kafka cluster, etc). + +In this example, we will use the `FakeStream`, which implements a sine wave. + +```python +import ADLStream + +stream = ADLStream.data.stream.FakeStream( + num_features=6, stream_length=1000, stream_period=100 +) +``` + +More precisely, this stream will return a maximun of 1000 instances. The stream sends one message every 100 milliseconds (0.1 seconds). + +#### 2. Create the stream generator. + +Once we have our source stream, we need to create our stream generator. +A `StreamGenerator` is an object that will preprocess the `stream` and convert the messages into input (`x`) and target (`y`) data of the deep learning model. +There are different options to choose under `ADLStream.data` and, if needed, we can create our custom `StreamGenerator` by inheriting `BaseStreamGenerator`. + +As our problem is time series forecasting, we will use the `MovingWindowStreamGenerator`, which performs the moving-window preprocessing method. + +```python +stream_generator = ADLStream.data.MovingWindowStreamGenerator( + stream=stream, past_history=12, forecasting_horizon=3, shift=1 +) +``` + +For the example we have set the past history to 12 and the model will predict the next 3 elements. + +#### 3. Configure the evaluation process. + +In order to evaluate the performance of the model, we need to create a validator object. +There exist different alternative for data-stream validation, some of the most common one can be found under `ADLStream.evaluation`. +Furthermore, custom evaluators can be easily implemented by inheriting `BaseEvaluator`. + +In this case, we are going to create a `PrequentialEvaluator` which implements the idea that more recent examples are more important using a decaying factor. + +```python +evaluator = ADLStream.evaluation.PrequentialEvaluator( + chunk_size=10, + metric="MAE", + fadding_factor=0.98, + results_file="ADLStream.csv", + dataset_name="Fake Data", + show_plot=True, + plot_file="test.jpg", +) +``` + +As can be seen, we are using the mean absolute error (MAE) metrics. Other options can be found in `ADLStream.evaluation.metrics`. +The evaluator will save the progress of the error metric in `results_file` and will also plot the progress and saved the image in `plot_file`. + +#### 4. Configure model and create ADLStream + +Finally we will create our `ADLStream` object specifying the model to use. + +The required model arguments are the architecture, the loss and the optimizer. In addition, we can provides a dict with the model parameters to customize its architecture. +All the available model architecture and its parameters can be found in `ADLStream.models`. + +For the example we are using a deep learning model with 3 stacked LSTM layers of 16, 32 and 64 units followed by a fully connected block of two layers with 16 and 8 neurons. + +```python +model_architecture = "lstm" +model_loss = "mae" +model_optimizer = "adam" +model_parameters = { + "recurrent_units": [16, 32, 64], + "recurrent_dropout": 0, + "return_sequences": False, + "dense_layers": [16, 8], + "dense_dropout": 0, +} + +adls = ADLStream.ADLStream( + stream_generator=stream_generator, + evaluator=evaluator, + batch_size=60, + num_batches_fed=20, + model_architecture=model_architecture, + model_loss=model_loss, + model_optimizer=model_optimizer, + model_parameters=model_parameters, + log_file="ADLStream.log", +) +``` + +#### 5. Run ADLStream & Results + +Once we came the ADLStream object created, we can initiate it by calling its `run` function. + +```python +adls.run() +``` + +The processes will start and the progress will be plot obtaining a result similar to this one + + + +Complete API reference can be found [here](https://adlstream.readthedocs.io). + +## Research papers related + +Here it is the original paper that you can cite to reference ADLStream + +* [Lara-Benítez, Pedro, Manuel Carranza-garcía, et al. ‘Asynchronous Dual-pipeline Deep Learning Framework for Online Data Stream Classification’. Integrated Computer-Aided Engineering. 1 Jan. 2020 : 101 – 119.](https://doi.org/10.3233/ICA-200617) + +Any other study using ADLStream framework will be listed here. + +* [Lara-Benítez, Pedro, et al. "On the performance of deep learning models for time series classification in streaming." International Workshop on Soft Computing Models in Industrial and Environmental Applications. Springer, Cham, 2020.](http://arxiv.org/abs/2003.02544v2.pdf) + +## Contributing + +Read [CONTRIBUTING.md](CONTRIBUTING.md). We appreciate all kinds of help. + +## License + +This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details + +## Authors + +* **Pedro Lara-Benítez** - [LinkedIn](www.linkedin.com/in/pedrolarben) +* **Manuel Carranza-García** - [LinkedIn](https://www.linkedin.com/in/manuelcarranzagarcia96/) +* **Jorge García-Gutiérrez** +* **José C. Riquelme** + +### Contributors +* [@pedrolarben](https://github.com/pedrolarben) +* [@carranza96](https://github.com/carranza96) +* [@preinaj](https://github.com/preinaj) + + + + + + + +%prep +%autosetup -n ADLStream-0.1.5 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-ADLStream -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Tue Jun 20 2023 Python_Bot <Python_Bot@openeuler.org> - 0.1.5-1 +- Package Spec generated @@ -0,0 +1 @@ +06574a5a335f8122ec92700bd4853cf2 ADLStream-0.1.5.tar.gz |