Reference-Collector: From Google Scholar List to Downloaded Papers

Notes on a small toolbox to collect paper metadata and available PDFs from Google Scholar.

Paper: Deep DeePC

This project is the source code of paper Deep DeePC: Data-enabled predictive control with low or no online optimization using deep learning by X. Zhang, K. Zhang, Z. Li, and X. Yin.

The objective of this work is to learn the DeePC operator using a neural network and bypass the online optimization of conventional DeePC for efficient online implementation.

If you are using this work in your research or teaching, please include explicit acknowledge of this work and of our paper.

Please check the sections of License and Citation at the end.

Paper：link

Source code: link

I. How to use

1. Install required packages:

    pip install -r path/to/requirements.txt

Note: if you want to use GPU, please install GPU version of torch, e.g.:

    pip install torch==1.8.0+cu101 torchvision==0.9.0+cu101 torchaudio===0.8.0 -f https://download.pytorch.org/whl/torch_stable.html

The source code can automatically run on a CPU or GPU without any modification.

• Specifically, two toolboxes are used which are developed by myself deepctools and QYtool for research purposes.

2. Run the project

• The arguments of DDeePC project is defined and modified in ddeepc_args.py, specify the arguments first.
• The training and testing part is in main.py.

a. To generate set-points for selected system:

    python main.py --system (selected systems) --gen_sp (number of set-points) --N (Time steps for one set-point)

For example:

    python main.py --system threetanks --gen_sp 10 --N 100

• Figure of generating set-points:

b. To train and test the model:

    python main.py --system (selected systems) --train --test_num (number of test runs) --N (Time steps for one set-point) --noise (#if add it, apply noise)

After training finished, it will automatically test the model.

For example:

    python main.py --system threetanks --train --test_num 1 --N 100 --noise

• The training process will automatically generate a new folder with a new trial number and save all related data and figures in this path: ./_results/system/new trial number.

• First test the conventional DeePC performance based on current parameters.

• Next start the training process.

• After training, start the test process for Deep DeePC and constrained Deep DeePC.

c. To test the well-trained model:

    python main.py --system (selected systems) --test (model number) --test_num (number of test runs) --N (Time steps for one set-point) --noise (#if add it, apply noise)

For example, to test the well-trained model 3:

    python main.py --threetanks --test 3 --test_num 10 --N 100 --noise

• The test part is identical to the part used in training and can be used for multiple evaluation trials.

II. Organization of Deep DeePC source codes

. 
└── Deep DeePC 
    ├── README.md 
    ├── main.py
    ├── ddeepc_args.py
    ├── DDeePC 
    │   ├── __init__.py
    │   ├── model.py
    │   ├── Plants
    │   │   └── three_tanks.py
    │   ├── deepc.py
    │   ├── train.py
    │   ├── control.py
    │   ├── con_opt.py
    │   └── MyTool.py
    ├── _data
    │   ├── README_fig
    │   │   └── ...
    │   └── threetanks
    │       └── ...
    ├── _results
    │   └── threetanks
    │       └── ...
    ├── .gitignore
    ├── requirements.txt
    └── LICENSE

Additionally, two toolboxes are used which are developed by myself:

• deepctools: A wrapped package for Data-enabled predictive control (DeePC) implementation. Including DeePC and Robust DeePC design with multiple objective functions.
• QYtool: A wrapped useful tool package designed for research purposes, tailored specifically for my own research needs.

III. Introductio to Deep DeePC

1. Training data construction

Figure from our paper Deep DeePC: Data-enabled predictive control with low or no online optimization using deep learning. Please refer to the paper for more details.

2. Offline training

Figure from our paper Deep DeePC: Data-enabled predictive control with low or no online optimization using deep learning. Please refer to the paper for more details.

• Neural network: $\hat{g} = F_{\theta}(\mathbf{u}{ini}, \mathbf{y}{ini}, e_u, e_y

  \theta)$

• Objective function: $J = \mathbb{E}_{\mathcal{D}} \Vert \mathbf{y}^r - \hat{\mathbf{y}} \Vert_Q^2 + \Vert \mathbf{u}^r - \hat{\mathbf{u}} \Vert_R^2 + \omega (\mathbf{u}, \mathbf{y})$

3. Constrainted Deep DeePC for online implementation

Figure from our paper Deep DeePC: Data-enabled predictive control with low or no online optimization using deep learning. Please refer to the paper for more details.

• When predicted trajectories $\hat{\mathbf{u}}_k = U_f \hat{g}_k, \ \hat{\mathbf{y}}_k = Y_f \hat{g}_k$ violate constraints, solve the following optimization problem:

  $min_{g^_k} \Vert g^_k - \hat{g}_k \Vert_2^2$

  s.t. $\quad \mathbf{u}{lb} \leq U_f g^*_k\leq \mathbf{u}{ub}$

  $\mathbf{y}{lb} \leq Y_f g^*_k \leq \mathbf{y}{ub}$

• Then apply the new operator $g^*_k$ to obtain the optimal control action to the system.

IV. Case study on chemical process

Figure from our paper Deep DeePC: Data-enabled predictive control with low or no online optimization using deep learning. Please refer to the paper for more details.

Acknowledgment

The sources code is established and contributed by Xuewen Zhang. This project is the source code of paper X. Zhang, K. Zhang, Z. Li, and X. Yin. Deep DeePC: Data-enabled predictive control with low or no online optimization using deep learning. arXiv preprint arXiv:2408.16338, 2024.

Citation

• If you are using this work in your research or teaching, please include explicit acknowledgment of this work and of our paper:

    @article{zhang2024deepdeepc,
    title={Deep DeePC: Data-enabled predictive control with low or no online optimization using deep learnin},
    author={Zhang, Xuewen and Zhang, Kaixiang and Li, Zhaojian and Yin, Xunyuan},
    journal={arXiv:2408.16338},
    year={2024}
    }
  

• The code also contains the deepctools toolbox for implementing DeePC, developed by Xuewen Zhang. Please be sure to explicitly acknowledge its use if you incorporate it into your work. This project and its license can be found in this link.

• The code also contains the QYtool toolbox for research needs, developed by Xuewen Zhang. Please be sure to explicitly acknowledge its use if you incorporate it into your work. This project and its license can be found in this link.

License

The project is released under the APACHE license. See LICENSE for details.

Copyright 2024 Xuewen Zhang (xuewen001@e.ntu.edu.sg)

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Developed QYtool toolbox

A wrapped useful tool package designed for research purposes, tailored specifically for my own research needs.

Introduction: link

PyPI site: link

I. How to use

This package operates within the Python framework.

1. Required packages

• Numpy
• Torch
• Rich
• Wanbd
• CasADi     <– 3 <= version <= 4

2. Usage

• Download the QYtool file and save it to your project directory.

• Or install using pip

    pip install QYtool

Then you can use the deepctools in your python project.

II. QYtool toolbox organization

. 
└── mytool
    ├── timer: give execution time of function 
    ├── datatool: for data process
    ├── dirtool: for directory operation
    ├── nntool: for neural networks, load model, save model, construct casadi model  
    ├── mathtool: for math operation
    ├── progressbar: an example to build your own custom progressbar
    └── new_wandb_proj: an example of using wandb

Version update

• 1.0.0: initial commit

• 1.0.1 - 1.0.6: under development with name: mytool

• 1.0.7: published and changed name to QYtool

• 1.0.8: update README

License

This project is developed by Xuewen Zhang (xuewen.zhang741@outlook.com).

The project is released under the APACHE license. See LICENSE for details.

Copyright 2024 Xuewen Zhang

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Developed modlinear toolbox

A wrapped package to linearize the nonlinear continuous/discrete model. Including numerical and symbolic calculations.

Github project: link

PyPI: link

I. How to use

This package operates within the Python framework.

1. Required packages

• Numpy
• Matplotlib
• Control
• CasADi     <– 3 <= version <= 4

2. Usage

• Download the modlinear file and save it to your project directory.

• Or install using pip

    pip install modlinear

Then you can use the modlinear in your python project.

II. modlinear toolbox organization

. 
└── modlinear 
    ├── cas_linearize 
    ├── linearize_continuous 
    ├── linearize_c2d
    ├── continuous_to_discrete
    └── plot_matrix

Detailed introduction of each function can be found using help in python.

1. cas_linearize

Symbolic calculation

Obtain the linearized continuous/discrete A, B symbolic functions for the continuous/discrete ODE.

• Continuous/discrete A, B from continuous ODE
• Discrete A, B from discrete ODE

Due to symbolic functions, the A, B at any expand state can be easily obtained by giving the state values.

2. linearize_continuous

Numerical calculation

Obtain the linearized continuous A, B matrices for the continuous ODE.

3. linearize_c2d

Numerical calculation

Obtain the linearized discrete A, B matrices for the continuous ODE.

4. continuous_to_discrete

Numerical calculation

Obtain the discrete model from the continuous model, utilizing control package.

5. plot_matrix

Plot a matrix.

II. Linearization process

1. Indicate the set-point that will be expanded: $x_{ss}, u_{ss}, p_{ss}$.
2. Compute the Jacobian of the system and obtain $A$, $B$, $M$, and $C$ matrix of the continuous linear system.

   $(x_{t+1} - x_{ss}) = A (x_t - x_{ss}) + B (u_{t} - u_{ss}) + M (p_{t} - p_{ss})$

   $y_k = C x_k$

   which equals to: $(x_{k+1} - x_{ss}) = A (x_k - x_{ss}) + [B, M] [u_k - u_{ss}, z_k -z_{ss}]^T$

3. Transform the continuous linear system to discrete linear system and obtain $A_{dis}$, $B_{dis}$, $M_{dis}$, and $C_{dis}$.

   $(x_{k+1} - x_{ss}) = A_{dis} (x_k - x_{ss}) + B_{dis} (u_{k} - u_{ss}) + M_{dis} (p_{k} - p_{ss})$

   $y_k = C_{dis} x_k$

Note: This procedure is applicable to all systems.

III. Tutorial

There is a tutorial example to illustrate how to use the modlinear to linearize nonlinear models.

Results:

License

The project is released under the APACHE license. See LICENSE for details.

Copyright 2024 Xuewen Zhang

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Upload package to PyPI

Introduction to how to upload your own package project to PyPI.

PyPI site: link

I. Install required packages

Required packages:

• pip
• build: Generating distribution archives
• twine: Uploading the distribution archives

    py -m pip install --upgrade pip
    py -m pip install --upgrade build
    py -m pip install --upgrade twine

II. Creating the package files

Put your package files under src/package_name/.

packaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── src/
│   └── package_name/
│       ├── __init__.py
│       └── example.py
└── tests/

1. README.md

Create a README.md markdown file which will be shown in the PyPI package website.

2. LICENSE

Create a license for your package. link

3. pyproject.toml

The pyproject.toml tells build frontend tools like pip and build which backend to use for your project. link

An example:

    [build-system]
    requires = ["hatchling"]
    build-backend = "hatchling.build"

    [project]
    name = "spam-eggs"
    version = "2020.0.0"
    dependencies = [
    "httpx",
    "gidgethub[httpx]>4.0.0",
    "django>2.1; os_name != 'nt'",
    "django>2.0; os_name == 'nt'",
    ]
    requires-python = ">=3.8"
    authors = [
    {name = "Pradyun Gedam", email = "pradyun@example.com"},
    {name = "Tzu-Ping Chung", email = "tzu-ping@example.com"},
    {name = "Another person"},
    {email = "different.person@example.com"},
    ]
    maintainers = [
    {name = "Brett Cannon", email = "brett@example.com"}
    ]
    description = "Lovely Spam! Wonderful Spam!"
    readme = "README.rst"
    license = {file = "LICENSE.txt"}
    keywords = ["egg", "bacon", "sausage", "tomatoes", "Lobster Thermidor"]
    classifiers = [
    "Development Status :: 4 - Beta",
    "Programming Language :: Python"
    ]

    [project.optional-dependencies]
    gui = ["PyQt5"]
    cli = [
    "rich",
    "click",
    ]

    [project.urls]
    Homepage = "https://example.com"
    Documentation = "https://readthedocs.org"
    Repository = "https://github.com/me/spam.git"
    "Bug Tracker" = "https://github.com/me/spam/issues"
    Changelog = "https://github.com/me/spam/blob/master/CHANGELOG.md"

    [project.scripts]
    spam-cli = "spam:main_cli"

    [project.gui-scripts]
    spam-gui = "spam:main_gui"

    [project.entry-points."spam.magical"]
    tomatoes = "spam:main_tomatoes"

III. Generating distributions archives

Run the following command under the directory where pyproject.toml is located:

    py -m build

This command should output a lot of text and once completed should generate two files in the dist directory:

    dist/
    ├── example_package_YOUR_USERNAME_HERE-0.0.1-py3-none-any.whl
    └── example_package_YOUR_USERNAME_HERE-0.0.1.tar.gz

IV. Uploading the distribution archives

1. Upload to TestPyPI

Upload to TestPyPI for testing and experimentation.

• First register an account on TestPyPI.
• Create a TestPyPI API token, setting the “Scope” to “Entire account”.

Then using the following commands to upload your packages:

    py -m twine upload --repository testpypi dist/*

You will be prompted for a username and password. For the username, use token. For the password, use the token value, including the pypi- prefix.

After the command completes, you should see output similar to this:

    Uploading distributions to https://test.pypi.org/legacy/
    Enter your username: __token__
    Uploading example_package_YOUR_USERNAME_HERE-0.0.1-py3-none-any.whl
    100% ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 8.2/8.2 kB • 00:01 • ?
    Uploading example_package_YOUR_USERNAME_HERE-0.0.1.tar.gz
    100% ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 6.8/6.8 kB • 00:00 • ?

Once uploaded, your package should be viewable on TestPyPI; for example: https://test.pypi.org/project/example_package_YOUR_USERNAME_HERE.

2. Upload to PyPI

When the package is ready, you can upload to PyPI instead TestPyPI.

• First register an account on PyPI.
• Create a TestPyPI [API token], setting the “Scope” to “Entire account”.

Then using the following commands to upload your packages:

    twine upload dist/*

You will be prompted for a username and password. For the username, use token. For the password, use the token value, including the pypi- prefix.

Once uploaded, your package should be viewable on PyPI.

Developed deepctools toolbox

Introduction to my developed deepctools toolbox for data-enabled predictive control.

Github project: link

PyPI site: link

DeePCtools

A wrapped package for Data-enabled predictive control (DeePC) implementation. Including DeePC and Robust DeePC design with multiple objective functions.

If you have questions, remarks, technical issues etc. feel free to use the issues page of this repository. I am looking forward to your feedback and the discussion.

I. How to use

This package operates within the Python framework.

1. Required packages

• Numpy
• Matplotlib
• CasADi     <– 3 <= version <= 4

2. Usage

• Download the deepctools file and save it to your project directory.

• Or install using pip

    pip install deepctools

Then you can use the deepctools in your python project.

II. deepctools toolbox organization

. 
└── deeptools 
    ├── hankel 
    ├── deepctools 
    │   ├── initialize_DeePCsolver
    │   ├── initialize_RDeePCsolver
    │   └── solver_step
    ├── getCasadiFunc 
    └── DiscreteSimulator

Under this file and function, there is detailed explanation of the usage, inputs, outputs of the functions.

1. hankel

Construct Hankel matrix of order L based on data x

• The data x: $x \in \mathbb{R}^{T, n_x}$
• The Hankel matrix: $H_L(x) \in \mathbb{R}^{n_x L \times T - L + 1}$

2. deepctools

Formulate and solve the DeePC problem, including DeePC and Robust DeePC design.

Construct the nlp solver for DeePC using CasADi IPOPT sovler, only formulate the solver once at the first beginning.

In the online loop, no need to reformulate the NLP problem which saves lots of computational time.

Each iteration, only need provide updated parameters: $u_{ini}$, $y_{ini}$.

Objective function: $J = \Vert y - y^r \Vert_Q^2 + \Vert u_{loss} \Vert_R^2 + \mathcal{o}(\sigma_y, g)$

$u_{loss}$ can be:

        'u': u

        'uus': u - u_ref

        'du': delta u

There is a tutorial file in tutorial.py.

a. initialize_DeePCsolver(uloss, opts)

Formulate the DeePC design with different loss on control inputs.

The optmization problem can be formulated as:

        Standard DeePC design:                        |            Equivalent expression
     min J  =  || y - yref ||_Q^2 + || uloss ||_R^2   |   min J  =  || Uf*g - yref ||_Q^2 + || uloss ||_R^2
         s.t.   [Up]       [uini]                     |      s.t.   Up * g = uini
                [Yp] * g = [yini]                     |             Yp * g = yini
                [Uf]       [ u  ]                     |             ulb <= u <= uub
                [Yf]       [ y  ]                     |             ylb <= y <= yub
                ulb <= u <= uub                       |
                ylb <= y <= yub                       |  uloss = (u)   or    (u - uref)    or    (du)

b. initialize_RDeePCsolver

Formulate the Robust DeePC design with slack variables and different loss on control inputs.

The optmization problem can be formulated as:

              Robust DeePC design:                    |            Equivalent expression
     min J  =  || y - yref ||_Q^2 + || uloss ||_R^2   |   min J  =  || Uf*g - ys ||_Q^2 + || uloss ||_R^2
                 + lambda_y||sigma_y||_2^2            |             + lambda_y||Yp*g-yini||_2^2
                 + lambda_g||g||_2^2                  |             + lambda_g||g||_2^2
         s.t.   [Up]       [uini]     [   0   ]       |      s.t.   Up * g = uini
                [Yp] * g = [yini]  +  [sigma_y]       |             ulb <= u <= uub
                [Uf]       [ u  ]     [   0   ]       |             ylb <= y <= yub
                [Yf]       [ y  ]     [   0   ]       |
                ulb <= u <= uub                       |
                ylb <= y <= yub                       |  uloss = (u)   or    (u - uref)    or    (du)

c. solver_step

Solve the optimization problem for one step, and output the optimized control inputs, operator g, and solving time.

3. getCasadiFunc

Construct the Function using CasADi

4. DiscreteSimulator

Construct the discrete system simulator for predicting next step

III. Tutorial

This is a tutorial example to illustrate how to use the deepctools to develop and implement DeePC design to different processes.

1. Plant

A simple discrete-time nonlinear model of polynomial single-input-single-output system is used:

        y(t) = 4 * y(t-1) * u(t-1) - 0.5 * y(t-1) + 2 * u(t-1) * u(t) + u(t)

The model has been crafted as a Plant class to facilitate its utilization.

Notice:

• This system is adopted from the paper.
• Note this plant is a nonlinear model which do not satisfy the assumption of Fundamental Lemma, the control performance can be bad.
• For your own project, you can replace this plant to your own system.

2. DeePC designs

Within the sample code, you have the option to specify either DeePC or Robust DeePC design, along with various objective functions. This segment is implemented within the main function.

3. Tutorial results

Feasible DeePC config:

     DeePC        |  {Tini:1, Np:5, T:5, uloss:uus}    | T merely influence the performance as long as T>=5 
     Robust DeePC |  {Tini:1, Np:1, T:600, uloss:du}   | T will influence the steady-state loss 
     Robust DeePC |  {Tini:1, Np:1, T:600, uloss:uus}  | T will influence the steady-state loss
     Robust DeePC |  {Tini:1, Np:1, T:600, uloss:u}    | T will influence the steady-state loss

Figure of control peformance under first config:

License

The project is released under the APACHE license. See LICENSE for details.

Copyright 2024 Xuewen Zhang

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Introduction to Jekyll

Try to learn the Jekyll and take some notes

MATLAB plot functions

Some useful information on MATLAB plot

Introduction to CasADi

Notes on CasADi, especially the usage of variables in CasADi

Daily life

Shot by GRIIIx.

My logo

My logo artworks.

Black and White

Some black ideas.

Messiness

Messy plots.