├── .DS_Store ├── 2021_L4DC_DataDriven-SLS ├── .DS_Store ├── Data_SLS_L4DC_2021_extended.pdf └── experiments │ ├── .ipynb_checkpoints │ ├── L4DC Controller Synthesis-checkpoint.ipynb │ ├── L4DC Data Processing-checkpoint.ipynb │ └── L4DC Sample Complexity-checkpoint.ipynb │ ├── Hwnorms.png │ ├── Jnoms.txt │ ├── JrobBs.txt │ ├── JrobTs.txt │ ├── Jstars.txt │ ├── L4DC Controller Synthesis.ipynb │ ├── L4DC Data Processing.ipynb │ ├── L4DC Sample Complexity.ipynb │ ├── README.md │ ├── gammaBs.txt │ ├── gammaTs.txt │ ├── lqr-costs.png │ ├── normunoms.txt │ ├── normurobBs.txt │ ├── normurobTs.txt │ ├── normustars.txt │ ├── normxnoms.txt │ ├── normxrobBs.txt │ ├── normxrobTs.txt │ ├── normxstars.txt │ ├── unorms.png │ └── xnorms.png ├── 2022_OJCS_DataDriven-DLMPC ├── Fig1_Optimality │ ├── plot_optimality.m │ └── script_optimality.m ├── Fig2_cost_locality │ ├── plot_cost_locality.m │ └── script_cost_locality.m ├── Fig3_tl_d │ ├── plot_tl_d.m │ └── script_tl_d.m ├── Fig4_runtime │ ├── plot_scalability.m │ └── script_scalability.m ├── Fig5_tl_network │ ├── plot_tl_net.m │ └── script_tl_net.m ├── README.md ├── lib │ ├── cent_opt.m │ ├── centralized.m │ ├── data_driven_lib.m │ ├── data_opt.m │ ├── ddd.m │ └── environment.m └── results │ ├── cost_locality.mat │ ├── cost_locality_chain.mat │ ├── optimality.mat │ ├── optimality_chain.mat │ ├── scalability_chain.mat │ ├── tl_d.mat │ ├── tl_d_chain.mat │ ├── tl_net.mat │ └── tl_net_chain.mat └── README.md /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/.DS_Store -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2021_L4DC_DataDriven-SLS/.DS_Store -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/Data_SLS_L4DC_2021_extended.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2021_L4DC_DataDriven-SLS/Data_SLS_L4DC_2021_extended.pdf -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/.ipynb_checkpoints/L4DC Controller Synthesis-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "using LinearAlgebra\n", 10 | "using JuMP\n", 11 | "using MathOptInterface\n", 12 | "using Dualization\n", 13 | "using Convex\n", 14 | "using MosekTools\n", 15 | "using Plots\n", 16 | "using Statistics\n", 17 | "using ControlSystems\n", 18 | "using Dates\n", 19 | "using DelimitedFiles" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "---------------------------" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "# The non-block dynamics of an LTI system\n", 36 | "struct Lti\n", 37 | " n::Int64 # State dimension\n", 38 | " m::Int64 # Control dimension\n", 39 | " A::Matrix{Float64} # n x n matrix\n", 40 | " B::Matrix{Float64} # n x m matrix\n", 41 | " sigma::Float64\n", 42 | " Lti(A, B, sigma) = (\n", 43 | " A = Matrix{Float64}(A);\n", 44 | " B = Matrix{Float64}(B);\n", 45 | " sigma = Float64(sigma);\n", 46 | " (ah, aw) = size(A); @assert ah == aw;\n", 47 | " (bh, bw) = size(B); @assert bh == aw;\n", 48 | " new(ah, bw, A, B, sigma)\n", 49 | " )\n", 50 | "end\n", 51 | "\n", 52 | "# The Ocal matrix\n", 53 | "function Ocal(L::Int64, X)\n", 54 | " (xh, xw) = size(X)\n", 55 | " @assert xh == xw\n", 56 | " M = zeros(0, xw)\n", 57 | " for t = 0:L-1; M = [M; X^t] end\n", 58 | " return Matrix{Float64}(M)\n", 59 | "end\n", 60 | "\n", 61 | "# The Tcal matrix\n", 62 | "function Tcal(lti::Lti, L::Int64, X)\n", 63 | " n = lti.n\n", 64 | " A = lti.A\n", 65 | " (xh, xw) = size(X)\n", 66 | " @assert n == xh\n", 67 | " T = zeros(n * L, 0)\n", 68 | " Z = Matrix{Float64}(kron(Bidiagonal(zeros(L), ones(L - 1), :L), I(n)))\n", 69 | " for t = 1:L; T = [T (Z^t * Ocal(L, A) * X)] end\n", 70 | " return Matrix{Float64}(T)\n", 71 | "end\n", 72 | "\n", 73 | "# Block dynamics parameterized by a data of type Lti\n", 74 | "struct BlockLti\n", 75 | " lti::Lti\n", 76 | " L::Int64\n", 77 | " Acal::Matrix{Float64} # nL x nL block matrix\n", 78 | " Bcal::Matrix{Float64} # nL x mL block matrix\n", 79 | " Zcal::Matrix{Float64} # nL x nL block matrix\n", 80 | " BlockLti(lti::Lti, L::Int64) = (\n", 81 | " In = Matrix{Float64}(I(lti.n));\n", 82 | " Acal = kron(I(L), lti.A);\n", 83 | " Bcal = kron(I(L), lti.B);\n", 84 | " Zcal = Matrix{Float64}(kron(Bidiagonal(zeros(L), ones(L - 1), :L), In));\n", 85 | " new(lti, L, Acal, Bcal, Zcal)\n", 86 | " )\n", 87 | "end\n", 88 | ";" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [ 97 | "# Explicitly store information about a Hankel matrix in a struct\n", 98 | "struct Hankel\n", 99 | " d::Int64 # Dimension of underlying signal\n", 100 | " L::Int64\n", 101 | " T::Int64\n", 102 | " H::Matrix{Float64} # dL x (T - L + 1) dimensional block matrix\n", 103 | " Hankel(d::Int64, H) = (\n", 104 | " H = Matrix{Float64}(H);\n", 105 | " (hh, hw) = size(H);\n", 106 | " @assert mod(hh, d) == 0;\n", 107 | " L = Int64(hh / d);\n", 108 | " T = hw + L - 1;\n", 109 | " new(d, L, T, H)\n", 110 | " )\n", 111 | "end\n", 112 | "\n", 113 | "# Generate a trajectory of states starting from x0,\n", 114 | "# given a control sequence u and noise sequence w,\n", 115 | "# with respect to the dynamics given by lti::Lti\n", 116 | "function xtraj(lti::Lti, x0::Array{Float64}, u::Array{Float64}, w::Array{Float64})\n", 117 | " n = lti.n; m = lti.m; A = lti.A; B = lti.B\n", 118 | " \n", 119 | " @assert length(x0) == n\n", 120 | " @assert length(u) / m == length(w) / n\n", 121 | " @assert mod(length(u), m) == 0\n", 122 | " @assert mod(length(w), n) == 0\n", 123 | " \n", 124 | " T = Int64(length(u) / m)\n", 125 | " \n", 126 | " x = zeros(n*T)\n", 127 | " x[1:n] = x0\n", 128 | " for t = 0:(T-2)\n", 129 | " (tlo, thi) = ((n * t) + 1, n * (t + 1))\n", 130 | " x[(tlo + n):(thi + n)] = A * x[tlo:thi] + B * u[tlo:thi] + w[tlo:thi]\n", 131 | " end\n", 132 | " \n", 133 | " return x\n", 134 | "end\n", 135 | "\n", 136 | "# We use z to denote system states _without_ process noise,\n", 137 | "# so this merely passes w = zeros(n * T) to the xtraj function\n", 138 | "function ztraj(lti::Lti, z0::Array{Float64}, u::Array{Float64})\n", 139 | " @assert mod(length(u), lti.m) == 0\n", 140 | " T = Int64(length(u) / lti.m)\n", 141 | " return xtraj(lti, z0, u, zeros(lti.n * T))\n", 142 | "end\n", 143 | "\n", 144 | "# Generate the Hankel data struct, assuming z is a stacked vector with block dimension d\n", 145 | "function Hankelize(z::Array{Float64}, d::Int64, L::Int64)::Hankel\n", 146 | " N = Int64(round(length(z) / d))\n", 147 | " @assert length(z) == N * d\n", 148 | " z = reshape(z, (d, N))\n", 149 | " H = Matrix{Float64}(zeros(d * L, N - L + 1))\n", 150 | " for i = 1:(N - L + 1); H[:, i] = (z[:, i:(i + L - 1)])[:] end\n", 151 | " return Hankel(d, H)\n", 152 | "end\n", 153 | "\n", 154 | "# The Wcal matrices for relating the noisy states Hx to the noiseless Hz\n", 155 | "function W(lti::Lti, t::Int64, w::Array{Float64})\n", 156 | " n = lti.n\n", 157 | " A = lti.A\n", 158 | " \n", 159 | " @assert mod(length(w), n) == 0\n", 160 | " \n", 161 | " acc = zeros(n)\n", 162 | " for k = 0:t-1\n", 163 | " (wlo, whi) = ((n * k) + 1, n * (k + 1))\n", 164 | " acc = acc + A^(t - 1 - k) * w[wlo:whi]\n", 165 | " end\n", 166 | " return acc\n", 167 | "end\n", 168 | ";" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": null, 174 | "metadata": {}, 175 | "outputs": [], 176 | "source": [ 177 | "# System dynamics of the slightly unstable graph Laplacian\n", 178 | "lti = Lti(\n", 179 | " # A\n", 180 | " [ 1.01 0.01 0.00;\n", 181 | " 0.01 1.01 0.01;\n", 182 | " 0.00 0.01 1.01 ],\n", 183 | " \n", 184 | " # B\n", 185 | " Matrix{Float64}(I(3)),\n", 186 | " \n", 187 | " # sigma\n", 188 | " sqrt(0.1)\n", 189 | ")\n", 190 | "\n", 191 | "# Hankel matrix parameters\n", 192 | "L = 10\n", 193 | "T = 45\n", 194 | "blk = BlockLti(lti, L)\n", 195 | ";" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": null, 201 | "metadata": {}, 202 | "outputs": [], 203 | "source": [ 204 | "# Sanity check things about the (block) system dynamics;\n", 205 | "# Will cause an assertion failure if something is wrong\n", 206 | "function sanitycheck()\n", 207 | " N = 2000\n", 208 | " x0 = [10.0; 10.0; 10.0]\n", 209 | " \n", 210 | " u = zeros(lti.m * T)\n", 211 | " w = zeros(lti.n * T)\n", 212 | " x = zeros(lti.n * T)\n", 213 | " z = zeros(lti.n * T)\n", 214 | " \n", 215 | " for k = 1:N\n", 216 | " ku = randn(lti.m * T)\n", 217 | " kw = randn(lti.n * T) * lti.sigma\n", 218 | " kx = xtraj(lti, x0, ku, kw)\n", 219 | " kz = ztraj(lti, x0, ku)\n", 220 | " \n", 221 | " u = u + ku\n", 222 | " w = w + kw\n", 223 | " x = x + kx\n", 224 | " z = z + kz\n", 225 | " end\n", 226 | " \n", 227 | " u = u / N\n", 228 | " x = x / N\n", 229 | " z = z / N\n", 230 | " w = w / N\n", 231 | " \n", 232 | " # Toggle to use a single noise trajectory instead\n", 233 | "# u = randn(lti.m * T)\n", 234 | "# w = randn(lti.n * T) * (lti.sigma / sqrt(N))\n", 235 | "# x = xtraj(lti, x0, u, w)\n", 236 | "# z = ztraj(lti, x0, u)\n", 237 | " \n", 238 | " \n", 239 | " Hankx = Hankelize(x, lti.n, blk.L)\n", 240 | " Hankz = Hankelize(z, lti.n, blk.L)\n", 241 | " Hanku = Hankelize(u, lti.m, blk.L)\n", 242 | " Hankw = Hankelize(w, lti.n, blk.L)\n", 243 | " \n", 244 | " \n", 245 | " epsT = opnorm(Hankw.H)\n", 246 | " println(\"epsT = \" * string(epsT))\n", 247 | "\n", 248 | " Wcal = zeros(lti.n, 0)\n", 249 | " for t = 0:T-L; Wcal = [Wcal W(lti, t, w)]end\n", 250 | "\n", 251 | " Eyen = Matrix{Float64}(I(lti.n))\n", 252 | "\n", 253 | " @assert norm(Hankz.H + Tcal(lti, L, Eyen) * Hankw.H + Ocal(L, lti.A) * Wcal - Hankx.H) < 0.00001\n", 254 | "end\n", 255 | "\n", 256 | "sanitycheck()" 257 | ] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "--------------------" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": null, 269 | "metadata": {}, 270 | "outputs": [], 271 | "source": [ 272 | "# The LQR cost data structure\n", 273 | "struct Lqr\n", 274 | " n::Int64\n", 275 | " m::Int64\n", 276 | " Q::Matrix{Float64}\n", 277 | " R::Matrix{Float64}\n", 278 | " sigma::Float64\n", 279 | " Lqr(Q, R, sigma) = (\n", 280 | " Q = Matrix{Float64}(Q);\n", 281 | " R = Matrix{Float64}(R);\n", 282 | " sigma = Float64(sigma);\n", 283 | " (qh, qw) = size(Q); @assert qh == qw;\n", 284 | " (rh, rw) = size(R); @assert rh == rw;\n", 285 | " new(qh, rh, Q, R, sigma)\n", 286 | " )\n", 287 | "end\n", 288 | "\n", 289 | "# The LQR, except in block form, so the Qcal, Rcal etc matrices are also stored\n", 290 | "# This distinction is made to reflect the Lti vs BlockLti structs earlier\n", 291 | "struct BlockLqr\n", 292 | " lqr::Lqr\n", 293 | " L::Int64\n", 294 | " Qcal::Matrix{Float64}\n", 295 | " Rcal::Matrix{Float64}\n", 296 | " sqrtQcal::Matrix{Float64}\n", 297 | " sqrtRcal::Matrix{Float64}\n", 298 | " BlockLqr(lqr::Lqr, L::Int64, QL, RL) = (\n", 299 | " @assert size(lqr.Q) == size(QL);\n", 300 | " (qh, qw) = size(QL);\n", 301 | " Qcal = kron(I(L), lqr.Q);\n", 302 | " Qcal[(end - qh + 1):end, (end - qw + 1):end] = QL;\n", 303 | " \n", 304 | " @assert size(lqr.R) == size(RL);\n", 305 | " (rh, rw) = size(RL);\n", 306 | " Rcal = kron(I(L), lqr.R);\n", 307 | " Rcal[(end - rh + 1):end, (end - rw + 1):end] = RL;\n", 308 | " \n", 309 | " sqrtQcal = sqrt(Qcal);\n", 310 | " sqrtRcal = sqrt(Rcal);\n", 311 | " new(lqr, L, Qcal, Rcal, sqrtQcal, sqrtRcal)\n", 312 | " ) \n", 313 | "end\n", 314 | ";" 315 | ] 316 | }, 317 | { 318 | "cell_type": "code", 319 | "execution_count": null, 320 | "metadata": {}, 321 | "outputs": [], 322 | "source": [ 323 | "# Expression of the Block LQR cost, before the Frobenius norm is taken\n", 324 | "function LqrExpr(blqr::BlockLqr, PhiX, PhiU)\n", 325 | " E = blqr.lqr.sigma * [blqr.sqrtQcal * PhiX; blqr.sqrtRcal * PhiU]\n", 326 | " return E\n", 327 | "end\n", 328 | "\n", 329 | "# Generate an Ocal(Z')' matrix as used in the paper\n", 330 | "function OcalZ(blk::BlockLti)\n", 331 | " return Matrix{Float64}(Ocal(L, blk.Zcal')')\n", 332 | "end\n", 333 | "\n", 334 | "# Given the system (blk::BlockLti), costs (blqr::BlockLqr),\n", 335 | "# and data matrices (Hx::Hankel, Hu::Hankel), synthesize a G.\n", 336 | "# Additional parameters include whether we are doing robust synthesis\n", 337 | "function findG(blk::BlockLti, blqr::BlockLqr, Hx::Hankel, Hu::Hankel; robust=false, epsilon=-1, gamma=0.0)\n", 338 | " # Problem dimensions\n", 339 | " n = blk.lti.n; m = blk.lti.m;\n", 340 | " L = Hx.L; T = Hx.T\n", 341 | " \n", 342 | " # Sanity check dimensions and whether robustness is enabled\n", 343 | " @assert (m, n) == (Hu.d, Hx.d)\n", 344 | " @assert (Hx.L, Hx.T) == (Hu.L, Hu.T)\n", 345 | " # robust == true implies (gamma > 0) and (epsilon > 0)\n", 346 | " @assert (!robust) || (gamma > 0 && epsilon > 0)\n", 347 | " \n", 348 | " # Swap these two lines to dualize the problem, or not\n", 349 | " model = Model(dual_optimizer(optimizer_with_attributes(\n", 350 | " # model = Model((optimizer_with_attributes(\n", 351 | " Mosek.Optimizer,\n", 352 | " # \"QUIET\" => false,\n", 353 | " \"QUIET\" => true,\n", 354 | " \"INTPNT_CO_TOL_DFEAS\" => 1e-9\n", 355 | " )))\n", 356 | " \n", 357 | " # Declare the G matrix\n", 358 | " (gh, gw) = (T - L + 1, n)\n", 359 | " @variable(model, G[1:(gh * L), 1:(gw * L)])\n", 360 | " \n", 361 | " # Declare a cost variable\n", 362 | " @variable(model, cost)\n", 363 | " \n", 364 | " # The PhiX and PhiU matrices can be defined in terms of G\n", 365 | " PhiX = OcalZ(blk) * kron(I(L), Hx.H) * G\n", 366 | " PhiU = OcalZ(blk) * kron(I(L), Hu.H) * G\n", 367 | " \n", 368 | " # Encode the objective cost this way because of JuMP's API\n", 369 | " @constraint(model, [cost; vec(LqrExpr(blqr, PhiX, PhiU))] in SecondOrderCone())\n", 370 | " \n", 371 | " # Block diagonals are in the Gamma set\n", 372 | " for k = 0:L-1\n", 373 | " # Diagonal is identity in the PhiX matrix\n", 374 | " (plo, phi) = (k * n + 1, k * n + n)\n", 375 | " @constraint(model, PhiX[plo:phi, plo:phi] .== Matrix{Float64}(I(n)))\n", 376 | " \n", 377 | " # If robustness is enabled, additionally enable opnorm constraints\n", 378 | " if robust\n", 379 | " (grlo, grhi) = (k * gh + 1, k * gh + gh)\n", 380 | " (gclo, gchi) = (k * gw + 1, k * gw + gw)\n", 381 | " Gk = G[grlo:grhi, gclo:gchi]\n", 382 | " gnorm = gamma / (epsilon * sqrt(L))\n", 383 | " # println(\"gnorm = \" * string(gnorm))\n", 384 | " @constraint(model, [gnorm; vec(Gk)] in MOI.NormSpectralCone(gh, gw))\n", 385 | " end\n", 386 | " end\n", 387 | " \n", 388 | " # Block lower triangular structure\n", 389 | " for i = 0:(L - 1)\n", 390 | " for j = (i + 1):(L - 1)\n", 391 | " (xrlo, xrhi) = (i * n + 1, i * n + n)\n", 392 | " (xclo, xchi) = (j * n + 1, j * n + n)\n", 393 | " @constraint(model, PhiX[xrlo:xrhi, xclo:xchi] .== zeros(n, n))\n", 394 | " \n", 395 | " (urlo, urhi) = (i * m + 1, i * m + m)\n", 396 | " (uclo, uchi) = (j * n + 1, j * n + n)\n", 397 | " @constraint(model, PhiU[urlo:urhi, uclo:uchi] .== zeros(m, n))\n", 398 | " \n", 399 | " (grlo, grhi) = (i * gh + 1, i * gh + gh)\n", 400 | " (gclo, gchi) = (j * gw + 1, j * gw + gw)\n", 401 | " @constraint(model, G[grlo:grhi, gclo:gchi] .== Matrix{Float64}(zeros(gh, gw)))\n", 402 | " end\n", 403 | " end\n", 404 | " \n", 405 | " # The strictly lower block triangles of G are also zero\n", 406 | " for i = 0:(L - 1)\n", 407 | " for j = 0:(i - 1)\n", 408 | " (grlo, grhi) = (i * gh + 1, i * gh + gh)\n", 409 | " (gclo, gchi) = (j * gw + 1, j * gw + gw)\n", 410 | " @constraint(model, G[grlo:grhi, gclo:gchi] .== Matrix{Float64}(zeros(gh, gw)))\n", 411 | " end\n", 412 | " end\n", 413 | "\n", 414 | " # For the robust problem, the 1/(1-gamma) part is done in the outer quasi-convex loop\n", 415 | " @objective(model, Min, cost)\n", 416 | " \n", 417 | " optimize!(model)\n", 418 | " return (model, value.(G))\n", 419 | "end\n", 420 | ";" 421 | ] 422 | }, 423 | { 424 | "cell_type": "code", 425 | "execution_count": null, 426 | "metadata": {}, 427 | "outputs": [], 428 | "source": [ 429 | "## Non-robust synthesis\n", 430 | "function findGstar(blk::BlockLti, blqr::BlockLqr, Hz::Hankel, Hu::Hankel)\n", 431 | " return findG(blk, blqr, Hz, Hu, robust=false)\n", 432 | "end\n", 433 | "\n", 434 | "# Identical to findGstar, except the parameter is named differently for semantics\n", 435 | "function findGnom(blk::BlockLti, blqr::BlockLqr, Hx::Hankel, Hu::Hankel)\n", 436 | " return findG(blk, blqr, Hx, Hu, robust=false)\n", 437 | "end\n", 438 | "\n", 439 | "# Find a robust G wrt some epsilon > 0\n", 440 | "function findGrob(blk::BlockLti, blqr::BlockLqr, Hx::Hankel, Hu::Hankel, epsilon)\n", 441 | " n = blk.lti.n; m = blk.lti.m\n", 442 | " L = Hx.L; T = Hx.T\n", 443 | " @assert (m, n) == (Hu.d, Hx.d)\n", 444 | " @assert (Hx.L, Hx.T) == (Hu.L, Hu.T)\n", 445 | " @assert epsilon > 0\n", 446 | " \n", 447 | " # Search range of gamma\n", 448 | " (left, right) = (1e-5, 1 - 1e-5)\n", 449 | " mid = (left + right) / 2\n", 450 | " \n", 451 | " # model and Grob are what we eventually return\n", 452 | " model = Model()\n", 453 | " Grob = zeros(n * L, T - L + 1)\n", 454 | " \n", 455 | " # Counters\n", 456 | " feasible = false\n", 457 | " iters = 0\n", 458 | " \n", 459 | " while (right - left > 1e-2)\n", 460 | " mid = (left + right) / 2\n", 461 | " iters = iters + 1\n", 462 | " (itermodel, iterG) = findG(blk, blqr, Hx, Hu, robust=true, epsilon=epsilon, gamma=mid)\n", 463 | " \n", 464 | " termstat = termination_status(itermodel)\n", 465 | " println(\"term stat: \" * string(termstat) * \" at bisection mid = \" * string(mid))\n", 466 | " if termstat == MOI.OPTIMAL\n", 467 | " model = itermodel\n", 468 | " Grob = iterG\n", 469 | " right = mid\n", 470 | " feasible = true\n", 471 | " else\n", 472 | " left = mid\n", 473 | " end\n", 474 | " end\n", 475 | " \n", 476 | " println(\"Total iterations: \" * string(iters))\n", 477 | " \n", 478 | " if !feasible\n", 479 | " println(\"Warning: problem was never feasible at epsilon = \" * string(epsilon)) \n", 480 | " end\n", 481 | " \n", 482 | " return (model, Grob, mid)\n", 483 | "end\n", 484 | "\n", 485 | ";" 486 | ] 487 | }, 488 | { 489 | "cell_type": "code", 490 | "execution_count": null, 491 | "metadata": {}, 492 | "outputs": [], 493 | "source": [ 494 | "# Define the LQR costs\n", 495 | "lqr = Lqr(1e-3 * Matrix{Float64}(I(lti.n)), Matrix{Float64}(I(lti.m)), lti.sigma)\n", 496 | "\n", 497 | "# While we're at it, we can also examine the DARE solution\n", 498 | "P = dlqr(lti.A, lti.B, lqr.Q, lqr.R)\n", 499 | "\n", 500 | "# blqr = BlockLqr(lqr, blk.L, 4e2 * lqr.Q, lqr.R)\n", 501 | "blqr = BlockLqr(lqr, blk.L, P, lqr.R)\n", 502 | "\n", 503 | ";" 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": null, 509 | "metadata": {}, 510 | "outputs": [], 511 | "source": [ 512 | "# The LQR cost of a K matrix against the true system dynamics\n", 513 | "function trueSystemLqrCost(blk::BlockLti, blqr::BlockLqr, K::Matrix{Float64})\n", 514 | " (kh, kw) = size(K)\n", 515 | " @assert kh == blk.lti.m * L\n", 516 | " @assert kw == blk.lti.n * L\n", 517 | " \n", 518 | " PhiXtrue = inv(I - blk.Zcal * (blk.Acal + blk.Bcal * K))\n", 519 | " J = blqr.lqr.sigma * norm(vec([blqr.sqrtQcal * PhiXtrue; blqr.sqrtRcal * K * PhiXtrue]))\n", 520 | " return J\n", 521 | "end\n", 522 | ";" 523 | ] 524 | }, 525 | { 526 | "cell_type": "code", 527 | "execution_count": null, 528 | "metadata": { 529 | "scrolled": true 530 | }, 531 | "outputs": [], 532 | "source": [ 533 | "function sanitycheck2()\n", 534 | " \n", 535 | " N = 10\n", 536 | " # x0 = [10.0; 10.0; 10.0]\n", 537 | " x0 = [0.0; 0.0; 0.0]\n", 538 | " u = zeros(lti.m * T)\n", 539 | " w = zeros(lti.n * T)\n", 540 | " x = zeros(lti.n * T)\n", 541 | " z = zeros(lti.n * T)\n", 542 | " \n", 543 | " for k = 1:N\n", 544 | " ku = randn(lti.m * T) * sqrt(lti.m * T * 1000)\n", 545 | " kw = randn(lti.n * T) * lti.sigma\n", 546 | " kx = xtraj(lti, x0, ku, kw)\n", 547 | " kz = ztraj(lti, x0, ku)\n", 548 | " \n", 549 | " u = u + ku\n", 550 | " w = w + kw\n", 551 | " x = x + kx\n", 552 | " z = z + kz\n", 553 | " end\n", 554 | " \n", 555 | " u = u / N\n", 556 | " w = w / N\n", 557 | " z = z / N\n", 558 | " x = x / N\n", 559 | " \n", 560 | " # Alternatively, generate data from a distribution\n", 561 | "# u = randn(lti.m * T)\n", 562 | "# w = randn(lti.n * T) * (lti.sigma / sqrt(N))\n", 563 | "# x = xtraj(lti, x0, u, w)\n", 564 | "# z = ztraj(lti, x0, u)\n", 565 | " \n", 566 | " println((norm(z), norm(x), norm(u), norm(w)))\n", 567 | "\n", 568 | " Hankx = Hankelize(x, lti.n, blk.L)\n", 569 | " Hankz = Hankelize(z, lti.n, blk.L)\n", 570 | " Hanku = Hankelize(u, lti.m, blk.L)\n", 571 | " Hankw = Hankelize(w, lti.n, blk.L)\n", 572 | " \n", 573 | " epsT = opnorm(Hankw.H)\n", 574 | " \n", 575 | " println(\"eps: \" * string(epsT))\n", 576 | " println(\"opnorms (Hx, Hz, Hu, Hw) = \" *\n", 577 | " string((opnorm(Hankx.H), opnorm(Hankz.H), opnorm(Hanku.H), opnorm(Hankw.H))))\n", 578 | " \n", 579 | " (model, Gstar) = findGstar(blk, blqr, Hankz, Hanku)\n", 580 | " PhiZstar = OcalZ(blk) * kron(I(L), Hankz.H) * Gstar\n", 581 | " PhiUstar = OcalZ(blk) * kron(I(L), Hanku.H) * Gstar\n", 582 | " Kstar = PhiUstar * inv(PhiZstar)\n", 583 | "\n", 584 | " (_, Gnom) = findGnom(blk, blqr, Hankx, Hanku)\n", 585 | " PhiXnom = OcalZ(blk) * kron(I(L), Hankx.H) * Gnom\n", 586 | " PhiUnom = OcalZ(blk) * kron(I(L), Hanku.H) * Gnom\n", 587 | " Knom = PhiUnom * inv(PhiXnom)\n", 588 | "\n", 589 | " @time (modelB, Grob, gammarob) = findGrob(blk, blqr, Hankx, Hanku, epsT)\n", 590 | "# @time (modelB, Grob) = findG(blk, blqr, Hankx, Hanku, robust=true, gamma=0.5, epsilon=epsT)\n", 591 | " println(termination_status(modelB))\n", 592 | " PhiXrob = OcalZ(blk) * kron(I(L), Hankx.H) * Grob\n", 593 | " PhiUrob = OcalZ(blk) * kron(I(L), Hanku.H) * Grob\n", 594 | " Krob = PhiUrob * inv(PhiXrob)\n", 595 | "\n", 596 | " Jstar = trueSystemLqrCost(blk, blqr, Kstar)\n", 597 | " Jnom = trueSystemLqrCost(blk, blqr, Knom)\n", 598 | " Jrob = trueSystemLqrCost(blk, blqr, Krob)\n", 599 | " \n", 600 | " println(\"(Jstar, Jnom, Jrob) = \" * string((Jstar, Jnom, Jrob)))\n", 601 | "\n", 602 | " println(\"rel err of Jnom vs Jstar = \" * string((Jnom - Jstar) / Jstar))\n", 603 | "\n", 604 | " println(\"rel err of Jrob (eps=0.1) vs Jstar = \" * string((Jrob - Jstar) / Jstar))\n", 605 | "\n", 606 | " println(\"rel err of Jrob (eps=0.1) vs Jnom = \" * string((Jrob - Jnom) / Jnom))\n", 607 | " \n", 608 | "end\n", 609 | "\n", 610 | "sanitycheck2()\n" 611 | ] 612 | }, 613 | { 614 | "cell_type": "markdown", 615 | "metadata": {}, 616 | "source": [ 617 | "-----------------------------------------------" 618 | ] 619 | }, 620 | { 621 | "cell_type": "code", 622 | "execution_count": null, 623 | "metadata": {}, 624 | "outputs": [], 625 | "source": [ 626 | "\n", 627 | "# A single step of the MPC\n", 628 | "# Given x(t), figure out u(t) to derive x(t+1)\n", 629 | "function MpcStep(blk::BlockLti, K::Matrix{Float64}, xt::Array{Float64})\n", 630 | " (n, m) = (blk.lti.n, lti.m)\n", 631 | " (A, B, sigma) = (blk.lti.A, blk.lti.B, blk.lti.sigma)\n", 632 | " L = blk.L\n", 633 | " \n", 634 | " @assert (m * L, n * L) == size(K)\n", 635 | " @assert length(xt) == n\n", 636 | " \n", 637 | " uts = K[:,1:n] * xt\n", 638 | " ut = uts[1:m]\n", 639 | " \n", 640 | " wt = sigma * randn(n)\n", 641 | " xt1 = A * xt + B * ut + wt\n", 642 | " \n", 643 | " return (xt1, ut, wt)\n", 644 | " \n", 645 | "end\n", 646 | "\n", 647 | "# Run an MPC using some K over horizon H and get the LQR costs\n", 648 | "function MpcLoop(blk::BlockLti, K::Matrix{Float64}, x0::Array{Float64}; H=1000)\n", 649 | " n = blk.lti.n\n", 650 | " m = blk.lti.m\n", 651 | " L = blk.L\n", 652 | " (kh, kw) = size(K)\n", 653 | " @assert size(K) == (L * m, L * n)\n", 654 | " \n", 655 | " xhist = x0\n", 656 | " xt = x0\n", 657 | " uhist = []\n", 658 | " whist = []\n", 659 | " for t = 0:H-1\n", 660 | " (xt1, ut, wt) = MpcStep(blk, K, xt)\n", 661 | " uhist = [uhist; ut]\n", 662 | " whist = [whist; wt]\n", 663 | " xt = xt1\n", 664 | " if t < H - 1; xhist = [xhist; xt1] end\n", 665 | " end\n", 666 | " \n", 667 | " return (xhist, uhist, whist)\n", 668 | "end\n", 669 | "\n", 670 | "# Cost of using a particular G in the MPC loop\n", 671 | "function MpcLoopCost(blk::BlockLti, blqr::BlockLqr, Hx::Hankel, Hu::Hankel, G, x0, H)\n", 672 | " PhiX = OcalZ(blk) * kron(I(L), Hx.H) * G\n", 673 | " PhiU = OcalZ(blk) * kron(I(L), Hu.H) * G\n", 674 | " K = PhiU * inv(PhiX)\n", 675 | " (xH, uH, _) = MpcLoop(blk, K, x0, H=H)\n", 676 | " bigQ = kron(I(H), blqr.lqr.Q)\n", 677 | " bigR = kron(I(H), blqr.lqr.R)\n", 678 | " sqrtBigQ = sqrt(bigQ)\n", 679 | " sqrtBigR = sqrt(bigR)\n", 680 | " J = lqr.sigma * norm(vec([sqrtBigQ * xH; sqrtBigR * uH]))\n", 681 | " return (J, norm(xH), norm(uH))\n", 682 | "end\n", 683 | ";" 684 | ] 685 | }, 686 | { 687 | "cell_type": "code", 688 | "execution_count": null, 689 | "metadata": {}, 690 | "outputs": [], 691 | "source": [ 692 | "# Values taken from \"L4DC Sample Complexity\".ipynb\n", 693 | "bootvals = [\n", 694 | "# (1, 3.9541887079997937);\n", 695 | "# (3, 2.311419167690131);\n", 696 | " (10, 1.2410479200418025);\n", 697 | " (31, 0.7166296851847598);\n", 698 | " (100, 0.39373544288332085);\n", 699 | " (316, 0.22195227125386172);\n", 700 | " (1000, 0.12497013402143313);\n", 701 | " (3162, 0.07103707465682507);\n", 702 | " (10000, 0.03887421881685629);\n", 703 | "]\n", 704 | "\n", 705 | "# How many (N, boot eps) values there are\n", 706 | "Bmax = length(bootvals)\n", 707 | "\n", 708 | "# How many independent samples per iteration\n", 709 | "Mmax = 50\n", 710 | "\n", 711 | "# WARNING: The expected runtime of this block\n", 712 | "# takes about 1-2 minute per M, per B,\n", 713 | "# So in the current configuration expect about 350 - 700 minutes!\n", 714 | "# The Mmax value can be reduced to speed things up\n", 715 | "\n", 716 | "# Data that is stored during runs\n", 717 | "Jstars = zeros(Bmax, Mmax)\n", 718 | "Jnoms = zeros(Bmax, Mmax)\n", 719 | "JrobBs = zeros(Bmax, Mmax)\n", 720 | "gammaBs = zeros(Bmax, Mmax)\n", 721 | "JrobTs = zeros(Bmax, Mmax)\n", 722 | "gammaTs = zeros(Bmax, Mmax)\n", 723 | "\n", 724 | "normHxs = zeros(Bmax, Mmax)\n", 725 | "normHzs = zeros(Bmax, Mmax)\n", 726 | "normHus = zeros(Bmax, Mmax)\n", 727 | "normHws = zeros(Bmax, Mmax)\n", 728 | "\n", 729 | "normxstars = zeros(Bmax, Mmax)\n", 730 | "normxnoms = zeros(Bmax, Mmax)\n", 731 | "normxrobBs = zeros(Bmax, Mmax)\n", 732 | "normxrobTs = zeros(Bmax, Mmax)\n", 733 | "\n", 734 | "normustars = zeros(Bmax, Mmax)\n", 735 | "normunoms = zeros(Bmax, Mmax)\n", 736 | "normurobBs = zeros(Bmax, Mmax)\n", 737 | "normurobTs = zeros(Bmax, Mmax)\n", 738 | "\n", 739 | "# Hankel matrix dimensions\n", 740 | "L = 10\n", 741 | "T = 45\n", 742 | "\n", 743 | "@assert L == 10\n", 744 | "@assert T == 45\n", 745 | "\n", 746 | "# Control horizon\n", 747 | "H = 1000\n", 748 | "\n", 749 | "# Start running a big MPC loop\n", 750 | "\n", 751 | "\n", 752 | "println(Dates.format(now(), \"HH:MM:SS\") * \" @ loop start\")\n", 753 | "for bi in 1:Bmax\n", 754 | " (N, epsilonboot) = bootvals[bi]\n", 755 | " \n", 756 | " println(Dates.format(now(), \"HH:MM:SS\") * \" @ bi = \" * string(bi))\n", 757 | " \n", 758 | " for mi = 1:Mmax\n", 759 | " println(Dates.format(now(), \"HH:MM:SS\") * \" @ mi = \" * string(mi))\n", 760 | "\n", 761 | " # Generate N random trajectories\n", 762 | " x0 = zeros(lti.n)\n", 763 | " ubar = randn(lti.m * T)\n", 764 | " \n", 765 | " avgz = zeros(lti.n * T)\n", 766 | " avgx = zeros(lti.n * T)\n", 767 | " avgu = zeros(lti.m * T)\n", 768 | " avgw = zeros(lti.n * T)\n", 769 | " \n", 770 | " for k = 1:N\n", 771 | " u = ubar\n", 772 | " w = lti.sigma * randn(lti.n * T)\n", 773 | " x = xtraj(lti, x0, u, w)\n", 774 | " z = ztraj(lti, x0, u)\n", 775 | " \n", 776 | " avgz = avgz + z\n", 777 | " avgx = avgx + x\n", 778 | " avgu = avgu + u\n", 779 | " avgw = avgw + w\n", 780 | " end\n", 781 | " \n", 782 | " # ... and average the N random trajectories\n", 783 | " avgz = avgz / N\n", 784 | " avgx = avgx / N\n", 785 | " avgu = avgu / N\n", 786 | " avgw = avgw / N\n", 787 | " \n", 788 | " # Toggle to use a single w trajectory\n", 789 | "# avgw = (lti.sigma / sqrt(N)) * randn(lti.n * T)\n", 790 | "# avgu = randn(lti.m * T)\n", 791 | "# avgx = xtraj(lti, x0, avgu, avgw)\n", 792 | "# avgz = ztraj(lti, x0, avgu)\n", 793 | " \n", 794 | " # Use this to build some Hankel matrices\n", 795 | " Hx = Hankelize(avgx, lti.n, L)\n", 796 | " Hz = Hankelize(avgz, lti.n, L)\n", 797 | " Hu = Hankelize(avgu, lti.m, L)\n", 798 | " Hw = Hankelize(avgw, lti.n, L)\n", 799 | " \n", 800 | " # Calculate ||Hw||\n", 801 | " epsilontrue = opnorm(Hw.H)\n", 802 | " println(\"(epsB, epsT) = \" * string((epsilonboot, epsilontrue)))\n", 803 | " \n", 804 | " # Store some norm information on the Hankel matrices\n", 805 | " normHxs[bi, mi] = opnorm(Hx.H)\n", 806 | " normHzs[bi, mi] = opnorm(Hz.H)\n", 807 | " normHus[bi, mi] = opnorm(Hu.H)\n", 808 | " normHws[bi, mi] = opnorm(Hw.H)\n", 809 | " \n", 810 | " # Optimal controller\n", 811 | " (modstar, Gstar) = findGstar(blk, blqr, Hz, Hu)\n", 812 | " if termination_status(modstar) == MOI.OPTIMAL\n", 813 | " (_Jstar, _normx, _normu) = MpcLoopCost(blk, blqr, Hz, Hu, Gstar, x0, H)\n", 814 | " Jstars[bi, mi] = _Jstar\n", 815 | " normxstars[bi, mi] = _normx\n", 816 | " normustars[bi, mi] = _normu\n", 817 | " println(\"Jstar @ \" * string((N, mi)) * \" = \" * string(Jstars[bi, mi]))\n", 818 | " else\n", 819 | " Jstars[bi, mi] = Inf\n", 820 | " normxstars[bi, mi] = Inf\n", 821 | " normustars[bi, mi] = Inf\n", 822 | " println(\"Jstar @ \" * string((N, mi)) * \" is !INFEASIBLE!\") \n", 823 | " end\n", 824 | " \n", 825 | " # Nominal controller\n", 826 | " (modnom, Gnom) = findGnom(blk, blqr, Hx, Hu)\n", 827 | " if termination_status(modnom) == MOI.OPTIMAL\n", 828 | " (_Jnom, _normx, _normu) = MpcLoopCost(blk, blqr, Hx, Hu, Gnom, x0, H)\n", 829 | " Jnoms[bi, mi] = _Jnom\n", 830 | " normxnoms[bi, mi] = _normx\n", 831 | " normunoms[bi, mi] = _normu\n", 832 | " println(\"Jnom @ \" * string((N, mi)) * \" = \" * string(Jnoms[bi, mi]))\n", 833 | " else\n", 834 | " Jnoms[bi, mi] = Inf\n", 835 | " normxnoms[bi, mi] = Inf\n", 836 | " normunoms[bi, mi] = Inf\n", 837 | " println(\"Jnom @ \" * string((N, mi)) * \" is !INFEASIBLE!\")\n", 838 | " end\n", 839 | " \n", 840 | " # Robust bootstrap controller\n", 841 | " (modrobB, GrobB, gammaB) = findGrob(blk, blqr, Hx, Hu, epsilonboot)\n", 842 | " if termination_status(modrobB) == MOI.OPTIMAL\n", 843 | " (_JrobB, _normx, _normu) = MpcLoopCost(blk, blqr, Hx, Hu, GrobB, x0, H)\n", 844 | " JrobBs[bi, mi] = _JrobB\n", 845 | " normxrobBs[bi, mi] = _normx\n", 846 | " normurobBs[bi, mi] = _normu\n", 847 | " gammaBs[bi, mi] = gammaB\n", 848 | " println(\"JrobB @ \" * string((N, mi)) * \" = \" * string(JrobBs[bi, mi]))\n", 849 | " else\n", 850 | " JrobBs[bi, mi] = Inf\n", 851 | " gammaBs[bi, mi] = Inf\n", 852 | " normxrobBs[bi, mi] = Inf\n", 853 | " normurobBs[bi, mi] = Inf\n", 854 | " println(\"JrobB @ \" * string((N, mi)) * \" is !INFEASIBLE!\")\n", 855 | " end\n", 856 | " \n", 857 | " # Robust true-epsilon controller\n", 858 | " (modrobT, GrobT, gammaT) = findGrob(blk, blqr, Hx, Hu, epsilontrue)\n", 859 | " if termination_status(modrobT) == MOI.OPTIMAL\n", 860 | " (_JrobT, _normx, _normu) = MpcLoopCost(blk, blqr, Hx, Hu, GrobT, x0, H)\n", 861 | " JrobTs[bi, mi] = _JrobT\n", 862 | " normxrobTs[bi, mi] = _normx\n", 863 | " normurobTs[bi, mi] = _normu\n", 864 | " gammaTs[bi, mi] = gammaT\n", 865 | " println(\"JrobT @ \" * string((N, mi)) * \" = \" * string(JrobTs[bi, mi]))\n", 866 | " else\n", 867 | " JrobTs[bi, mi] = Inf\n", 868 | " normxrobTs[bi, mi] = Inf\n", 869 | " normurobTs[bi, mi] = Inf\n", 870 | " gammaTs[bi, mi] = Inf\n", 871 | " println(\"JrobT @ \" * string((N, mi)) * \" is !INFEASIBLE!\")\n", 872 | " end\n", 873 | " end\n", 874 | "end\n", 875 | "\n", 876 | "\n", 877 | "println(Dates.format(now(), \"HH:MM:SS\") * \" @ loop end\")" 878 | ] 879 | }, 880 | { 881 | "cell_type": "code", 882 | "execution_count": null, 883 | "metadata": {}, 884 | "outputs": [], 885 | "source": [] 886 | }, 887 | { 888 | "cell_type": "code", 889 | "execution_count": null, 890 | "metadata": {}, 891 | "outputs": [], 892 | "source": [] 893 | }, 894 | { 895 | "cell_type": "code", 896 | "execution_count": null, 897 | "metadata": {}, 898 | "outputs": [], 899 | "source": [] 900 | }, 901 | { 902 | "cell_type": "code", 903 | "execution_count": 18, 904 | "metadata": {}, 905 | "outputs": [ 906 | { 907 | "data": { 908 | "text/plain": [ 909 | "7×4 Array{Float64,2}:\n", 910 | " 157.508 155.468 10.7856 1.08001 \n", 911 | " 155.337 155.925 10.4473 0.607818 \n", 912 | " 168.723 168.968 10.8032 0.349064 \n", 913 | " 158.3 158.196 10.7644 0.189703 \n", 914 | " 149.97 150.226 10.66 0.105729 \n", 915 | " 175.668 175.712 10.7265 0.0604378\n", 916 | " 157.187 157.22 10.5805 0.0342406" 917 | ] 918 | }, 919 | "execution_count": 18, 920 | "metadata": {}, 921 | "output_type": "execute_result" 922 | } 923 | ], 924 | "source": [ 925 | "[mean(normHxs, dims=2) mean(normHzs, dims=2) mean(normHus, dims=2) mean(normHws, dims=2)]" 926 | ] 927 | }, 928 | { 929 | "cell_type": "code", 930 | "execution_count": 19, 931 | "metadata": {}, 932 | "outputs": [ 933 | { 934 | "data": { 935 | "text/plain": [ 936 | "7×4 Array{Float64,2}:\n", 937 | " 2.95019 5422.01 6.27647 6.19573\n", 938 | " 3.04704 2.85068e5 5.86868 6.07503\n", 939 | " 3.02075 4.1484e5 6.01105 5.81962\n", 940 | " 3.02441 1.66553e5 5.95789 5.81807\n", 941 | " 3.01767 88800.9 5.53203 5.43756\n", 942 | " 2.93259 37505.8 5.68597 5.72207\n", 943 | " 3.05018 2.67656e5 5.13257 5.19896" 944 | ] 945 | }, 946 | "execution_count": 19, 947 | "metadata": {}, 948 | "output_type": "execute_result" 949 | } 950 | ], 951 | "source": [ 952 | "[median(normustars, dims=2) median(normunoms, dims=2) median(normurobBs, dims=2) median(normurobTs, dims=2)]" 953 | ] 954 | }, 955 | { 956 | "cell_type": "code", 957 | "execution_count": 20, 958 | "metadata": {}, 959 | "outputs": [ 960 | { 961 | "data": { 962 | "text/plain": [ 963 | "7×4 Array{Float64,2}:\n", 964 | " 1.15077 6145.05 2.13776 2.06918\n", 965 | " 1.19019 3.65391e5 1.97594 2.03781\n", 966 | " 1.17961 5.49699e5 2.01862 1.99888\n", 967 | " 1.17734 1.91532e5 1.97846 1.9275 \n", 968 | " 1.16911 1.18187e5 1.86767 1.79885\n", 969 | " 1.14725 36625.7 1.88762 1.93503\n", 970 | " 1.18694 3.32972e5 1.72762 1.75718" 971 | ] 972 | }, 973 | "execution_count": 20, 974 | "metadata": {}, 975 | "output_type": "execute_result" 976 | } 977 | ], 978 | "source": [ 979 | "[median(Jstars, dims=2) median(Jnoms, dims=2) median(JrobBs, dims=2) median(JrobTs, dims=2)]" 980 | ] 981 | }, 982 | { 983 | "cell_type": "code", 984 | "execution_count": null, 985 | "metadata": {}, 986 | "outputs": [], 987 | "source": [] 988 | }, 989 | { 990 | "cell_type": "code", 991 | "execution_count": null, 992 | "metadata": {}, 993 | "outputs": [], 994 | "source": [] 995 | }, 996 | { 997 | "cell_type": "markdown", 998 | "metadata": {}, 999 | "source": [ 1000 | "---------------------------------------" 1001 | ] 1002 | }, 1003 | { 1004 | "cell_type": "code", 1005 | "execution_count": 21, 1006 | "metadata": {}, 1007 | "outputs": [], 1008 | "source": [ 1009 | "# Save a bunch of results.\n", 1010 | "\n", 1011 | "open(\"Jstars.txt\", \"w\") do io\n", 1012 | " writedlm(io, Jstars)\n", 1013 | "end\n", 1014 | "\n", 1015 | "open(\"Jnoms.txt\", \"w\") do io\n", 1016 | " writedlm(io, Jnoms)\n", 1017 | "end\n", 1018 | "\n", 1019 | "open(\"JrobBs.txt\", \"w\") do io\n", 1020 | " writedlm(io, JrobBs)\n", 1021 | "end\n", 1022 | "\n", 1023 | "open(\"JrobTs.txt\", \"w\") do io\n", 1024 | " writedlm(io, JrobTs)\n", 1025 | "end\n", 1026 | "\n", 1027 | "open(\"gammaBs.txt\", \"w\") do io\n", 1028 | " writedlm(io, gammaBs)\n", 1029 | "end\n", 1030 | "\n", 1031 | "open(\"gammaTs.txt\", \"w\") do io\n", 1032 | " writedlm(io, gammaTs)\n", 1033 | "end\n", 1034 | "\n", 1035 | "\n", 1036 | "open(\"normxstars.txt\", \"w\") do io\n", 1037 | " writedlm(io, normxstars)\n", 1038 | "end\n", 1039 | "\n", 1040 | "\n", 1041 | "open(\"normxnoms.txt\", \"w\") do io\n", 1042 | " writedlm(io, normxnoms)\n", 1043 | "end\n", 1044 | "\n", 1045 | "\n", 1046 | "open(\"normxrobBs.txt\", \"w\") do io\n", 1047 | " writedlm(io, normxrobBs)\n", 1048 | "end\n", 1049 | "\n", 1050 | "\n", 1051 | "open(\"normxrobTs.txt\", \"w\") do io\n", 1052 | " writedlm(io, normxrobTs)\n", 1053 | "end\n", 1054 | "\n", 1055 | "open(\"normustars.txt\", \"w\") do io\n", 1056 | " writedlm(io, normustars)\n", 1057 | "end\n", 1058 | "\n", 1059 | "\n", 1060 | "open(\"normunoms.txt\", \"w\") do io\n", 1061 | " writedlm(io, normunoms)\n", 1062 | "end\n", 1063 | "\n", 1064 | "\n", 1065 | "open(\"normurobBs.txt\", \"w\") do io\n", 1066 | " writedlm(io, normurobBs)\n", 1067 | "end\n", 1068 | "\n", 1069 | "\n", 1070 | "open(\"normurobTs.txt\", \"w\") do io\n", 1071 | " writedlm(io, normurobTs)\n", 1072 | "end\n" 1073 | ] 1074 | }, 1075 | { 1076 | "cell_type": "code", 1077 | "execution_count": null, 1078 | "metadata": {}, 1079 | "outputs": [], 1080 | "source": [] 1081 | }, 1082 | { 1083 | "cell_type": "code", 1084 | "execution_count": null, 1085 | "metadata": {}, 1086 | "outputs": [], 1087 | "source": [] 1088 | }, 1089 | { 1090 | "cell_type": "code", 1091 | "execution_count": null, 1092 | "metadata": {}, 1093 | "outputs": [], 1094 | "source": [] 1095 | } 1096 | ], 1097 | "metadata": { 1098 | "kernelspec": { 1099 | "display_name": "Julia 1.3.1", 1100 | "language": "julia", 1101 | "name": "julia-1.3" 1102 | }, 1103 | "language_info": { 1104 | "file_extension": ".jl", 1105 | "mimetype": "application/julia", 1106 | "name": "julia", 1107 | "version": "1.3.1" 1108 | } 1109 | }, 1110 | "nbformat": 4, 1111 | "nbformat_minor": 2 1112 | } 1113 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/.ipynb_checkpoints/L4DC Data Processing-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 134, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "using LinearAlgebra\n", 10 | "using Statistics\n", 11 | "using DelimitedFiles\n", 12 | "using Plots" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": null, 18 | "metadata": {}, 19 | "outputs": [], 20 | "source": [ 21 | "# Process the data dumped out of \"L4DC Controller Synthesis\".ipynb" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 135, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "Jstars = readdlm(\"Jstars.txt\", '\\t', Float64)\n", 31 | "Jstars[Jstars .>= 10] .= Inf\n", 32 | "\n", 33 | "Jnoms = readdlm(\"Jnoms.txt\", '\\t', Float64)\n", 34 | "Jnoms[Jnoms .>= 10] .= Inf\n", 35 | "\n", 36 | "JrobBs = readdlm(\"JrobBs.txt\", '\\t', Float64)\n", 37 | "JrobBs[JrobBs .>= 10] .= Inf\n", 38 | "\n", 39 | "JrobTs = readdlm(\"JrobTs.txt\", '\\t', Float64)\n", 40 | "JrobTs[JrobTs .>= 10] .= Inf\n", 41 | "\n", 42 | "gammaBs = readdlm(\"gammaBs.txt\", '\\t', Float64)\n", 43 | "\n", 44 | "gammaTs = readdlm(\"gammaTs.txt\", '\\t', Float64)\n", 45 | "\n", 46 | "normxstars = readdlm(\"normxstars.txt\", '\\t', Float64)\n", 47 | "normxstars[normxstars .>= 1000] .= Inf\n", 48 | "normustars = readdlm(\"normustars.txt\", '\\t', Float64)\n", 49 | "normustars[normustars .>= 100] .= Inf\n", 50 | "\n", 51 | "normxnoms = readdlm(\"normxnoms.txt\", '\\t', Float64)\n", 52 | "normxnoms[normxnoms .>= 1000] .= Inf\n", 53 | "normunoms = readdlm(\"normunoms.txt\", '\\t', Float64)\n", 54 | "normunoms[normunoms .>= 100] .= Inf\n", 55 | "\n", 56 | "normxrobBs = readdlm(\"normxrobBs.txt\", '\\t', Float64)\n", 57 | "normxrobBs[normxrobBs .>= 1000] .= Inf\n", 58 | "normurobBs = readdlm(\"normurobBs.txt\", '\\t', Float64)\n", 59 | "normurobBs[normurobBs .>= 100] .= Inf\n", 60 | "\n", 61 | "normxrobTs = readdlm(\"normxrobTs.txt\", '\\t', Float64)\n", 62 | "normxrobTs[normxrobTs .>= 1000] .= Inf\n", 63 | "normurobTs = readdlm(\"normurobTs.txt\", '\\t', Float64)\n", 64 | "normurobTs[normurobTs .>= 100] .= Inf\n", 65 | "\n", 66 | ";" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 136, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "# The particular values of N that were used\n", 76 | "# Should be in intervals of 10^1.0, 10^1.5, ...\n", 77 | "# But the resolution of the \"L4DC Sample Complexity\".ipynb\n", 78 | "# was in units of 10.\n", 79 | "Ns = [10; 30; 100; 316; 1000; 3160; 10000;]\n", 80 | "\n", 81 | "Bmax = length(Ns)\n", 82 | "\n", 83 | "Jstarsmed = median(Jstars, dims=2)\n", 84 | "JstarsQ1 = [quantile(Jstars[b,:], 0.25) for b = 1:Bmax]\n", 85 | "JstarsQ3 = [quantile(Jstars[b,:], 0.75) for b = 1:Bmax]\n", 86 | "\n", 87 | "JrobBsmed = median(JrobBs, dims=2)\n", 88 | "JrobBsQ1 = [quantile(JrobBs[b,:], 0.25) for b = 1:Bmax]\n", 89 | "JrobBsQ3 = [quantile(JrobBs[b,:], 0.75) for b = 1:Bmax]\n", 90 | "\n", 91 | "JrobTsmed = median(JrobTs, dims=2)\n", 92 | "JrobTsQ1 = [quantile(JrobTs[b,:], 0.25) for b = 1:Bmax]\n", 93 | "JrobTsQ3 = [quantile(JrobTs[b,:], 0.75) for b = 1:Bmax]\n", 94 | ";" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 137, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "plot(1:Bmax, Jstarsmed,\n", 104 | " ribbons=(Jstarsmed - JstarsQ1, JstarsQ3 - Jstarsmed),\n", 105 | " fillalpha=0.2,\n", 106 | " xticks=(1:10, [\"1.0\"; \"1.5\"; \"2.0\"; \"2.5\"; \"3.0\"; \"3.5\"; \"4.0\";]),\n", 107 | " ylims=(1.0,3.0),\n", 108 | " label=\"Optimal\",\n", 109 | " xlabel=\"Number of Samples (log10 N)\",\n", 110 | " ylabel=\"LQR Cost\",\n", 111 | " xtickfontsize=18,\n", 112 | " ytickfontsize=18,\n", 113 | " legendfontsize=18,\n", 114 | " xguidefontsize=18,\n", 115 | " yguidefontsize=18,\n", 116 | " )\n", 117 | "plot!(1:Bmax, JrobBsmed,\n", 118 | " ribbons=(JrobBsmed - JrobBsQ1, JrobBsQ3 - JrobBsmed),\n", 119 | " fillalpha=0.2,\n", 120 | " label=\"Boot ε\")\n", 121 | "\n", 122 | "plot!(1:Bmax, JrobTsmed,\n", 123 | " ribbons=(JrobTsmed - JrobTsQ1, JrobTsQ3 - JrobTsmed),\n", 124 | " fillalpha=0.2,\n", 125 | " label=\"True ε\")\n", 126 | "\n", 127 | "savefig(\"lqr-costs.png\")\n" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 138, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "xstarsmed = median(normxstars, dims=2)\n", 144 | "xstarsQ1 = [quantile(normxstars[b,:], 0.25) for b = 1:Bmax]\n", 145 | "xstarsQ3 = [quantile(normxstars[b,:], 0.75) for b = 1:Bmax]\n", 146 | "\n", 147 | "xrobBsmed = median(normxrobBs, dims=2)\n", 148 | "xrobBsQ1 = [quantile(normxrobBs[b,:], 0.25) for b = 1:Bmax]\n", 149 | "xrobBsQ3 = [quantile(normxrobBs[b,:], 0.75) for b = 1:Bmax]\n", 150 | "\n", 151 | "xrobTsmed = median(normxrobTs, dims=2)\n", 152 | "xrobTsQ1 = [quantile(normxrobTs[b,:], 0.25) for b = 1:Bmax]\n", 153 | "xrobTsQ3 = [quantile(normxrobTs[b,:], 0.75) for b = 1:Bmax]\n", 154 | ";" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 139, 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [ 163 | "plot(1:Bmax, xstarsmed,\n", 164 | " ribbons=(xstarsmed - xstarsQ1, xstarsQ3 - xstarsmed),\n", 165 | " fillalpha=0.2,\n", 166 | " ylims=(40,100),\n", 167 | " xticks=(1:10, [\"1.0\"; \"1.5\"; \"2.0\"; \"2.5\"; \"3.0\"; \"3.5\"; \"4.0\";]),\n", 168 | " label=\"Optimal x[0:H-1]\",\n", 169 | " xlabel=\"Number of Samples (log10 N)\",\n", 170 | " ylabel=\"Norm\",\n", 171 | " xtickfontsize=18,\n", 172 | " ytickfontsize=18,\n", 173 | " legendfontsize=18,\n", 174 | " xguidefontsize=18,\n", 175 | " yguidefontsize=18,\n", 176 | ")\n", 177 | "\n", 178 | "plot!(1:Bmax, xrobBsmed,\n", 179 | " ribbons=(xrobBsmed - xrobBsQ1, xrobBsQ3 - xrobBsmed),\n", 180 | " fillalpha=0.2,\n", 181 | " label=\"Boot ε x[0:H-1]\")\n", 182 | "\n", 183 | "plot!(1:Bmax, xrobTsmed,\n", 184 | " ribbons=(xrobTsmed - xrobTsQ1, xrobTsQ3 - xrobTsmed),\n", 185 | " fillalpha=0.2,\n", 186 | " label=\"True ε x[0:H-1]\")\n", 187 | "\n", 188 | "savefig(\"xnorms.png\")" 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": null, 194 | "metadata": {}, 195 | "outputs": [], 196 | "source": [] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 140, 201 | "metadata": {}, 202 | "outputs": [], 203 | "source": [ 204 | "ustarsmed = median(normustars, dims=2)\n", 205 | "ustarsQ1 = [quantile(normustars[b,:], 0.25) for b = 1:Bmax]\n", 206 | "ustarsQ3 = [quantile(normustars[b,:], 0.75) for b = 1:Bmax]\n", 207 | "\n", 208 | "urobBsmed = median(normurobBs, dims=2)\n", 209 | "urobBsQ1 = [quantile(normurobBs[b,:], 0.25) for b = 1:Bmax]\n", 210 | "urobBsQ3 = [quantile(normurobBs[b,:], 0.75) for b = 1:Bmax]\n", 211 | "\n", 212 | "urobTsmed = median(normurobTs, dims=2)\n", 213 | "urobTsQ1 = [quantile(normurobTs[b,:], 0.25) for b = 1:Bmax]\n", 214 | "urobTsQ3 = [quantile(normurobTs[b,:], 0.75) for b = 1:Bmax]\n", 215 | ";" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": 141, 221 | "metadata": {}, 222 | "outputs": [], 223 | "source": [ 224 | "plot(1:Bmax, ustarsmed,\n", 225 | " ribbons=(ustarsmed - ustarsQ1, ustarsQ3 - ustarsmed),\n", 226 | " fillalpha=0.2,\n", 227 | " ylims=(2,10),\n", 228 | " xticks=(1:10, [\"1.0\"; \"1.5\"; \"2.0\"; \"2.5\"; \"3.0\"; \"3.5\"; \"4.0\";]),\n", 229 | " label=\"Optimal u[0:H-1]\",\n", 230 | " xlabel=\"Number of Samples (log10 N)\",\n", 231 | " ylabel=\"Norm\",\n", 232 | " xtickfontsize=18,\n", 233 | " ytickfontsize=18,\n", 234 | " legendfontsize=18,\n", 235 | " xguidefontsize=18,\n", 236 | " yguidefontsize=18,\n", 237 | ")\n", 238 | "\n", 239 | "plot!(1:Bmax, urobBsmed,\n", 240 | " ribbons=(urobBsmed - urobBsQ1, urobBsQ3 - urobBsmed),\n", 241 | " fillalpha=0.2,\n", 242 | " label=\"Boot ε u[0:H-1]\")\n", 243 | "\n", 244 | "plot!(1:Bmax, urobTsmed,\n", 245 | " ribbons=(urobTsmed - urobTsQ1, urobTsQ3 - urobTsmed),\n", 246 | " fillalpha=0.2,\n", 247 | " label=\"True ε u[0:H-1]\")\n", 248 | "\n", 249 | "savefig(\"unorms.png\")" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": null, 255 | "metadata": {}, 256 | "outputs": [], 257 | "source": [] 258 | } 259 | ], 260 | "metadata": { 261 | "kernelspec": { 262 | "display_name": "Julia 1.3.1", 263 | "language": "julia", 264 | "name": "julia-1.3" 265 | }, 266 | "language_info": { 267 | "file_extension": ".jl", 268 | "mimetype": "application/julia", 269 | "name": "julia", 270 | "version": "1.3.1" 271 | } 272 | }, 273 | "nbformat": 4, 274 | "nbformat_minor": 2 275 | } 276 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/.ipynb_checkpoints/L4DC Sample Complexity-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 19, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "using LinearAlgebra\n", 10 | "using Plots\n", 11 | "using Statistics" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 20, 17 | "metadata": {}, 18 | "outputs": [], 19 | "source": [ 20 | "# Generate the Hankel, assuming z is a stacked vector with block dimension d\n", 21 | "function Hankel(z::Array{Float64}, d::Int64, L::Int64)\n", 22 | " N = Int64(round(length(z) / d))\n", 23 | " @assert length(z) == N * d\n", 24 | " z = reshape(z, (d, N))\n", 25 | " H = Matrix{Float64}(zeros(d * L, N - L + 1))\n", 26 | " for i = 1:(N - L + 1); H[:, i] = (z[:, i:(i + L - 1)])[:] end\n", 27 | " return H\n", 28 | "end\n", 29 | ";" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 21, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [ 38 | "# For a particular value of N, calculate the statistics of averaging N different Hw's\n", 39 | "# Generate M (=1000) different norm(Hw) to get the mean, delta, and (1-delta) quantiles\n", 40 | "function sampleTrueN(n::Int64, sigma::Float64, T::Int64, L::Int64, N::Int64, delta::Float64; M=1000)\n", 41 | " norms = zeros(M)\n", 42 | " for m = 1:M\n", 43 | " w = (sigma / sqrt(N)) * randn(n * T)\n", 44 | " Hw = Hankel(w, n, L)\n", 45 | " norms[m] = opnorm(Hw)\n", 46 | " end\n", 47 | " # Mean\n", 48 | " mu = mean(norms)\n", 49 | " \n", 50 | " # delta quantile\n", 51 | " qlonorm = quantile(norms, delta)\n", 52 | " \n", 53 | " # (1-delta) quantile\n", 54 | " qhinorm = quantile(norms, 1 - delta)\n", 55 | " \n", 56 | " return (mu, qlonorm, qhinorm)\n", 57 | "end\n", 58 | "\n", 59 | "\n", 60 | "# For a particular N, calculate the statistics of \n", 61 | "# Run a bootstrap experiment:\n", 62 | "# Over M (=1) iterations, get call sampleTrueN to figure out the bootstrap epsilon\n", 63 | "# The bootstrap epsilon is the (1-delta) quantile of the empirical true H_L (w)\n", 64 | "function sampleBootN(n::Int64, sigma::Float64, T::Int64, L::Int64, N::Int64, delta::Float64; M=1)\n", 65 | " Bs = zeros(M)\n", 66 | " for m = 1:M\n", 67 | " W = sigma * randn((n * T), N)\n", 68 | " (mu, qlo, qhi) = sampleTrueN(n, sigma, T, L, N, delta)\n", 69 | " Bs[m] = qhi\n", 70 | " end\n", 71 | " \n", 72 | " # Mean of boot eps\n", 73 | " muB = mean(Bs)\n", 74 | " \n", 75 | " # delta quantile of boot eps\n", 76 | " qloB = quantile(Bs, delta)\n", 77 | " \n", 78 | " # (1-delta) quantile of boot eps\n", 79 | " qhiB = quantile(Bs, 1 - delta)\n", 80 | " \n", 81 | " return (muB, qloB, qhiB)\n", 82 | "end\n", 83 | "\n", 84 | ";" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 22, 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "name": "stdout", 94 | "output_type": "stream", 95 | "text": [ 96 | "Generating trues\n", 97 | "145.344276 seconds (86.10 M allocations: 68.304 GiB, 3.59% gc time)\n", 98 | "Generating boots\n", 99 | "140.486977 seconds (86.09 M allocations: 78.372 GiB, 4.47% gc time)\n" 100 | ] 101 | } 102 | ], 103 | "source": [ 104 | "# Slightly unstable graph Laplacian is dim n = 3\n", 105 | "n = 3\n", 106 | "sigma = sqrt(0.1)\n", 107 | "\n", 108 | "# Hankel matrix dimensions\n", 109 | "T = 45\n", 110 | "L = 10\n", 111 | "\n", 112 | "# Uncertainty parameter delta\n", 113 | "delta = 0.05\n", 114 | "\n", 115 | "# 10, 20, 30, 40, ..., 10000\n", 116 | "Ns = 10:10:10000\n", 117 | "\n", 118 | "println(\"Generating trues\")\n", 119 | "# About 150 secs\n", 120 | "@time trues = [sampleTrueN(n, sigma, T, L, k, delta) for k in Ns]\n", 121 | "\n", 122 | "println(\"Generating boots\")\n", 123 | "# About 150 secs\n", 124 | "@time boots = [sampleBootN(n, sigma, T, L, k, delta) for k in Ns]\n", 125 | ";" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 23, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [ 134 | "NN = length(Ns)\n", 135 | "# Mean of true ||Hw||\n", 136 | "muTs = [trues[i][1] for i = 1:NN]\n", 137 | "\n", 138 | "# delta quantile of true ||Hw||\n", 139 | "qloTs = [trues[i][2] for i = 1:NN]\n", 140 | "\n", 141 | "# (1-delta) quantile of true ||Hw||\n", 142 | "qhiTs = [trues[i][3] for i = 1:NN]\n", 143 | "\n", 144 | "# Mean of boot eps\n", 145 | "muBs = [boots[i][1] for i = 1:NN]\n", 146 | "\n", 147 | "# We don't actually plot these two\n", 148 | "qloBs = [boots[i][2] for i = 1:NN]\n", 149 | "qhiBs = [boots[i][3] for i = 1:NN]\n", 150 | ";" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 31, 156 | "metadata": {}, 157 | "outputs": [], 158 | "source": [ 159 | "# Plot the true ||Hw|| data, along with ribbons\n", 160 | "plot(Ns, muTs,\n", 161 | " ribbon=(muTs - qloTs, qhiTs - muTs),\n", 162 | " fillalpha=0.1,\n", 163 | " xticks=([10; 31; 100; 316; 1000; 3162; 10000] , [\"1.0\"; \"1.5\"; \"2.0\"; \"2.5\"; \"3.0\"; \"3.5\"; \"4.0\";]),\n", 164 | "# xticks=([2000; 6000; 10000]),\n", 165 | " label=\"true ||H_L (w)||\",\n", 166 | " xlabel=\"Number of Samples (log10 N)\",\n", 167 | " ylabel=\"Operator Norm\",\n", 168 | " xscale=:log10,\n", 169 | " yscale=:log10,\n", 170 | " xtickfontsize=18,\n", 171 | " ytickfontsize=18,\n", 172 | " legendfontsize=18,\n", 173 | " xguidefontsize=18,\n", 174 | " yguidefontsize=18\n", 175 | ")\n", 176 | "\n", 177 | "\n", 178 | "# Plot the solid eps-B line\n", 179 | "plot!(Ns, muBs,\n", 180 | " label=\"ε Boot\"\n", 181 | ")\n", 182 | "\n", 183 | "# Check which directory you booted jupyter notebook from\n", 184 | "savefig(\"Hwnorms.png\")\n" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": {}, 191 | "outputs": [], 192 | "source": [] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 32, 197 | "metadata": {}, 198 | "outputs": [ 199 | { 200 | "data": { 201 | "text/plain": [ 202 | "9-element Array{Float64,1}:\n", 203 | " 3.9082042192458024 \n", 204 | " 2.299229011763075 \n", 205 | " 1.2477926488188928 \n", 206 | " 0.7080045365205088 \n", 207 | " 0.40338514816909393\n", 208 | " 0.22333114401705384\n", 209 | " 0.12494235476552938\n", 210 | " 0.07121620824611384\n", 211 | " 0.03917996646748791" 212 | ] 213 | }, 214 | "execution_count": 32, 215 | "metadata": {}, 216 | "output_type": "execute_result" 217 | } 218 | ], 219 | "source": [ 220 | "# The particular values we will use in the controller synthesis\n", 221 | "[\n", 222 | " sampleBootN(n, sigma, T, L, 1, delta)[1];\n", 223 | " sampleBootN(n, sigma, T, L, 3, delta)[1];\n", 224 | " sampleBootN(n, sigma, T, L, 10, delta)[1];\n", 225 | " sampleBootN(n, sigma, T, L, 31, delta)[1];\n", 226 | " sampleBootN(n, sigma, T, L, 100, delta)[1];\n", 227 | " sampleBootN(n, sigma, T, L, 316, delta)[1];\n", 228 | " sampleBootN(n, sigma, T, L, 1000, delta)[1];\n", 229 | " sampleBootN(n, sigma, T, L, 3162, delta)[1];\n", 230 | " sampleBootN(n, sigma, T, L, 10000, delta)[1];\n", 231 | "]" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": null, 237 | "metadata": {}, 238 | "outputs": [], 239 | "source": [] 240 | } 241 | ], 242 | "metadata": { 243 | "kernelspec": { 244 | "display_name": "Julia 1.3.1", 245 | "language": "julia", 246 | "name": "julia-1.3" 247 | }, 248 | "language_info": { 249 | "file_extension": ".jl", 250 | "mimetype": "application/julia", 251 | "name": "julia", 252 | "version": "1.3.1" 253 | } 254 | }, 255 | "nbformat": 4, 256 | "nbformat_minor": 2 257 | } 258 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/Hwnorms.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2021_L4DC_DataDriven-SLS/experiments/Hwnorms.png -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/Jnoms.txt: -------------------------------------------------------------------------------- 1 | 162105.85679090294 11.651848025835488 1.4878981650026621e7 1.3645416603786298 38406.48065392721 1.6659015955582261e7 2.0902962034685828e6 8368.645647786792 499.01957731313655 139595.40544376886 136.66548299539969 93.22729896778966 81786.46650539913 25024.86098985436 3009.554507579348 1.9067902943322859e6 61110.06454307353 1.5474460473369809e7 32025.352493774182 1.435153095271085e8 143002.6560048781 76399.58591485437 2511.2610840272455 25039.34053672235 5.082955188326029e6 57.272446296143 495448.4784840605 14551.998560297301 8.057584130659983 592.5090703394541 722846.0109358239 1638.5882822446154 8134.483325541511 2.944300617622124e6 2448.0758123702703 2.907350812848196e6 6.944173072164881 14662.999025248417 2.9107031120718165 6.625387023325698e6 10753.36213031709 3260.367169736711 1.5544926014305241e7 1.1098966429259873e6 2.523855561791763e7 10793.863213520808 4298.973497305587 71.68623724564897 90598.64896029785 71.40187022841468 2 | 4.565145043095891e6 233316.98217888916 140.3312599612707 46.87093619037545 7.773930746207234e6 6572.966703441607 3.946357081251215e7 419803.2456090677 2238.9871979846876 12862.986259951402 66.47079825133342 4.352956394624665e6 61404.796014191146 1.4155407355820829e7 16442.69249209707 1.1324504919365522e8 883131.028918237 7.150494752017512 29364.201401324437 774.8411555850829 591.2183387770569 7.160330992676379e6 5922.832944160393 75317.1623969593 9821.534672478549 3434.6784320267193 1.8432295131910949e6 533254.6342409457 290.8683340816425 1833.0523839874884 3.1524981921114482e7 2.8610487860275087 9.453772982833202e7 79.80615020887983 62130.04596027056 3.3666997653729354 26.32936403472273 7.55572433868153e6 552627.4279458217 1.4722887019771818 33.001649313762435 4.889603982996859e6 24306.03332458623 1573.1736788106796 20795.434626656013 32348.8168129075 10706.859443182278 2351.4849768981853 313535.0762459964 19.55885865878823 3 | 405.9530626788286 11450.461266584874 88887.42403652363 1.8432834339183564e6 125104.84147987262 4.579286527485706e6 2.43541664079865e6 116106.05348047942 2.3226730900844936e6 5.460877132853329e6 3.68363634233831e6 2907.2010561360617 1.2038598207073282e7 66566.93892723498 12395.847385744124 51.52847383857899 1.7252604107172138 8.631240187054034e6 56.10814987383504 8142.204788631709 194700.51770753312 5240.381296738087 46.363930159759036 3639.6662356945612 1.5799767338837283e6 13.370712865031505 1.3774873406069713e7 1.3500850432957136e6 446432.3431363523 450190.69757542654 85.21816689140671 2.990663993314634e6 1.350127904422992e7 66229.77681270945 2.463921838168803e6 2679.6607843569336 18.74673669958851 1858.4311191783029 20505.479292126027 7.749349186801703e7 1.58964187032797e7 33901.363203071836 1.3402563581562223 61557.81062683454 257654.87849252814 264250.5409716893 540384.8745370697 1329.2195919669743 820091.3751232062 14678.700191100213 4 | 1.2739497467061159e8 123639.54026939979 10067.437932071653 145453.58847200702 2.6278306493660223e7 856.8478951202901 205.1925145240272 29266.870634092804 315209.0944611802 101801.71466065766 6.467123329669738e6 1.7853440522291082 40971.123967399784 139479.4118314423 8976.422598509544 16416.148604960927 238.06141365752063 463756.9979496293 64262.97604830734 220589.40588946693 346.22632423437756 9.268720111512548e7 2.3786523624688727e6 8.949014967487317e6 52541.92019978293 40474.822543617534 12183.455516961449 1.4758136679154934e7 315232.7776212721 80619.5208143733 59.944093460678864 895064.4583293919 6060.445082348359 89.16972984393492 4822.740571493927 105.95156728716012 1.5003820000017773 1.9421251085200813e7 1926.4678035616207 472819.9915350892 4.881529967818508e6 24.46917651771295 4.0929977173468806e6 2.5289090650534365e7 16988.29714843731 6.69553446524534e7 888239.5564975732 99.40959923653901 68.5710973634221 5.524036148026622e6 5 | 1.6966003444614541 575993.9450320979 346.279668318245 8.408609408040135e7 9.21582928364279e6 2.80473796941123e6 794247.1630074988 49956.203033716665 130.36674928854666 1091.5125598161933 3.1383306959449314e7 1.171883776200357e6 11474.671961521652 13099.375756117908 3.994262947074899 1106.0409337034678 7.17893190270147 631692.5033946561 86.0522916363346 51.5358620013637 74398.33800250205 27.226746335268547 2.711297187862891e6 774313.654365893 24123.63309425847 9.721527465607367e6 196.82169887704123 157041.5316927318 55.90358728604647 221.4157940350317 9445.304719688258 134748.65695693638 731.4706764533348 7920.240325203694 6.155777039235689 2.6607183890613765e6 292226.2508251049 205095.15154703264 663512.7148207073 7.889178548031168e7 2.516729420667076e7 243894.7293756358 29.537361874645452 22502.520761541273 1.7249020861374456e7 1418.6859557468201 112002.68755715054 964815.1930491868 2.8631943102408196e6 2.0900815639139727e7 6 | 8.60192019073068e6 320259.57074548875 41149.82659362937 5278.739366516842 36.7795478931478 972.9908965208493 6163.353005873459 1.262147702285148e6 9.499470652119676e6 619938.5836585695 56974.47918456121 5244.772332293583 1.7824708224144483e6 173112.0680173125 753245.9417804888 79017.4768073184 1.4563935107227275e7 100314.99097873352 5.712611424686148e7 4.741873639005762e6 130.63287955533164 210853.15164739016 4388.105661342808 2.0645798977290953e6 1929.8738561713303 1.743197439246077e7 9.13387488795484e6 1065.2237390696712 847.3831407383418 5.058707657066762e6 279.2922509487344 4.469869049871799e6 526461.3228954248 4.614895663528174e6 356.163860282371 69198.27949017136 2.6253625510959493 188354.22397787514 8.403253783354874e7 3.091287222688576e7 2.544076685692032 3.019192250794613e6 2683.8344597919795 68853.67427306264 121646.26922157689 3.605827845653747 17.747650692989918 12.81226955165036 7.364747636383384e6 182.50578765939505 7 | 4.951017519681722e6 214.5213484901765 163.38769345139752 480402.7863624823 1.3147528599224687e6 75780.11675347555 1877.0729091374178 2.9514861555247035e7 3.313732578635481 18.81788357489617 25517.20797528613 1831.0270907448255 2.4726990694167735e6 9906.801225758523 1.5267060823278287e7 9963.9466697744 2.2367252535935637e7 175649.03896917918 292.6717198790583 2609.9691210935525 4.34752502264177 20110.453192702524 222.4608118050981 852609.4698655559 6.628359884580755e6 437836.42727084656 1266.366506820996 1.503716204983451 191707.242099974 58252.834415759 148033.94688692634 3.0471292746824212e6 1.2675270430918208e8 59.3176340901997 117258.80412808825 63.31398566363472 6.354402159139919e6 16894.98703097883 1.389800301087587e6 709.2518173762692 95.88425473742817 161.0612649322323 35883.95879525736 1562.1740210683129 664304.755044257 89245.19842351184 147943.40111029457 746.9564888342403 63.959575278424055 1.5680601100751034e6 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/JrobBs.txt: -------------------------------------------------------------------------------- 1 | 2.3561513854455876 2.59339843864172 1.848039636991579 1.5420936850250853 1.8641858560422873 2.504215024285719 1.8406399471209256 2.206349496691329 2.2168465708906813 1.8555616819871714 1.6313817169103164 3.1347084056206596 2.2649643937432624 2.0672455382232875 1.786749236860597 2.070237355186043 1.691501629742278 1.8596258335405684 1.5346085395943048 2.0788486024543027 2.6066091067946138 1.7806550608969323 2.6235526588201132 1.780361662492219 2.1361639211123 1.5594162923696673 1.9280015110444286 1.4616349106274418 1.706770671315293 2.480701129039342 2.1547381319780965 2.0875430398829793 1.910079348924235 2.0891697401636415 2.1672938330230034 2.2912825978718394 1.9449428646584335 1.590067694500784 2.2066562254503927 1.9958511890425574 2.606298209146896 2.6200640788601777 1.912239364488587 2.1868465513813136 1.9643693055070945 2.352952043140056 1.8534932710448517 2.2252668603345973 2.4439673611148627 2.015419637338933 2 | 1.6278277599125477 1.8087244170271448 1.5183626953202838 1.8239936051500178 2.0060421928000234 1.592039961282362 2.127165446055021 2.3726647133255256 2.189007903893725 1.8633868566560436 2.311354789520227 2.0530404417609427 2.2368301850291292 2.0946535697062956 2.1090928776751525 2.2464519586305824 1.6959698497794458 2.7008104640922346 1.8556583120291958 2.0459946008489367 1.579435320758385 2.0508794862751976 2.032987277867429 2.2534309726497104 1.768112168589303 1.7404046406658777 1.5789288701605833 2.2580963120610114 1.8145361204561687 1.5334551916522419 2.5719530091648224 2.244353626276631 2.504376536010932 2.597259524507623 1.6332022792293932 2.0109598260516357 2.8300738774555425 1.6482846489234018 1.8531587430119458 1.871238239209627 2.4898647712607964 1.7406014043721412 2.0151252766259695 2.2266484200996417 1.86989599996768 1.3550477054140586 1.7493840581480753 2.4852751071960544 2.339075535359286 2.281739276159676 3 | 1.7608613518588176 2.718118053048238 1.729132692054361 2.0989264804096828 1.4864425096858993 1.954099458830575 1.8859838917808278 1.7545885300801933 2.69600322798695 1.7459999813583071 2.4418106431971673 2.416779483229475 1.7513480656026847 2.31584023624649 2.2782484474508125 1.8917465188594549 2.6164648193234807 2.3599783315896627 1.4738039502461935 2.0778732941286573 2.284747099938965 2.3819675386899513 1.9211648256244507 1.7690971157575361 2.2380089931858222 2.5476921672353625 2.12127155184968 1.9837244367296945 1.658175247503205 1.8581437982261848 1.8294670565565434 1.8354254185750476 1.8224982620517716 1.4691760307164123 1.860034679772149 2.767866234309817 1.6735598817299158 1.7861474275456173 2.2478901989388347 2.512161371855585 2.1460538607621347 1.725660838832705 2.450861620222275 1.773306429923216 1.835474685541092 2.179136486339473 1.9374480097375122 2.266924366190772 1.4658514478700437 3.0717352773922935e12 4 | 1.933190213133211 2.261602719251485 1.956558003675883 2.0879926437187204 2.1075039425822886 1.9447074506118303 1.9397038623285277 2.316494657363158 2.7907093531397233 2.092175964832525 1.7553231504739395 1.878371324011271 1.745352964152962 1.7491266745730893 1.9432030892940197 2.195366991362619 2.2098251336277404 1.9945907635823688 3.017971133990985 1.8495944800667874 2.831692396865918 1.6583089501144286 2.5493223844666053 2.259005358420442 2.3161540678531085 2.5310928017502765 2.064350613361869 1.779561918288508 2.3165229205037883 2.2199533052741187 1.6052405950978097 2.2694656301157394 2.283625210931728 1.853525927996163 2.0381736966649617 1.5111648699725417 1.801092313675741 2.596534850178068 2.5459518228173215 1.7271168911579786 1.7826555356132645 2.277863516484308 1.7141813594925546 1.8364120756639417 2.4037302070888575 2.169153100628414 1.8026755451805347 1.883482144251112 2.081691677837356 1.6448939327781131 5 | 4.4117262729709 1.5728436422874497 2.1836218816875936 2.18474327437862 1.7166034122461062 1.8051199571425491 2.028687643561078 2.240811486357096 2.5313092130573414 2.0511615013919546 1.884574934580254 2.1182140971420615 1.9249746426109702 1.9060165369394004 1.5752875342526176 1.5803050850182356 1.6311796087414472 1.5448051873528292 2.274710303949891 1.8831124287127807 2.083037822342061 3.4620508498793825 2.139399789273584 2.0278983003177213 1.9226739722134176 2.628264318851607 2.984812301911302 1.9968428802239668 1.7616213165785333 1.6824087758108028 2.088414074469173 1.768817335891217 2.0934088796203176 1.9697064005151164 1.5915196641347567 1.711942028956027 1.4908093090392878 2.147957068571974 2.536585245097398 1.4977534466237798 1.7461865793815607 1.8805471113926764 2.2611645536969007 1.7876879730371038 1.6279349935896583 1.724434620211435 1.8744428492502168 1.4647029561621772 1.903745915188085 1.7476559696878022 6 | 1.5332319134224182 2.0386579359837986 1.8661311055481298 2.425037462920369 1.8695147170745743 2.011352698039708 1.6986784486782145 1.50768600915184 1.9329486708785368 2.17919216840548 1.9841163450126529 1.931459627861698 1.7206518309654606 2.2873019947661737 2.073633075419023 2.133390855778789 2.539250507601015 2.3328301688047715 1.936101649905988 1.745463724416704 1.7186434043035717 1.6361331099667447 1.9636126789151864 2.21075660113325 2.2034387845164076 1.9368924761273758 1.6040224083055268 1.8726220196760088 1.6635238872035503 2.148630471268107 2.0685207935695304 1.7421687661760077 1.9984866969585162 1.7405860483850253 1.419517752160369 2.3483919846060135 8.774550771185093e7 1.8387874339342196 2.104861642092523 2.397914954008993 1.5658630756089351 2.154274743362016 1.7012731270928296 1.9055899967245475 1.568041561971306 1.4659702636126444 1.7171520235050988 1.1968494201999704 2.364894419507919 4.364589623915517 7 | 1.4852902938982886 2.123454011163037 1.7324982445118577 1.6097021442768185 1.4665525375667257 2.1572503766312336 1.3530028418312627 2.232909972121315 1.693509905934059 1.994238935524523 1.3789911438885625 1.5110029256680637 1.9847104166882354 1.740092322610366 1.736516360178941 1.7497620090715817 1.5529446953500672 2.1942848600894065 1.7480963695108493 1.9296482126171892 2.2586228428946304 1.7436161339938778 1.793861357195294 1.8671210514597858 1.4048205998862913 1.5619522399886399 2.3061567075971694 1.922840445976744 2.474996354847946 1.6497538324677348 2.1163791411260937 1.5853667192144925 1.7812535193557015 1.5676971773041288 2.2673167821083395 1.765976674170452 1.8028849254372923 2.6714486813495024 1.9706482243180048 1.5534589003235457 1.916495209851092 1.6095318095689275 1.4858936613391847 1.7738910786219468 1.7685958720340262 1.890823002827261 2.643847581330304 1.8496180870602381 1.993254143812105 1.4224611002837715 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/JrobTs.txt: -------------------------------------------------------------------------------- 1 | 2.2752919141644252 2.5202491144144936 1.8193964629512056 1.7273874855396576 1.823096247377651 2.5713820426530716 1.8094339497854737 2.163643672198583 2.1309026117220022 1.8981059576398722 1.6871303767886816 2.9707784097472887 2.086709244356262 2.105790637678156 1.8383175259365654 2.0045793314863314 1.6739929954287422 1.8563418795028406 1.4742872531531743 2.146697226236832 2.598273202744766 1.7077204484579107 2.4394349580071766 1.7214968038222174 2.104472943125261 1.6329368400326816 1.9623584047378113 1.390091034982811 1.629784559959142 2.40528935184611 2.232390169167752 1.8639267604990857 1.8838717958938067 2.019925973109172 2.173735771866522 2.4175459511012662 2.087849991813381 1.5432327606505052 2.205030743647357 2.0822837666469396 2.5401619746994015 2.743046178929967 1.82960040886659 2.2130580150992087 1.7351729945327998 2.258814339504319 2.075558581947257 2.241641951419063 2.459962764553943 1.7460676644952065 2 | 1.6703832401551675 1.9132014077202488 1.5312797204328126 1.8748919418286107 1.8188252956885844 1.5079918146186104 2.0745593026916653 2.3859601080592654 2.338247926280185 2.0112483946428896 2.4578157447422253 2.0977186143449527 2.12991135146259 2.12702125645359 2.306054735096449 2.265535651884982 1.7407216416771973 2.5336264324696844 2.0980023854463856 2.1533684096644667 1.6285536340904045 2.0478938580825345 2.0903376154868694 2.441712017453057 1.9304402032744044 1.6950263350861088 1.7400352513472332 2.2949933376148546 1.8372094793974543 1.5443690770082934 2.986467436693375 2.106028855196758 2.4623778311536166 2.4534376162381544 1.5340924717057682 1.9517153834274714 2.6111355331709256 1.6913676472859422 1.5914201798775751 1.978112709512638 2.3837970723814936 1.9432284414844505 2.0218179224355977 2.3550232186085602 1.8872680128741677 1.572071973064169 1.7706393512691023 2.35848236137604 2.2662995471550285 2.4428589493125816 3 | 1.6255890537081037 2.6539400240397057 1.8075202235829566 2.130094538432348 1.5276424914640636 2.055104636502789 1.842134028202557 1.937681802213909 2.208256248371041 1.8505146971804427 2.337253318675907 2.4038287920802204 1.8050858027145944 2.1938608455306 2.31100491328623 2.0013001676482522 2.707342958947541 2.2326964758178307 1.6287899254486282 2.026498028740601 2.2151074851582035 2.1430603730774602 1.9562145776790578 1.8728054902550846 2.110586498181656 2.5969092368187234 2.112100982187634 2.1270548548477763 1.5879631061844621 1.7800379613628936 1.8187761511749994 1.8892781867980533 1.8958875702265692 1.5309451563585839 1.9368778601174517 2.902699301728337 1.6766720765626066 1.7609502179731795 2.278972713595453 2.616738366450631 2.1525793203192243 1.7947351626878836 2.4414445067748516 1.5776327873927682 1.7112205177739588 2.1455796129434046 1.9399061278608614 2.11566877380933 1.5619874259985098 5.827433674339925e13 4 | 1.9883808109646213 2.348484269049103 2.132158559770376 2.0729545685942017 2.191855541825049 1.9679282655750157 2.1318426825624157 2.19272465116561 2.8124607862692264 2.02406092980867 1.7888899341521824 1.8043149400086897 1.6707272404176114 1.9245721508873173 1.8167507655889608 2.2361318500689125 2.198930669981694 1.7068326043726159 3.209433924210633 1.9301847453590126 2.913429523257481 1.6710656930769696 2.8074490960472973 2.1756025167884836 2.257084529098145 2.1823091895834152 2.047077190467537 1.6631795227571189 2.5544566808122657 1.9576118218272998 1.4850757253601576 2.080707850506626 2.2093347179352327 1.958303121863592 2.1499018307663196 1.6926085061101854 1.8193168289098918 2.551106462957608 2.4301376864586475 1.873792435807543 1.7310166767812736 2.2247297538734077 1.6762613739258423 1.730159692728333 2.2980205489863033 2.1311291269043786 1.8896858808986097 2.033426086688667 2.143645495305027 1.657973579526892 5 | 2.5230204111478476 1.4301831729171455 2.043199740383304 2.0871695364881737 1.745685494121705 1.9089450849122767 1.7907957118357498 2.0999540607097593 2.292141670580916 2.2360720287815252 1.7947738864360305 2.0718374484135307 1.7592031256994032 2.0596650595459263 1.7152526854805612 1.800760069790379 1.6542215613521354 1.9346377072036411 2.216245358707703 1.7411017532450315 1.8768264490888968 2.9664000959669803 2.0138786883932123 1.9009225019027796 1.8870317056399042 2.547653494693477 2.8383673672522787 1.8538682950444485 1.7666476348648767 1.8084263926710542 1.7007544919619342 1.7161577083880777 2.085339022615673 1.718283161752375 1.7484947637922823 1.758086405043285 1.4724529542255635 2.15968669911131 2.654081394015112 1.6531470349949908 1.7376638674942229 1.8927996256865176 1.6850282793406837 1.8394562571267699 1.7349953343821554 1.6777341306401998 1.975282595221093 1.5289579711388057 1.893106548685484 1.7721521823831916 6 | 1.5092033075062758 1.9322033017028224 1.8142519086306654 2.0215604429884384 1.848676272283927 1.6577763499588358 1.719673808967927 1.6751120734499758 1.7865903374133525 2.1748831936414086 2.1725167355899004 2.0152793620704985 2.046498569459325 1.9352930368829024 2.069541428527538 1.944386211971019 2.1370084555601845 2.3958811687693804 1.9810878632880824 1.7072842598723752 1.7708658985905434 1.6505424104903221 2.1722117730586508 2.2612866351453955 2.195167576611372 2.023802441553354 1.5397076893746287 1.7264078902248683 1.6141889466679709 2.5012475998266823 1.771421247268542 1.5736100754794922 1.1200272914342075 2.0186346266967425 1.3444062536344659 2.2743316344701188 370511.872881885 1.7769264012388248 2.1119887584048267 2.328292651186912 1.8076634355658447 2.2013530627119002 1.7689042314557122 1.8349546039082945 1.723359249621311 1.4501753763783933 1.510595036543485 1.1923687371208123 2.1261889130862914 1.8046457062945993 7 | 1.4135498499882475 2.1046621746516467 1.8131847012546103 1.5268814312694103 1.7160981029897446 2.140106707641708 1.3328497317048018 2.0873948102146302 1.6773694542467736 1.8426653045801273 1.6291155548734275 1.7010064889275485 1.0935071713271292 1.6331738290860203 1.9048859751416636 1.6213664256086906 1.5596673500799467 2.076890236718885 2.270927190311244 2.0549140366885648 2.09167556173268 1.5959274660993006 1.565971034499267 2.0827186861769307 1.498818182884011 1.7444336867860422 1.8497485959405773 1.6785570363336462 2.3466618649682407 2.019723312983008 2.09388588053763 1.3599405559765707 1.9320330614418293 1.5109188873848767 1.8085084223622163 1.647488847718023 1.804418570691649 2.185128049875733 1.6038645780438208 1.5814034776745198 1.7622055024910357 1.8852541758593504 1.5627165054281853 1.7393412419466587 1.6134549934797655 1.9335918047261174 2.6301428849294712 1.6328165107437942 1.6870694747697108 1.2175048556619639 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/Jstars.txt: -------------------------------------------------------------------------------- 1 | 1.0949793689045413 1.2499484894433202 1.13208114214587 1.2501667874991724 1.3065320471023119 1.1898348620752526 1.1376694915170233 1.1286249070353958 1.1597567321143434 1.0618994805283368 1.0350115124173194 1.1417438996758071 1.13557662022906 1.2910721951799589 1.0916798028583217 1.2096742756267056 1.2059806593884506 0.8849556802955804 1.2475487549417614 1.1157196633273496 1.200761429960825 1.1282918876817518 1.2410888089729726 1.129218099854841 1.0440957026853652 1.2928429324728068 1.3168051512592 1.270241897351479 1.2257633125083462 1.155109810836463 1.0745919529448853 1.137834810870742 1.3216900049297058 1.2684566674289355 1.2570614912669604 1.096742706709137 1.1703370533721729 1.1648433022789242 1.1303928669910546 1.1039297552465244 1.0282618022849594 1.019460591972444 1.3210229320568951 1.131984917853311 1.1399489170929749 1.2275315624418262 1.1630222674606434 1.1175342649352464 1.124054723154098 1.2348355639342192 2 | 1.3007172820189783 1.1479513832132944 1.2571063789582078 1.2534293120863154 1.2356070840855398 1.206930116254597 1.2801972770283518 1.1884189328503798 1.2302213700665254 1.0499357975159134 1.1306011893803762 1.1498572913093295 1.1460348519941543 1.2239406420593966 1.1163806883975846 1.0925308451853957 1.077796865299211 1.2124695735005273 1.0484825127411044 1.0932951069258399 1.1961480061005298 1.1722932953932281 1.1566187295024841 1.1871612666643323 1.041686404664064 1.1926454526982202 1.2737045822826705 1.1769654111134977 1.1200738053021464 1.2555742077516057 1.1871635808519285 1.1894819107953931 1.0670408854087006 1.118196409825128 1.128377471329409 1.097331265486386 1.2315540612656242 1.1813567497863873 1.1391637341735377 1.2008427883006918 1.2641480730131507 1.3018783798319955 1.1546948972846813 1.1889263008010698 1.2786940603089423 1.1221642893279047 1.1846122857321413 0.9910049595898927 1.2854382744197972 1.2520046519033456 3 | 1.1441471593264843 1.2122221704838556 1.1897865187869894 1.1614139815937439 1.0983980515270775 1.1064211031016427 1.3277001352743292 1.14910364990672 1.3649619459859392 1.279225093434143 1.13223372167625 1.2011491988107592 1.260019131292328 1.1409638037432803 1.095387225471539 1.1178930122416255 1.1457222904986584 1.0391114449926755 1.1105758278103224 1.054467315646913 1.1621614876991808 1.1138715693186068 1.0726507567874808 1.2517846254987868 1.2301423240305174 1.0812649291887286 1.316666667917017 1.1882142074804087 1.039322470884133 0.9686969995533731 1.1711431031204629 1.0735717478440827 1.0778022228078665 1.193695299810529 1.2324740830012604 1.0639873867129985 1.2201203717275544 1.0664794486781282 1.1494729187194068 1.1128420172697482 1.1433189546199736 1.0221985436748513 1.1342259780579473 1.1616270287484411 1.1403860354892867 0.9702276997920205 1.0530716559912148 1.1935735685619047 1.2399433665108464 1.037050497321466 4 | 1.1129084794248532 1.1382789005598812 1.2208659870392413 1.0929466472882359 1.2188633084393605 1.3449509381901292 1.1094266406596132 1.2757926201777918 1.0763267773974012 1.1276700880486816 1.2474253443608365 1.1493895899029911 1.0991965458325628 1.093796114126546 1.1726300519521087 1.2105320048661667 1.1600430434993647 1.0669778082716177 1.1096125671617039 1.2886372448104553 1.2188023691689036 1.1319530764253083 1.0619321267381012 1.2134527620463116 1.1682265316165008 1.074969752714415 1.1610200362360545 1.1111487574835994 1.1592055214477763 1.0603344415530727 1.1909480155690304 1.0917765328063627 1.047856047459359 1.0634984578752211 1.1032221094619188 1.2289164503565915 1.1837292753355362 1.1761000044984895 1.173364887114169 1.1419259004502493 1.1581927519830335 1.229204398149789 1.0510986265655458 1.4927751222630108 1.3239376786021888 1.1354812723378709 1.0538242194312817 1.0525766630029902 1.0815171371789438 1.2161451585433196 5 | 1.1925814675900346 1.1310138703048298 1.097530365586851 1.1869591380720927 1.214755428177744 1.2239991539581547 1.1566152021933591 1.1384655070510181 1.1257684236181913 1.20597220416422 1.0687968408507242 1.125196782120876 1.1105675099067467 1.0885500414749996 1.1406400321338235 1.0851563842024672 1.1633818858817422 1.125409271280612 1.1535521668072297 1.1999108892788735 1.1256655300988403 1.1526124981610548 1.280432604678272 1.155114866000655 1.0361223613907287 1.1598298629856127 1.0132939053879095 1.1979281265035806 1.2326232573506841 1.2822158701427442 1.0587082806398813 1.1890753745532292 1.0797952451492643 1.1160599956223105 1.1439797691767328 1.167704113124091 1.160840301325384 1.18003446069967 1.1606260785382843 0.9993121314345783 1.1776223417579224 1.0103665548680676 1.0746155485021858 1.009781628989583 1.1630372976728327 1.1493884290008773 1.2002582559996282 1.1317659679021017 1.1545034128095637 1.190099055596043 6 | 0.9901399208726097 1.2665552930292447 1.1155781428766312 1.201763264447448 1.0978670192538988 1.1358509379330601 1.0175924598529882 1.2277910371707 1.1936258779906674 1.1014584401122076 1.225504643485004 1.1470049516820384 1.1674539603014307 1.1092683574679825 1.2715940012648361 1.0889477951018405 1.0698682800955162 1.3794348029191923 1.0239753151515365 1.245262521928497 1.1090746248848955 1.0749517131749757 1.1681865357985297 1.2673676395076936 1.2323908702038653 1.1809819380741353 0.986018892613477 1.1488336080909392 1.1237681398908166 1.0394216965551026 1.1556954641027828 1.0349789134659946 1.119502618892694 1.1172762501786089 1.0692478168822974 1.2083350174713763 1.2613433690660387 1.083235178807347 1.0636371871300263 1.0290324249113636 1.3086468592079772 1.253891230984041 1.2232909051061611 1.1892479520168877 1.1874769175445248 1.0639565541197642 1.3607279756784767 1.205500483746213 1.1261676488056163 1.1364785565179933 7 | 1.1179836197037607 1.1657917573452354 1.1856700157731828 1.055460554437646 1.1987980757498773 1.0734913137316038 1.2004632165429487 1.3092339788437923 1.1490820923577398 1.0362171136721614 1.0728946439796991 1.0951481162880274 1.1120874178814881 1.3103789725874104 1.0692749119980252 1.1025464147039754 1.1907224716494877 1.078624362811583 1.1916023331174486 1.3230597865430118 1.1148092184110274 1.1478464180302785 1.041281487488634 1.2198504436421365 1.1874849798440428 0.9792667907301397 1.153860183192072 1.1267814234747908 1.0865887284430824 1.1592130056832872 1.0326572187314338 1.1681939904627456 1.1457055720326357 1.1366939371208344 1.1691468738791178 1.1501479490155413 1.1075340113932333 1.2211544577509694 1.070254838354929 1.28789121702901 1.1262889275606565 1.1480071695927248 1.1099968724073224 1.0865421808026265 1.1053479244743407 1.262594007256323 1.190837300604685 1.094630303434784 1.2571263140094164 1.131378075500951 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/L4DC Data Processing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "using LinearAlgebra\n", 10 | "using Statistics\n", 11 | "using DelimitedFiles\n", 12 | "using Plots" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": {}, 18 | "source": [ 19 | "## Process the data dumped out of `L4DC Controller Synthesis.ipynb`\n", 20 | "\n", 21 | "All of the data matrices are indexed by `[b, m]`,\n", 22 | "where `b = 1, 2, 3, ..., 7` and `m = 1, 2, 3, ..., 50`\n", 23 | "are the different bootstrap index and sample index respectively.\n", 24 | "For instance,\n", 25 | "\n", 26 | "* `Jstars[5, 20]` is the cost of the `20`th independent run of the MPC loop with `N = 1000` under the optimal control scheme\n", 27 | "* `xrobBs[3, 10]` is the `||x[0 : H-1]||` of the `10`th independent run of MPC loop with `N = 100` under the robust bootstrap-epsilon control scheme\n", 28 | "\n", 29 | "\n" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 2, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [ 38 | "Jstars = readdlm(\"Jstars.txt\", '\\t', Float64)\n", 39 | "Jstars[Jstars .>= 10] .= Inf\n", 40 | "\n", 41 | "Jnoms = readdlm(\"Jnoms.txt\", '\\t', Float64)\n", 42 | "Jnoms[Jnoms .>= 10] .= Inf\n", 43 | "\n", 44 | "JrobBs = readdlm(\"JrobBs.txt\", '\\t', Float64)\n", 45 | "JrobBs[JrobBs .>= 10] .= Inf\n", 46 | "\n", 47 | "JrobTs = readdlm(\"JrobTs.txt\", '\\t', Float64)\n", 48 | "JrobTs[JrobTs .>= 10] .= Inf\n", 49 | "\n", 50 | "gammaBs = readdlm(\"gammaBs.txt\", '\\t', Float64)\n", 51 | "\n", 52 | "gammaTs = readdlm(\"gammaTs.txt\", '\\t', Float64)\n", 53 | "\n", 54 | "normxstars = readdlm(\"normxstars.txt\", '\\t', Float64)\n", 55 | "normxstars[normxstars .>= 1000] .= Inf\n", 56 | "normustars = readdlm(\"normustars.txt\", '\\t', Float64)\n", 57 | "normustars[normustars .>= 100] .= Inf\n", 58 | "\n", 59 | "normxnoms = readdlm(\"normxnoms.txt\", '\\t', Float64)\n", 60 | "normxnoms[normxnoms .>= 1000] .= Inf\n", 61 | "normunoms = readdlm(\"normunoms.txt\", '\\t', Float64)\n", 62 | "normunoms[normunoms .>= 100] .= Inf\n", 63 | "\n", 64 | "normxrobBs = readdlm(\"normxrobBs.txt\", '\\t', Float64)\n", 65 | "normxrobBs[normxrobBs .>= 1000] .= Inf\n", 66 | "normurobBs = readdlm(\"normurobBs.txt\", '\\t', Float64)\n", 67 | "normurobBs[normurobBs .>= 100] .= Inf\n", 68 | "\n", 69 | "normxrobTs = readdlm(\"normxrobTs.txt\", '\\t', Float64)\n", 70 | "normxrobTs[normxrobTs .>= 1000] .= Inf\n", 71 | "normurobTs = readdlm(\"normurobTs.txt\", '\\t', Float64)\n", 72 | "normurobTs[normurobTs .>= 100] .= Inf\n", 73 | "\n", 74 | ";" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 3, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "# The particular values of N that were used\n", 84 | "# Should be in intervals of 10^1.0, 10^1.5, ...\n", 85 | "# But the resolution of the \"L4DC Sample Complexity\".ipynb\n", 86 | "# was in units of 10.\n", 87 | "Ns = [10; 30; 100; 316; 1000; 3160; 10000;]\n", 88 | "\n", 89 | "Bmax = length(Ns)\n", 90 | "\n", 91 | "Jstarsmed = median(Jstars, dims=2)\n", 92 | "JstarsQ1 = [quantile(Jstars[b,:], 0.25) for b = 1:Bmax]\n", 93 | "JstarsQ3 = [quantile(Jstars[b,:], 0.75) for b = 1:Bmax]\n", 94 | "\n", 95 | "JrobBsmed = median(JrobBs, dims=2)\n", 96 | "JrobBsQ1 = [quantile(JrobBs[b,:], 0.25) for b = 1:Bmax]\n", 97 | "JrobBsQ3 = [quantile(JrobBs[b,:], 0.75) for b = 1:Bmax]\n", 98 | "\n", 99 | "JrobTsmed = median(JrobTs, dims=2)\n", 100 | "JrobTsQ1 = [quantile(JrobTs[b,:], 0.25) for b = 1:Bmax]\n", 101 | "JrobTsQ3 = [quantile(JrobTs[b,:], 0.75) for b = 1:Bmax]\n", 102 | ";" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 4, 108 | "metadata": {}, 109 | "outputs": [], 110 | "source": [ 111 | "plot(1:Bmax, Jstarsmed,\n", 112 | " ribbons=(Jstarsmed - JstarsQ1, JstarsQ3 - Jstarsmed),\n", 113 | " fillalpha=0.2,\n", 114 | " xticks=(1:10, [\"1.0\"; \"1.5\"; \"2.0\"; \"2.5\"; \"3.0\"; \"3.5\"; \"4.0\";]),\n", 115 | " ylims=(1.0,3.0),\n", 116 | " label=\"Optimal\",\n", 117 | " xlabel=\"Number of Samples (log10 N)\",\n", 118 | " ylabel=\"LQR Cost\",\n", 119 | " xtickfontsize=18,\n", 120 | " ytickfontsize=18,\n", 121 | " legendfontsize=18,\n", 122 | " xguidefontsize=18,\n", 123 | " yguidefontsize=18,\n", 124 | " )\n", 125 | "plot!(1:Bmax, JrobBsmed,\n", 126 | " ribbons=(JrobBsmed - JrobBsQ1, JrobBsQ3 - JrobBsmed),\n", 127 | " fillalpha=0.2,\n", 128 | " label=\"Boot ε\")\n", 129 | "\n", 130 | "plot!(1:Bmax, JrobTsmed,\n", 131 | " ribbons=(JrobTsmed - JrobTsQ1, JrobTsQ3 - JrobTsmed),\n", 132 | " fillalpha=0.2,\n", 133 | " label=\"True ε\")\n", 134 | "\n", 135 | "savefig(\"lqr-costs.png\")\n" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 5, 148 | "metadata": {}, 149 | "outputs": [], 150 | "source": [ 151 | "xstarsmed = median(normxstars, dims=2)\n", 152 | "xstarsQ1 = [quantile(normxstars[b,:], 0.25) for b = 1:Bmax]\n", 153 | "xstarsQ3 = [quantile(normxstars[b,:], 0.75) for b = 1:Bmax]\n", 154 | "\n", 155 | "xrobBsmed = median(normxrobBs, dims=2)\n", 156 | "xrobBsQ1 = [quantile(normxrobBs[b,:], 0.25) for b = 1:Bmax]\n", 157 | "xrobBsQ3 = [quantile(normxrobBs[b,:], 0.75) for b = 1:Bmax]\n", 158 | "\n", 159 | "xrobTsmed = median(normxrobTs, dims=2)\n", 160 | "xrobTsQ1 = [quantile(normxrobTs[b,:], 0.25) for b = 1:Bmax]\n", 161 | "xrobTsQ3 = [quantile(normxrobTs[b,:], 0.75) for b = 1:Bmax]\n", 162 | ";" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 6, 168 | "metadata": {}, 169 | "outputs": [], 170 | "source": [ 171 | "plot(1:Bmax, xstarsmed,\n", 172 | " ribbons=(xstarsmed - xstarsQ1, xstarsQ3 - xstarsmed),\n", 173 | " fillalpha=0.2,\n", 174 | " ylims=(40,100),\n", 175 | " xticks=(1:10, [\"1.0\"; \"1.5\"; \"2.0\"; \"2.5\"; \"3.0\"; \"3.5\"; \"4.0\";]),\n", 176 | " label=\"Optimal x[0:H-1]\",\n", 177 | " xlabel=\"Number of Samples (log10 N)\",\n", 178 | " ylabel=\"Norm\",\n", 179 | " xtickfontsize=18,\n", 180 | " ytickfontsize=18,\n", 181 | " legendfontsize=18,\n", 182 | " xguidefontsize=18,\n", 183 | " yguidefontsize=18,\n", 184 | ")\n", 185 | "\n", 186 | "plot!(1:Bmax, xrobBsmed,\n", 187 | " ribbons=(xrobBsmed - xrobBsQ1, xrobBsQ3 - xrobBsmed),\n", 188 | " fillalpha=0.2,\n", 189 | " label=\"Boot ε x[0:H-1]\")\n", 190 | "\n", 191 | "plot!(1:Bmax, xrobTsmed,\n", 192 | " ribbons=(xrobTsmed - xrobTsQ1, xrobTsQ3 - xrobTsmed),\n", 193 | " fillalpha=0.2,\n", 194 | " label=\"True ε x[0:H-1]\")\n", 195 | "\n", 196 | "savefig(\"xnorms.png\")" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": {}, 203 | "outputs": [], 204 | "source": [] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": 7, 209 | "metadata": {}, 210 | "outputs": [], 211 | "source": [ 212 | "ustarsmed = median(normustars, dims=2)\n", 213 | "ustarsQ1 = [quantile(normustars[b,:], 0.25) for b = 1:Bmax]\n", 214 | "ustarsQ3 = [quantile(normustars[b,:], 0.75) for b = 1:Bmax]\n", 215 | "\n", 216 | "urobBsmed = median(normurobBs, dims=2)\n", 217 | "urobBsQ1 = [quantile(normurobBs[b,:], 0.25) for b = 1:Bmax]\n", 218 | "urobBsQ3 = [quantile(normurobBs[b,:], 0.75) for b = 1:Bmax]\n", 219 | "\n", 220 | "urobTsmed = median(normurobTs, dims=2)\n", 221 | "urobTsQ1 = [quantile(normurobTs[b,:], 0.25) for b = 1:Bmax]\n", 222 | "urobTsQ3 = [quantile(normurobTs[b,:], 0.75) for b = 1:Bmax]\n", 223 | ";" 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": 8, 229 | "metadata": {}, 230 | "outputs": [], 231 | "source": [ 232 | "plot(1:Bmax, ustarsmed,\n", 233 | " ribbons=(ustarsmed - ustarsQ1, ustarsQ3 - ustarsmed),\n", 234 | " fillalpha=0.2,\n", 235 | " ylims=(2,10),\n", 236 | " xticks=(1:10, [\"1.0\"; \"1.5\"; \"2.0\"; \"2.5\"; \"3.0\"; \"3.5\"; \"4.0\";]),\n", 237 | " label=\"Optimal u[0:H-1]\",\n", 238 | " xlabel=\"Number of Samples (log10 N)\",\n", 239 | " ylabel=\"Norm\",\n", 240 | " xtickfontsize=18,\n", 241 | " ytickfontsize=18,\n", 242 | " legendfontsize=18,\n", 243 | " xguidefontsize=18,\n", 244 | " yguidefontsize=18,\n", 245 | ")\n", 246 | "\n", 247 | "plot!(1:Bmax, urobBsmed,\n", 248 | " ribbons=(urobBsmed - urobBsQ1, urobBsQ3 - urobBsmed),\n", 249 | " fillalpha=0.2,\n", 250 | " label=\"Boot ε u[0:H-1]\")\n", 251 | "\n", 252 | "plot!(1:Bmax, urobTsmed,\n", 253 | " ribbons=(urobTsmed - urobTsQ1, urobTsQ3 - urobTsmed),\n", 254 | " fillalpha=0.2,\n", 255 | " label=\"True ε u[0:H-1]\")\n", 256 | "\n", 257 | "savefig(\"unorms.png\")" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": null, 263 | "metadata": {}, 264 | "outputs": [], 265 | "source": [] 266 | } 267 | ], 268 | "metadata": { 269 | "kernelspec": { 270 | "display_name": "Julia 1.3.1", 271 | "language": "julia", 272 | "name": "julia-1.3" 273 | }, 274 | "language_info": { 275 | "file_extension": ".jl", 276 | "mimetype": "application/julia", 277 | "name": "julia", 278 | "version": "1.3.1" 279 | } 280 | }, 281 | "nbformat": 4, 282 | "nbformat_minor": 2 283 | } 284 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/L4DC Sample Complexity.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 19, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "using LinearAlgebra\n", 10 | "using Plots\n", 11 | "using Statistics" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 20, 17 | "metadata": {}, 18 | "outputs": [], 19 | "source": [ 20 | "# Generate the Hankel, assuming z is a stacked vector with block dimension d\n", 21 | "function Hankel(z::Array{Float64}, d::Int64, L::Int64)\n", 22 | " N = Int64(round(length(z) / d))\n", 23 | " @assert length(z) == N * d\n", 24 | " z = reshape(z, (d, N))\n", 25 | " H = Matrix{Float64}(zeros(d * L, N - L + 1))\n", 26 | " for i = 1:(N - L + 1); H[:, i] = (z[:, i:(i + L - 1)])[:] end\n", 27 | " return H\n", 28 | "end\n", 29 | ";" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 21, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [ 38 | "# For a particular value of N, calculate the statistics of averaging N different Hw's\n", 39 | "# Generate M (=1000) different norm(Hw) to get the mean, delta, and (1-delta) quantiles\n", 40 | "function sampleTrueN(n::Int64, sigma::Float64, T::Int64, L::Int64, N::Int64, delta::Float64; M=1000)\n", 41 | " norms = zeros(M)\n", 42 | " for m = 1:M\n", 43 | " w = (sigma / sqrt(N)) * randn(n * T)\n", 44 | " Hw = Hankel(w, n, L)\n", 45 | " norms[m] = opnorm(Hw)\n", 46 | " end\n", 47 | " # Mean\n", 48 | " mu = mean(norms)\n", 49 | " \n", 50 | " # delta quantile\n", 51 | " qlonorm = quantile(norms, delta)\n", 52 | " \n", 53 | " # (1-delta) quantile\n", 54 | " qhinorm = quantile(norms, 1 - delta)\n", 55 | " \n", 56 | " return (mu, qlonorm, qhinorm)\n", 57 | "end\n", 58 | "\n", 59 | "\n", 60 | "# For a particular N, calculate the statistics of \n", 61 | "# Run a bootstrap experiment:\n", 62 | "# Over M (=1) iterations, get call sampleTrueN to figure out the bootstrap epsilon\n", 63 | "# The bootstrap epsilon is the (1-delta) quantile of the empirical true H_L (w)\n", 64 | "function sampleBootN(n::Int64, sigma::Float64, T::Int64, L::Int64, N::Int64, delta::Float64; M=1)\n", 65 | " Bs = zeros(M)\n", 66 | " for m = 1:M\n", 67 | " W = sigma * randn((n * T), N)\n", 68 | " (mu, qlo, qhi) = sampleTrueN(n, sigma, T, L, N, delta)\n", 69 | " Bs[m] = qhi\n", 70 | " end\n", 71 | " \n", 72 | " # Mean of boot eps\n", 73 | " muB = mean(Bs)\n", 74 | " \n", 75 | " # delta quantile of boot eps\n", 76 | " qloB = quantile(Bs, delta)\n", 77 | " \n", 78 | " # (1-delta) quantile of boot eps\n", 79 | " qhiB = quantile(Bs, 1 - delta)\n", 80 | " \n", 81 | " return (muB, qloB, qhiB)\n", 82 | "end\n", 83 | "\n", 84 | ";" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 22, 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "name": "stdout", 94 | "output_type": "stream", 95 | "text": [ 96 | "Generating trues\n", 97 | "145.344276 seconds (86.10 M allocations: 68.304 GiB, 3.59% gc time)\n", 98 | "Generating boots\n", 99 | "140.486977 seconds (86.09 M allocations: 78.372 GiB, 4.47% gc time)\n" 100 | ] 101 | } 102 | ], 103 | "source": [ 104 | "# Slightly unstable graph Laplacian is dim n = 3\n", 105 | "n = 3\n", 106 | "sigma = sqrt(0.1)\n", 107 | "\n", 108 | "# Hankel matrix dimensions\n", 109 | "T = 45\n", 110 | "L = 10\n", 111 | "\n", 112 | "# Uncertainty parameter delta\n", 113 | "delta = 0.05\n", 114 | "\n", 115 | "# 10, 20, 30, 40, ..., 10000\n", 116 | "Ns = 10:10:10000\n", 117 | "\n", 118 | "println(\"Generating trues\")\n", 119 | "# About 150 secs\n", 120 | "@time trues = [sampleTrueN(n, sigma, T, L, k, delta) for k in Ns]\n", 121 | "\n", 122 | "println(\"Generating boots\")\n", 123 | "# About 150 secs\n", 124 | "@time boots = [sampleBootN(n, sigma, T, L, k, delta) for k in Ns]\n", 125 | ";" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 23, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [ 134 | "NN = length(Ns)\n", 135 | "# Mean of true ||Hw||\n", 136 | "muTs = [trues[i][1] for i = 1:NN]\n", 137 | "\n", 138 | "# delta quantile of true ||Hw||\n", 139 | "qloTs = [trues[i][2] for i = 1:NN]\n", 140 | "\n", 141 | "# (1-delta) quantile of true ||Hw||\n", 142 | "qhiTs = [trues[i][3] for i = 1:NN]\n", 143 | "\n", 144 | "# Mean of boot eps\n", 145 | "muBs = [boots[i][1] for i = 1:NN]\n", 146 | "\n", 147 | "# We don't actually plot these two\n", 148 | "qloBs = [boots[i][2] for i = 1:NN]\n", 149 | "qhiBs = [boots[i][3] for i = 1:NN]\n", 150 | ";" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 31, 156 | "metadata": {}, 157 | "outputs": [], 158 | "source": [ 159 | "# Plot the true ||Hw|| data, along with ribbons\n", 160 | "plot(Ns, muTs,\n", 161 | " ribbon=(muTs - qloTs, qhiTs - muTs),\n", 162 | " fillalpha=0.1,\n", 163 | " xticks=([10; 31; 100; 316; 1000; 3162; 10000] , [\"1.0\"; \"1.5\"; \"2.0\"; \"2.5\"; \"3.0\"; \"3.5\"; \"4.0\";]),\n", 164 | "# xticks=([2000; 6000; 10000]),\n", 165 | " label=\"true ||H_L (w)||\",\n", 166 | " xlabel=\"Number of Samples (log10 N)\",\n", 167 | " ylabel=\"Operator Norm\",\n", 168 | " xscale=:log10,\n", 169 | " yscale=:log10,\n", 170 | " xtickfontsize=18,\n", 171 | " ytickfontsize=18,\n", 172 | " legendfontsize=18,\n", 173 | " xguidefontsize=18,\n", 174 | " yguidefontsize=18\n", 175 | ")\n", 176 | "\n", 177 | "\n", 178 | "# Plot the solid eps-B line\n", 179 | "plot!(Ns, muBs,\n", 180 | " label=\"ε Boot\"\n", 181 | ")\n", 182 | "\n", 183 | "# Check which directory you booted jupyter notebook from\n", 184 | "savefig(\"Hwnorms.png\")\n" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": {}, 191 | "outputs": [], 192 | "source": [] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 32, 197 | "metadata": {}, 198 | "outputs": [ 199 | { 200 | "data": { 201 | "text/plain": [ 202 | "9-element Array{Float64,1}:\n", 203 | " 3.9082042192458024 \n", 204 | " 2.299229011763075 \n", 205 | " 1.2477926488188928 \n", 206 | " 0.7080045365205088 \n", 207 | " 0.40338514816909393\n", 208 | " 0.22333114401705384\n", 209 | " 0.12494235476552938\n", 210 | " 0.07121620824611384\n", 211 | " 0.03917996646748791" 212 | ] 213 | }, 214 | "execution_count": 32, 215 | "metadata": {}, 216 | "output_type": "execute_result" 217 | } 218 | ], 219 | "source": [ 220 | "# The particular values we will use in the controller synthesis\n", 221 | "[\n", 222 | " sampleBootN(n, sigma, T, L, 1, delta)[1];\n", 223 | " sampleBootN(n, sigma, T, L, 3, delta)[1];\n", 224 | " sampleBootN(n, sigma, T, L, 10, delta)[1];\n", 225 | " sampleBootN(n, sigma, T, L, 31, delta)[1];\n", 226 | " sampleBootN(n, sigma, T, L, 100, delta)[1];\n", 227 | " sampleBootN(n, sigma, T, L, 316, delta)[1];\n", 228 | " sampleBootN(n, sigma, T, L, 1000, delta)[1];\n", 229 | " sampleBootN(n, sigma, T, L, 3162, delta)[1];\n", 230 | " sampleBootN(n, sigma, T, L, 10000, delta)[1];\n", 231 | "]" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": null, 237 | "metadata": {}, 238 | "outputs": [], 239 | "source": [] 240 | } 241 | ], 242 | "metadata": { 243 | "kernelspec": { 244 | "display_name": "Julia 1.3.1", 245 | "language": "julia", 246 | "name": "julia-1.3" 247 | }, 248 | "language_info": { 249 | "file_extension": ".jl", 250 | "mimetype": "application/julia", 251 | "name": "julia", 252 | "version": "1.3.1" 253 | } 254 | }, 255 | "nbformat": 4, 256 | "nbformat_minor": 2 257 | } 258 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/README.md: -------------------------------------------------------------------------------- 1 | # L4DC 2021 Experiments 2 | This directory contains the files necessary to reproduce our L4DC 2021 experiments. 3 | 4 | ## Dependencies 5 | These experiments were run with the following software 6 | * Julia (>= 1.3.1) 7 | * Jupyter Notebook (>= 5.7.10) 8 | * MOSEK (>= 9.29) 9 | 10 | Missing Julia packages can be installed as follows: 11 | 1. Run `julia` from the terminal to launch the interactive environment 12 | 2. `using Pkg` imports Julia's built-in package manager 13 | 3. `Pkg.add("Statistics")` will install Julia's [Statistics](https://docs.julialang.org/en/v1/stdlib/Statistics/) package, for example 14 | 15 | 16 | ## Experiment 1: Bootstrapping 17 | This experiment is contained in the `L4DC Sample Complexity.ipynb` file. This file contains code that 18 | 1. Generates `N = 10, 20, 30, ...,10000` independent `H_L (w)` matrices and computes their average 19 | 2. Calculates their norm (`opnorm`) 20 | 3. Stores and plots data 21 | 22 | Running all of the code blocks (not including time to import and pre-compile packages) takes around 300 seconds, depending on the machine. A pre-computed image is stored in `Hwnorms.png`. 23 | 24 | ![Hwnorms.png](Hwnorms.png) 25 | 26 | The x-axis displays different values of `N` in `log10` scale. The solid blue line is the `opnorm` of `N` independent `H_L (w)` averaged together, with the `0.05` and `0.95` quantiles shaded. The bootstrap epsilon is the `0.95` quantile, sampled independent from the blue data and drawn in orange. 27 | 28 | 29 | 30 | ## Experiment 2: MPC Loop 31 | The code for this is split into two files: 32 | * `L4DC Controller Synthesis.ipynb` which runs the MPC experiments 33 | * `L4DC Data Processing.ipynb` which plots data from the experiments. This file is rather straightforward, so we focus on the controller synthesis part. 34 | 35 | The `L4DC Controller Synthesis.ipynb` file defines 36 | * Data structures for the LTI system, as in the paper 37 | * Data structures for the LQR cost function 38 | * An optimization routine call to `MOSEK` in order to synthesize the `G` matrix 39 | * Sanity checks to ensure that system constraints hold 40 | * MPC loop with different control schemes (optimal, naive, robust bootstrap-epsilon, robust true-epsilon) 41 | 42 | The following are saved from running the MPC loop experiment: 43 | * `Jstars.txt` contains the optimal controller cost data 44 | * `Jnoms.txt` contains the nominal controller cost data 45 | * `JrobBs.txt` contains the robust boostrap-epsilon controller cost data 46 | * `JrobTs.txt` contains the robust true-epsilon controller cost data 47 | 48 | Following this naming convention, 49 | * `normx*.txt` contains the `||x[0:H-1]||` data for its respective controller 50 | * `normu*.txt` contains the `||u[0:H-1]||` data for its respective controller 51 | 52 | Pre-computed plots are available in `lqr-costs.png`, `xnorms.png`, and `unorms.png`. 53 | 54 | _!!!WARNING: The MPC experiment is expected to take 350-700 minutes, dependent on machine!!!_ 55 | 56 | ### LQR Cost 57 | Shown below are the LQR costs of the optimal, robust bootstrap epsilon, and robust true epsilon controllers in an MPC loop over control horizon `H = 1000` (with `Q = 1e-3 I` , `R = I`, and `sigma = sqrt(0.1)`) for different sample counts `N`. The 1st and 3rd quartiles are shaded for each. The naive (nominal) controller is omitted because it consistently blows up due to instability. 58 | 59 | ![lqr-costs.png](lqr-costs.png) 60 | 61 | 62 | ### State and input norms 63 | Shown below are the norms of the states and controls of the system over the MPC loop over different number of samples `N`. Again, we omit the naive controller as it is consistently unstable. 64 | 65 | ![xnorms.png](xnorms.png) 66 | 67 | ![unorms.png](unorms.png) 68 | 69 | 70 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/gammaBs.txt: -------------------------------------------------------------------------------- 1 | 0.71093328125 0.7890567187499999 0.50781234375 0.44531359375 0.5859357812500001 0.63280984375 0.63280984375 0.77343203125 0.6953085937499999 0.41406421875000005 0.42968890625 0.67968390625 0.32031609375 0.67968390625 0.57031109375 0.57031109375 0.47656296875 0.44531359375 0.47656296875 0.53906171875 0.85155546875 0.5234370312500001 0.5546864062500001 0.77343203125 0.6640592187499998 0.57031109375 0.57031109375 0.30469140624999996 0.46093828124999997 0.5234370312500001 0.50781234375 0.5546864062500001 0.5546864062500001 0.57031109375 0.53906171875 0.77343203125 0.6953085937499999 0.49218765625 0.5234370312500001 0.6640592187499998 0.7265579687499999 0.8046814062500001 0.64843453125 0.63280984375 0.50781234375 0.5234370312500001 0.57031109375 0.7265579687499999 0.5234370312500001 0.5546864062500001 2 | 0.32031609375 0.24219265624999997 0.25781734375 0.25781734375 0.33594078125 0.19531859375 0.39843953125000003 0.39843953125000003 0.24219265624999997 0.21094328125 0.44531359375 0.28906671874999995 0.35156546875 0.35156546875 0.33594078125 0.39843953125000003 0.39843953125000003 0.30469140624999996 0.25781734375 0.35156546875 0.22656796874999996 0.33594078125 0.33594078125 0.46093828124999997 0.24219265624999997 0.30469140624999996 0.27344203124999994 0.49218765625 0.28906671874999995 0.30469140624999996 0.30469140624999996 0.35156546875 0.42968890625 0.50781234375 0.25781734375 0.27344203124999994 0.38281484375 0.27344203124999994 0.28906671874999995 0.35156546875 0.36719015625 0.35156546875 0.27344203124999994 0.35156546875 0.25781734375 0.30469140624999996 0.28906671874999995 0.35156546875 0.50781234375 0.38281484375 3 | 0.11719515624999999 0.22656796874999996 0.14844453125 0.14844453125 0.13281984375 0.17969390624999998 0.19531859375 0.17969390624999998 0.16406921874999997 0.14844453125 0.32031609375 0.19531859375 0.17969390624999998 0.19531859375 0.24219265624999997 0.21094328125 0.27344203124999994 0.17969390624999998 0.19531859375 0.19531859375 0.25781734375 0.14844453125 0.19531859375 0.16406921874999997 0.25781734375 0.19531859375 0.13281984375 0.14844453125 0.17969390624999998 0.14844453125 0.17969390624999998 0.19531859375 0.17969390624999998 0.14844453125 0.14844453125 0.35156546875 0.14844453125 0.19531859375 0.19531859375 0.25781734375 0.24219265624999997 0.17969390624999998 0.28906671874999995 0.17969390624999998 0.14844453125 0.16406921874999997 0.17969390624999998 0.21094328125 0.14844453125 0.17969390624999998 4 | 0.14844453125 0.11719515624999999 0.07032109375000001 0.14844453125 0.11719515624999999 0.16406921874999997 0.10157046875 0.10157046875 0.13281984375 0.14844453125 0.08594578124999999 0.11719515624999999 0.07032109375000001 0.10157046875 0.10157046875 0.14844453125 0.16406921874999997 0.07032109375000001 0.19531859375 0.11719515624999999 0.13281984375 0.07032109375000001 0.10157046875 0.14844453125 0.16406921874999997 0.10157046875 0.11719515624999999 0.10157046875 0.16406921874999997 0.10157046875 0.08594578124999999 0.10157046875 0.10157046875 0.13281984375 0.10157046875 0.08594578124999999 0.11719515624999999 0.17969390624999998 0.14844453125 0.10157046875 0.08594578124999999 0.13281984375 0.07032109375000001 0.08594578124999999 0.13281984375 0.13281984375 0.10157046875 0.11719515624999999 0.11719515624999999 0.11719515624999999 5 | 0.05469640625 0.07032109375000001 0.05469640625 0.05469640625 0.05469640625 0.05469640625 0.07032109375000001 0.05469640625 0.07032109375000001 0.05469640625 0.03907171875 0.05469640625 0.08594578124999999 0.07032109375000001 0.05469640625 0.05469640625 0.05469640625 0.05469640625 0.05469640625 0.07032109375000001 0.07032109375000001 0.05469640625 0.03907171875 0.07032109375000001 0.07032109375000001 0.10157046875 0.10157046875 0.05469640625 0.07032109375000001 0.07032109375000001 0.05469640625 0.07032109375000001 0.05469640625 0.05469640625 0.05469640625 0.05469640625 0.05469640625 0.07032109375000001 0.08594578124999999 0.05469640625 0.05469640625 0.05469640625 0.03907171875 0.05469640625 0.07032109375000001 0.05469640625 0.08594578124999999 0.05469640625 0.05469640625 0.03907171875 6 | 0.02344703125 0.03907171875 0.03907171875 0.03907171875 0.05469640625 0.02344703125 0.03907171875 0.02344703125 0.03907171875 0.03907171875 0.03907171875 0.02344703125 0.03907171875 0.02344703125 0.03907171875 0.03907171875 0.03907171875 0.03907171875 0.03907171875 0.03907171875 0.03907171875 0.03907171875 0.02344703125 0.03907171875 0.03907171875 0.02344703125 0.03907171875 0.03907171875 0.03907171875 0.03907171875 0.02344703125 0.02344703125 0.03907171875 0.03907171875 0.02344703125 0.03907171875 0.03907171875 0.03907171875 0.03907171875 0.05469640625 0.02344703125 0.03907171875 0.02344703125 0.03907171875 0.03907171875 0.02344703125 0.02344703125 0.03907171875 0.05469640625 0.03907171875 7 | 0.00782234375 0.02344703125 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.00782234375 0.02344703125 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.00782234375 0.00782234375 0.02344703125 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.00782234375 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/gammaTs.txt: -------------------------------------------------------------------------------- 1 | 0.5546864062500001 0.6640592187499998 0.41406421875000005 0.38281484375 0.42968890625 0.42968890625 0.5546864062500001 0.67968390625 0.57031109375 0.33594078125 0.36719015625 0.49218765625 0.32031609375 0.5234370312500001 0.46093828124999997 0.60156046875 0.42968890625 0.41406421875000005 0.39843953125000003 0.44531359375 0.6953085937499999 0.42968890625 0.41406421875000005 0.74218265625 0.53906171875 0.5234370312500001 0.46093828124999997 0.32031609375 0.35156546875 0.47656296875 0.38281484375 0.57031109375 0.46093828124999997 0.38281484375 0.46093828124999997 0.6640592187499998 0.6171851562499999 0.44531359375 0.42968890625 0.5234370312500001 0.71093328125 0.6640592187499998 0.6171851562499999 0.50781234375 0.47656296875 0.38281484375 0.42968890625 0.63280984375 0.41406421875000005 0.44531359375 2 | 0.28906671874999995 0.21094328125 0.21094328125 0.21094328125 0.24219265624999997 0.14844453125 0.28906671874999995 0.33594078125 0.19531859375 0.16406921874999997 0.39843953125000003 0.25781734375 0.33594078125 0.35156546875 0.30469140624999996 0.32031609375 0.33594078125 0.27344203124999994 0.21094328125 0.30469140624999996 0.17969390624999998 0.25781734375 0.25781734375 0.36719015625 0.21094328125 0.28906671874999995 0.22656796874999996 0.39843953125000003 0.24219265624999997 0.27344203124999994 0.25781734375 0.32031609375 0.36719015625 0.41406421875000005 0.21094328125 0.22656796874999996 0.28906671874999995 0.21094328125 0.24219265624999997 0.22656796874999996 0.28906671874999995 0.30469140624999996 0.22656796874999996 0.32031609375 0.21094328125 0.24219265624999997 0.24219265624999997 0.27344203124999994 0.41406421875000005 0.27344203124999994 3 | 0.10157046875 0.17969390624999998 0.13281984375 0.11719515624999999 0.11719515624999999 0.16406921874999997 0.14844453125 0.16406921874999997 0.13281984375 0.14844453125 0.28906671874999995 0.17969390624999998 0.14844453125 0.13281984375 0.21094328125 0.21094328125 0.24219265624999997 0.14844453125 0.17969390624999998 0.16406921874999997 0.22656796874999996 0.13281984375 0.16406921874999997 0.14844453125 0.22656796874999996 0.14844453125 0.10157046875 0.11719515624999999 0.17969390624999998 0.16406921874999997 0.13281984375 0.17969390624999998 0.14844453125 0.11719515624999999 0.13281984375 0.30469140624999996 0.11719515624999999 0.16406921874999997 0.16406921874999997 0.21094328125 0.16406921874999997 0.16406921874999997 0.24219265624999997 0.16406921874999997 0.11719515624999999 0.13281984375 0.14844453125 0.17969390624999998 0.10157046875 0.19531859375 4 | 0.11719515624999999 0.10157046875 0.07032109375000001 0.13281984375 0.10157046875 0.13281984375 0.08594578124999999 0.07032109375000001 0.11719515624999999 0.13281984375 0.07032109375000001 0.11719515624999999 0.05469640625 0.07032109375000001 0.08594578124999999 0.10157046875 0.13281984375 0.07032109375000001 0.17969390624999998 0.10157046875 0.11719515624999999 0.05469640625 0.08594578124999999 0.13281984375 0.14844453125 0.08594578124999999 0.10157046875 0.08594578124999999 0.13281984375 0.08594578124999999 0.07032109375000001 0.08594578124999999 0.08594578124999999 0.13281984375 0.08594578124999999 0.07032109375000001 0.10157046875 0.14844453125 0.14844453125 0.10157046875 0.07032109375000001 0.11719515624999999 0.07032109375000001 0.07032109375000001 0.11719515624999999 0.11719515624999999 0.07032109375000001 0.11719515624999999 0.08594578124999999 0.08594578124999999 5 | 0.05469640625 0.05469640625 0.03907171875 0.05469640625 0.03907171875 0.05469640625 0.05469640625 0.05469640625 0.05469640625 0.05469640625 0.03907171875 0.05469640625 0.07032109375000001 0.07032109375000001 0.03907171875 0.03907171875 0.03907171875 0.03907171875 0.05469640625 0.05469640625 0.05469640625 0.05469640625 0.03907171875 0.07032109375000001 0.05469640625 0.08594578124999999 0.07032109375000001 0.03907171875 0.07032109375000001 0.05469640625 0.05469640625 0.07032109375000001 0.03907171875 0.05469640625 0.03907171875 0.03907171875 0.03907171875 0.07032109375000001 0.08594578124999999 0.03907171875 0.05469640625 0.03907171875 0.03907171875 0.05469640625 0.05469640625 0.05469640625 0.08594578124999999 0.03907171875 0.05469640625 0.03907171875 6 | 0.02344703125 0.02344703125 0.03907171875 0.03907171875 0.03907171875 0.02344703125 0.02344703125 0.02344703125 0.03907171875 0.02344703125 0.03907171875 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.03907171875 0.03907171875 0.02344703125 0.03907171875 0.05469640625 0.02344703125 0.02344703125 0.03907171875 0.03907171875 0.02344703125 0.03907171875 0.03907171875 0.02344703125 0.03907171875 0.02344703125 0.02344703125 0.9296789062500002 0.02344703125 0.02344703125 0.03907171875 0.02344703125 0.02344703125 0.02344703125 0.05469640625 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.05469640625 0.03907171875 7 | 0.00782234375 0.02344703125 0.02344703125 0.00782234375 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.00782234375 0.5234370312500001 0.02344703125 0.00782234375 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.00782234375 0.00782234375 0.00782234375 0.00782234375 0.00782234375 0.02344703125 0.00782234375 0.00782234375 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.00782234375 0.00782234375 0.02344703125 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.02344703125 0.02344703125 0.02344703125 0.02344703125 0.00782234375 0.00782234375 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/lqr-costs.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2021_L4DC_DataDriven-SLS/experiments/lqr-costs.png -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/normunoms.txt: -------------------------------------------------------------------------------- 1 | 140123.46214801943 16.506362913941594 6.911143951141015e6 2.730653772165136 34200.205232605374 9.31888963972422e6 1.5331960030202672e6 8252.309525842158 389.2658787755132 131328.48372267882 178.0252731825613 67.9737060608321 72928.40181806221 24800.371225496772 3688.154134443504 1.1956301853117596e6 54738.73540351926 8.609873766586069e6 33090.044807111444 5.482608795885204e7 122706.10527381829 83031.89436026591 2753.475571373582 26750.934896031355 3.5761176786089265e6 78.48175359628124 428009.7159532673 14319.196312003705 11.82723171868264 205.2435301639134 586992.6184999119 2069.1036624607827 10037.931174053021 2.187567512171636e6 2282.6963874092407 1.7612552047340057e6 7.189943038246353 15974.188100982476 3.7944301302812993 3.6855689728425127e6 11229.941002924355 3084.117549722493 8.427566644065727e6 826954.2047524101 1.231984786826261e7 13093.919352206422 5127.696517760348 65.41740968687972 98845.51459340399 63.4003538563673 2 | 2.9135040687834844e6 215069.95561581725 60.51445650418607 64.29160201059689 4.942971520192612e6 7004.587955320886 1.4277857464365887e7 366202.5651680725 1524.1686097330853 13885.085246834473 67.06921686643088 2.6873113840319384e6 69676.93586272628 8.368829362792331e6 12976.858783357919 3.732884764731175e7 557549.3760698983 11.5613112359668 29185.377429155982 358.21541196686786 558.5437522430266 4.4273763384969905e6 6307.413487669084 74002.1581309518 10364.517047082998 3637.2094924008625 1.1947613520574297e6 447578.5095552293 291.4772781322366 1374.2988806594788 1.962604526898348e7 3.2971629760216796 2.448372686723523e7 29.780706570776722 55641.986055081616 4.509893046176693 19.532298318252273 4.469892412213421e6 406733.071338505 2.0223576152480827 52.61605464522674 3.1049927918453203e6 25755.76466513176 2020.3046979579374 17469.531663417965 31059.438775376973 11340.934289747907 2611.3321922434534 270820.9348998961 15.181463265787816 3 | 393.27082255914763 8762.433837886694 76990.50639305367 982541.0514343873 120035.94628574868 2.4750605319789774e6 1.6839919141004896e6 106290.74965947538 1.8925698533290783e6 3.5597981586927287e6 1.2041815365392026e6 2667.0324173307245 7.022361592705109e6 61842.87726552899 10592.374335536751 82.86412084650134 3.1078681331432763 4.814333191772723e6 73.51406387738878 7758.037322925205 180049.80519355746 6147.899117586876 41.132793491034 4119.056885466881 1.129140212491242e6 13.76344741772251 5.396951022339949e6 1.0510294280462062e6 353678.19859965524 387410.27994267695 131.22649711039298 1.7474575846160215e6 5.554462784416942e6 62823.621543123954 1.0810831547931996e6 2763.612249998886 32.592758816153385 1924.5789542238936 20455.336399576954 2.5912106067693695e7 6.666571961363187e6 29290.523208228802 1.8599540957236322 66211.03233334595 215639.08806505465 232409.49818963523 454208.06587011117 1778.8899903133515 699799.893478128 15838.168355940204 4 | 4.9220093435591295e7 105024.82969206493 9769.914476740512 135894.0631955309 8.127210509437004e6 764.2368350800538 102.08075274979417 31467.241008335168 267814.5703032268 108044.9044572002 3.555628624409443e6 2.6260078606690387 41414.8057672702 140773.3430598633 11534.347546678324 13156.824896874936 316.1062269348955 380838.7679289194 66557.19879697148 163731.50490060134 380.7852271812075 2.3317969832044e7 1.149214129357547e6 6.01678592098854e6 57727.17358739811 35667.77574116431 12416.271245546042 7.17729538769883e6 241636.2200582382 78434.5186475209 51.05217129553553 567611.4147304109 7740.670825332023 110.82613435635277 4938.899096609191 155.04848502944515 2.931703302147176 9.10707116783776e6 830.3755909165625 334403.7755431064 3.2607321835580324e6 13.241316116110486 2.5772171531862924e6 1.3708981030700369e7 15262.582849962659 2.9741947753714003e7 731646.0183406114 91.81481682647822 25.403341812312647 3.60371528491868e6 5 | 2.427202968698843 278675.3153311659 503.4910832548567 3.121350991501627e7 4.702319224818867e6 1.6950122283093054e6 646474.225579821 44180.668586279564 51.22098905430076 1508.4284223679051 1.4665499056153176e7 811294.5860471777 13324.504739120146 11589.639366301913 4.991145741595591 991.6604341748581 11.598043333109427 506950.4456854835 104.31849643673688 64.14281326595744 72805.82696595002 36.732506920779485 2.202668936632015e6 465788.3544781989 21828.933792665226 5.230105066688555e6 200.99832628087526 135043.53616277012 68.52758781546594 188.16626263265604 6875.650048723378 133313.78020282162 846.7479377812789 9188.812267405245 11.099446852004256 1.8431080770436598e6 299998.78818666516 194171.7939532785 386493.96260722785 3.20356414991215e7 1.2840075401485234e7 91949.89537262473 42.2520327258855 24330.198169160696 1.0531743757330948e7 1588.8364180668982 101328.97914454482 735790.913865826 2.2139676669976376e6 1.0891119754173916e7 6 | 4.499549945788385e6 267923.937180332 39995.937699352624 6825.803820773809 57.25313041818249 846.970359760314 6955.951962739215 1.0050315422153327e6 3.8362660798999667e6 508454.09282353206 54414.05930806089 6548.793695649356 1.3799073745230585e6 155044.6793270312 492661.54888826236 78619.81837429602 5.826340158907428e6 92978.52925782169 1.732742534078426e7 2.8887263189798123e6 149.40585831712437 173573.52988838963 3750.642242449901 1.1486490376620272e6 2055.4848830213887 7.546144587710153e6 4.888439548277409e6 889.1896999529771 415.9731758884075 2.375816593541791e6 218.8845416743047 2.790006585356088e6 494470.3122017059 3.109127668305065e6 472.7669549872367 71321.52965097893 4.350391906697806 158796.3179782663 3.0976329226745468e7 1.0778741583640616e7 4.063870774397227 1.4973952382328992e6 2694.7618353663147 57188.781220160694 116427.55194519993 6.277304884493204 16.441714345879593 19.233750426374513 4.228642205669723e6 175.0748979961146 7 | 3.355124647815209e6 200.9881083494209 197.8890811098052 407386.8588861043 1.1176363514532193e6 67369.28311908146 2304.9431239968494 1.4686870198993208e7 4.478455047643173 13.02380050366901 28408.21734729597 1422.9004441165914 1.5987707722680883e6 11727.145479575021 8.283514026050378e6 11827.189980043575 1.2535883644172352e7 152346.95932551147 359.58937870753664 2579.8053657600653 5.337331282657898 21643.343427185784 177.5448088443878 531449.4281652941 3.9061390722104846e6 390206.3827459486 987.4772167669008 2.8999901755935658 164522.90697498206 54747.14140460411 154601.30789092573 1.7750377078463575e6 4.160798399878905e7 66.98136062272535 84026.67401551465 89.08291541908359 3.672701267065371e6 13072.530950672244 1.1085174008709707e6 959.8022501963119 64.29504606842534 162.74004858097504 28899.217820826267 1936.569289593365 495222.2791073398 66178.94369103196 139388.76462598034 705.2506714284178 79.3867223698397 1.3313497658296525e6 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/normurobBs.txt: -------------------------------------------------------------------------------- 1 | 7.202026596759472 8.015140507124041 5.2935776442206475 4.518663532753084 5.589935777839233 7.64770356084673 5.588978858631415 6.72568766892053 6.813809000062103 5.602900235073795 4.797363519724643 9.19459015404543 6.68858783332714 6.406057534022764 5.471709288374985 6.311957806630574 5.176256611866833 5.69752358992601 4.435441197028001 6.35682245130902 7.819531958115276 5.235369606045591 7.97897544505972 5.3421364854999585 6.505560758787262 4.681352806874757 5.9392582258022 4.042626935201115 5.029098986765122 7.467725245785921 6.629529278123838 6.392190833053631 5.684322098572531 6.261576348643354 6.612364245626015 7.065912150461311 5.754606860124704 4.679591402347141 6.461892951848966 5.93218130912076 7.329860021223227 8.106228223600768 5.681910594405733 6.759801505476942 6.011400071312664 7.045959401136174 5.491529077023153 6.77889481292333 7.551929383252221 6.064446469509022 2 | 4.936542807803021 5.453307692666282 4.569943430666228 5.375801545267214 6.10542593588772 4.707442745113409 6.4893020093039535 7.286275153113612 6.744983902115352 5.582965084455056 7.208164721483933 6.203628235312733 6.839075292286826 6.293552902568802 6.437276578727414 6.948473224420519 5.124705090825734 8.246059162610868 5.6296784111781815 6.262283191088088 4.3758568216428895 6.140946697317867 6.202495549334025 6.942743370999688 5.333283444514158 5.262091189753088 4.752583131461311 6.99439770743128 5.5094993306685875 4.568119484865174 7.961142065560384 6.487407549072676 7.775338463251468 7.624557976528138 4.8715100587152875 6.006978233980284 8.839656965192626 4.707772355595453 5.356193936593151 5.661050085719471 7.757199353096538 5.081374618839863 6.170901741513234 6.8898240579062815 5.1472580298625275 3.902680526393934 5.258025970131319 7.649296601442351 7.071291560426625 7.074565114221659 3 | 5.3393968535086636 8.390239074726416 4.94856415147678 6.470639290635684 4.395842026697915 5.93711814657334 5.689654847837502 5.300792007649378 7.530935299379126 5.328189535376519 7.533290367396871 7.457664853564602 5.154243646012561 7.083015661827343 6.957965557666367 5.767396006270951 8.072760707566667 7.29099705877377 4.2202372887644035 6.403743485580851 7.009008946659939 7.267272011874506 5.8800104269469635 5.354228200995914 6.828304936948675 7.926038258889122 6.4366233182918675 5.887948496548202 4.995711056035301 5.6214372047242325 5.601437189359866 5.177790620618418 5.60420328621933 4.135247525211588 5.6869672601809125 8.476616626040098 5.082403975139682 5.465689278585165 6.789894271335297 7.696147267494152 6.452411984273515 5.19401954878423 7.4803708727526566 5.19926907246266 5.381231092328565 6.755241717860354 5.895527355128048 6.856641328092049 4.3700156513587025 3.771421769735572e12 4 | 5.94925657718445 6.756510144031135 5.773162042522289 6.28863125833689 6.3111240223543135 5.884642111535234 5.956025527302022 7.180663353666554 8.62740527246193 6.362041184260634 5.377942117007296 5.6777193435930995 5.227140905909275 5.189759795951504 5.90811745226984 6.708304050482176 6.7937048871013195 6.054704261693942 9.386777430005106 5.646204755686566 8.767541146773386 4.974341533013817 7.56521512297995 7.002245956143149 7.110441297339458 7.701771192160561 6.183552099868752 5.4181780104529 7.167538159396609 6.8787476616197765 4.6334249701273045 6.925821995501278 6.872225653992537 5.7061226303598405 6.1171901163669515 4.55117298534483 5.312108155490792 8.057309167236586 7.881363970226113 5.283082302384134 5.180175526037653 7.027021638913288 5.182528946648203 5.397146083307102 7.341841146766775 6.607105036965828 5.403265115881706 5.771390896017135 6.38095822039046 4.828335987213339 5 | 9.017645513797671 4.567958205582215 6.655221895471895 6.464969213118894 5.083122254479353 5.485526252726682 6.077885790938302 6.663100143949593 7.793546872688565 6.2088642553654205 5.488094804914811 6.514666487127647 5.7490675678910375 5.831632286846027 4.6430611970161735 4.73901551844587 4.77393831371862 4.367324547749187 6.568202642626283 5.753217433162018 6.400975222915588 9.135970331135251 6.534534798113857 6.115384991416621 5.874467758265761 8.177298842275592 9.301540553768863 5.076429727209857 5.164167233820109 5.033360114620116 6.353943454332308 5.08475589566904 6.461648546226688 5.989660495879834 4.8247422522113235 4.904833274468197 4.236344851000003 6.61262812634473 7.742300714480442 4.443070617700331 5.156750279184529 5.426146291447668 6.601333641346473 5.178161589935618 4.798098585708169 5.040587090187314 5.636793498228668 4.176052022905429 5.777544085828827 5.164147113413476 6 | 4.330508894695924 6.202181699883498 5.7397493807495295 7.531654308645098 5.617678834097908 6.09326410257832 5.092905561346229 4.137510859983242 5.889956042325834 6.67685848667078 6.072232863889201 5.830407088883462 5.189951889636776 6.899159028212609 6.386668199248943 6.420319324443097 7.706550370194354 7.191726754849284 5.865711636987626 5.341589677382311 5.094117312807571 4.722978686940607 4.863779525364939 6.789920243169658 6.750870476955251 5.863056826491427 4.817525005301335 5.53136480408665 5.002476525308894 6.617697546300768 5.890070935009129 5.277617603006186 6.080449571263879 5.235970348628297 4.12366257302642 7.238878408762794 1.3610043622506464e8 5.567103899601942 6.311619929767681 7.415714314527448 4.499554261383153 6.5293321075471065 5.119462727745766 5.842061234261032 4.533115431562179 4.2377152724593605 4.885359136972154 3.326046230198215 7.308616436769106 8.729648727116079 7 | 4.279869535005285 6.526063368684342 5.322321699001385 4.738845265548345 4.120768603333762 6.628717307847136 3.846735219641209 6.721375146635578 4.922745827882098 6.00591536746091 3.8744973835988272 4.432795511738349 5.94520666356998 5.1687078756582 5.304715960872812 5.251569297719243 4.597006959206847 6.779900223479446 5.263893577868214 5.7707005847920465 6.907948289800539 5.093210033994117 5.420911044528582 5.719253155762916 4.1186234688771854 4.671218650436289 7.006422176906892 5.767725542039283 7.661152421463986 4.721020569667849 6.452243539453169 4.617148445536027 5.2364011574128035 4.526262871003389 6.90119089462171 5.345792073876945 5.369679097361277 8.044655949212375 5.867274723620312 4.505282582575328 5.690481235801306 4.81409843145307 4.479874205411392 5.413613196517206 5.276356259777575 5.607305648270571 8.097905164853525 5.495852977757719 5.997622643218083 3.9438496834426076 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/normurobTs.txt: -------------------------------------------------------------------------------- 1 | 6.956960144617674 7.8043819165427095 5.364714968385911 4.975023197438734 5.533874167404805 7.858189809945288 5.396647119976989 6.649337382094005 6.508811930021635 5.770463488691446 4.984753856007529 8.965539225366108 6.096374698291737 6.523738895964084 5.598793732245905 6.04611393159808 5.101880237539907 5.6413667545618225 4.327313208654576 6.651032018058643 7.93418735202933 4.983840125279548 7.2393068016467135 5.171315554534663 6.378437237229294 4.7842430594426615 6.051565370093993 3.8454446976367938 4.912346326335899 7.232021144053382 6.798013589109385 5.683926594199783 5.655577185895063 6.127582954565895 6.652861073961701 7.369197622219855 6.201839133839218 4.604289327811756 6.703215257654138 6.2518900078607205 7.180274646008418 8.448963441116273 5.3304050617196825 6.745419451474518 5.308082712662073 6.8455498306035745 6.027070756244962 6.859488929318837 7.5187712729592 5.285262636937637 2 | 5.02737065538464 5.656983860903327 4.606192439258328 5.39162623574463 5.585342627456404 4.454847599655851 6.359902007760825 7.367565965303178 7.239399691976371 6.036086873417132 7.664742814642775 6.3402809991947 6.5146060609441045 6.428884358881551 6.973529866686657 6.96446992647004 5.246588437019705 7.572990687044669 6.316824475633946 6.596681788811624 4.5345968357841855 5.947966823528992 6.372526017034334 7.55327632138601 5.594665509237386 5.143604489530985 5.154941800426454 7.138784864191648 5.500298707171819 4.528978922446879 9.265211841172498 5.884627389609028 7.629715415574775 7.5011959627548075 4.603262001985707 5.785292488633008 8.02172001008128 4.9089996048563265 4.591366245617544 5.926036316639312 7.418952336170067 5.405149274164665 6.184919824169026 7.304125856272361 5.117360637055019 4.462942702141888 5.2699234595780045 7.162138306143591 6.8988335599778035 7.56326088539246 3 | 4.896249883537795 8.208485724973254 5.203093258488772 6.4796920519425445 4.5634410641133 6.19207641268764 5.600956806837742 5.786045767880859 6.595799421198596 5.594358874400474 7.262469680316983 7.477275872352175 5.225189248159391 6.692402628457189 7.087222905945975 6.126523585287319 8.367920312205362 6.918656337300225 4.70080096764284 6.218682346525305 6.8430113584686945 6.542189482829967 5.921272271690489 5.469240911136013 6.420896046085768 8.025132922336581 6.354278992478944 6.279755335693588 4.790845675632635 5.25614961830661 5.582610224023383 5.530297740029737 5.746350192959235 4.376854575067647 5.833125376760505 8.917208258925344 5.062979996466081 5.402668422471396 6.846822606981663 8.020722622246343 6.492873626076934 5.397214389286903 7.460869649253651 4.559415098147661 5.001042683859792 6.6212151053822765 5.913240043129262 6.445195308514636 4.636833037782298 9.01285999777142e13 4 | 6.118953416274223 7.052994423803753 6.397912521923063 6.286523504930943 6.650239917453262 5.822839870834198 6.500432470048947 6.737936575201616 8.745371539232153 6.094402865274732 5.3854883940165 5.450100725343675 4.940137112083559 5.719245577160798 5.521030545046865 6.838214064579511 6.720010559254879 5.079622734610777 9.994095651225523 5.875260287134118 9.044936106498604 4.996778267382783 8.304656348006802 6.740248679784998 6.895875481851666 6.707333132754123 6.129670286610254 5.037605082531188 7.895875752177106 5.984972473174764 4.148385687760899 6.3172680921087565 6.703885653517746 5.948445362225841 6.450971197567995 5.101933888087989 5.4138573910165375 7.843211796693914 7.553348987218027 5.717472450889678 5.004243784714603 6.853820648015878 5.036305364653439 5.108448522937767 7.044289735220333 6.5558631337906075 5.660357744845622 6.211559834924342 6.53405140167702 4.8697695702827035 5 | 6.610914267484438 4.111297787111039 6.253918004102497 6.05593198119425 5.21805391556796 5.817099028973759 5.431172044778916 6.283814599861536 7.109865511936949 6.729636609366706 5.301736892562746 6.3083268055458435 5.3073420600528225 6.282557696531713 5.027630006301049 5.46531926329424 4.721475207887615 5.297692398745433 6.331411091517994 5.311821399939106 5.700413795665388 8.238748206553657 6.116466269408631 5.731778623332943 5.754274803406432 7.935804371959464 8.830484942877186 5.122876233181536 5.100508856353075 5.469116165789243 5.1677904657011435 4.949058614305177 6.400447401827824 5.092364948770958 5.305371380769312 5.167935608473648 4.143546686346193 6.670372085575311 8.073761741310843 4.995872475320878 5.155881510640577 5.562055480680115 4.982916666971733 5.469562462402135 5.017767943765859 4.980600767892036 5.9822072864837885 4.381270225100602 5.7403957969726065 5.293590765358019 6 | 4.258616882490371 5.745824022106215 5.512267667112015 6.169649095926445 5.4976971565344614 4.988184004312987 5.1070324337122015 4.091679985282269 5.4632923797697375 6.620205791346364 6.606885013061791 5.979129083110165 6.207796544896878 5.878079242187926 6.386821562078699 5.878677310685803 6.511692510876897 7.3191314507463785 5.963685768440115 5.177775981877573 5.22183142521107 4.90536833801249 5.411694552449576 6.878346492974808 6.764207039596024 6.170034065216354 4.632162281572696 5.095525625496205 4.763663600069958 7.69410746827747 4.85987344382565 4.409592853992043 2.826526479696529 6.102519339571405 3.903553740318359 6.937476560385563 480857.28780172335 5.347813654398917 6.519786129882105 7.187135622702037 5.154953093712013 6.684583690987062 5.271710062998505 5.645159816251663 5.114300597782243 3.6911317967687336 4.26415669887566 3.3660966652104145 6.569529906632995 5.124265573858472 7 | 4.151649584690576 6.352438782566475 5.573576001345263 4.47327584587098 5.062596036935548 6.551332063125009 3.7544983536482643 6.3650299676109405 4.947087698451357 5.525338672701307 4.802334114518649 5.0005687320963395 2.849216435749055 4.792585397654447 5.850974153414508 4.821653734157149 4.560033352110605 6.292834298422179 6.822293747228388 6.213425990937997 6.393506868442015 4.672415744590217 4.755031761900032 6.352690080950523 4.410056548025868 5.251563754280765 5.599075111844339 5.0456046689987835 7.276628307660253 5.7971594650857945 6.366433196338064 4.004591028471611 5.699318615491865 4.428033677270953 5.442548490522874 4.8729202169823465 5.253115163638546 6.545713647202442 4.755508812824377 4.714167338484773 5.307900917878089 5.65071362906831 4.705685802752953 5.295032589246926 4.86136946455892 5.699688981780556 8.027572576003907 4.804437923824987 5.039426773737956 3.3304980586806985 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/normustars.txt: -------------------------------------------------------------------------------- 1 | 2.839366944256284 3.2045431384102487 2.9398004845802976 3.271172266767208 3.3290302151582347 3.1286034254700974 2.8829594259919578 2.92079765656982 3.004222574686808 2.688329706306253 2.677665767799461 2.939005737751643 2.9708463270553307 3.310259911002207 2.7952122781846436 3.112062436754722 3.1074038917366584 2.3026780542988505 3.2427771605010545 2.838791686693917 3.13986640915632 2.960811981791835 3.2658185882398025 2.8646421350000204 2.7113175697904968 3.3970887575100046 3.439650594842725 3.3571462908209444 3.196534024113896 2.9975619212469513 2.7678243769046573 2.9242171180117893 3.42987161463997 3.27939514473002 3.287380454319645 2.8828765201325406 3.0593272205302173 3.0474926469982875 2.925348740721364 2.9290782123804204 2.662804547151501 2.577112435132136 3.3905900528490927 2.939488540612229 2.8830916157183597 3.1801600077070327 3.0155188706396125 2.8906904703423275 2.8899862829870235 3.240267196925561 2 | 3.274869043589654 3.032220254812341 3.2722053885217646 3.2172303072926245 3.236928801912741 3.149957340281833 3.348913282374358 3.176272547596018 3.1937213241638647 2.6394616205449624 2.9349945143817613 2.936838264618335 2.9472914290369117 3.18325705912683 2.929133087300194 2.7993117782312993 2.7118886215718883 3.257089968812639 2.6255550529981266 2.8214350439281857 3.0483902985893816 2.995630778819403 3.0160393950449853 3.0671221166313365 2.735464220484612 3.1376387231993967 3.3072141756561573 3.097322906877005 2.9031520725065536 3.315988206987603 3.0223030099978225 3.1322225663377448 2.749089140920888 2.878879454351178 2.8973979101303273 2.7995005174396823 3.1945447008689922 3.0989529963533644 2.9787422410038102 3.1768030672287373 3.294625861923676 3.318508745900771 3.0423698407177295 3.0803050553595264 3.283968416346693 2.9265103962918873 3.016874456054616 2.512281125708825 3.3181606764450873 3.1835022583764063 3 | 2.9661107847322326 3.1576584540291295 3.0311799344268873 3.0268259145046574 2.7944608192666953 2.903314734760087 3.389569531776647 2.9933177629256043 3.512395122619718 3.3369192148058295 2.98623803320299 3.137035315656996 3.2578220044711887 2.9517579025127803 2.8218931745135154 2.903658797397326 2.966520970563414 2.716019465449661 2.889214420928625 2.669172975449305 2.9290931283051314 2.851455048869435 2.748617048058996 3.2127358777033335 3.1659892180646314 2.7589415551548298 3.475685120062366 3.1310492184973784 2.6909726572927144 2.4774304982418096 3.1246037237510103 2.7902318695368087 2.7949039692701465 3.090015898339365 3.1388918059185604 2.693947525642985 3.1551553189056327 2.77164097909304 3.0157833177095603 2.9257635478745168 2.9874209094686583 2.6572076682630907 2.9806210735154606 2.965499961589686 3.022056256733507 2.543944928193187 2.6843332372847026 3.0932142838898606 3.196728320794742 2.7111877891155958 4 | 2.8749762739450175 2.9296320502513584 3.1661319414696925 2.867270035581748 3.159446187832391 3.5393146491664558 2.8309149456679346 3.289688206126781 2.752552645688915 2.845398149420006 3.2427594481671562 2.992035432314912 2.771941832105062 2.7824452433641556 3.0027493770990015 3.1015760029661967 2.9681594601945913 2.805720666678615 2.91605670991394 3.43122467513946 3.2287892999845056 2.9209591395512167 2.7603161436463157 3.131541253855646 3.0429673556583428 2.8731173826898595 2.9578361757131444 2.9105912740300606 2.9650624962892365 2.742750422438509 3.049327322266629 2.8509014935991432 2.7555442634415814 2.764199275656294 2.8410950111658586 3.182165358819584 3.028536938737644 2.971761882039185 3.09743782350345 2.975298139066522 3.0001252912283753 3.1560617449128467 2.7126823828646875 3.7831997026961406 3.5219858719570265 2.900574408644418 2.736913095850672 2.7348079246698727 2.753532733490701 3.1976209282729062 5 | 3.112141877699325 2.9185029486990826 2.8747041283291574 3.1361458751158486 3.151427608004025 3.1172399100075787 3.0626048191745743 2.96402597806187 2.945318151060915 3.1075768543233275 2.776929174967963 2.965179458536749 2.8951518763820827 2.7945094153720476 2.99000325296132 2.816455330981739 2.979103134804856 2.8834129509832462 2.9505698683613044 3.097941653181304 2.9208720066216385 3.0117064847537396 3.2861370918059776 3.0002095324344844 2.640703443697449 3.043478021511145 2.5999151877429587 3.096333542767079 3.24018554827197 3.363337364629529 2.728034430561914 3.1082596329054444 2.831576639737263 2.928125703454795 2.979597489383797 3.0270176876082395 3.0063702366551026 3.0489641836373527 3.0324827830832586 2.5741632814232758 3.0668884393962115 2.547623697776351 2.7718895925436033 2.5667421432131707 3.008124074184235 2.9677271697439536 3.1289985841885373 2.9748233424529733 3.017714751325411 3.081248578048046 6 | 2.5541975419192022 3.3484319655831936 2.8939264291280673 3.1196960335584674 2.879525315876565 2.9057226407477685 2.6475459594290056 3.1202703017908124 3.0874685975327143 2.8759949377776826 3.1887159874140485 2.940670257795833 3.109851839481085 2.8916363226694393 3.3352707236283523 2.855730312173837 2.8061153901946074 3.6738161631573374 2.6244824127296567 3.216685841342359 2.8984312616004173 2.825955916205756 3.026674279563245 3.2228748158785505 3.1654778109618764 3.056846725819627 2.5249733258549822 2.978832518713614 2.932442345431129 2.684847038839353 2.9782077737887898 2.679296493571367 2.916272048318043 2.8984866708324732 2.7074432553979326 3.1032836183591326 3.2418194721035833 2.768105367692507 2.7527050569972435 2.6403524803483056 3.420113839851731 3.2487092485704876 3.1971437170133417 3.1374694626208925 3.1221932030795125 2.6725426919011666 3.618553378001949 3.1627006404617655 2.93342298003984 2.9857689792408357 7 | 2.921095916879286 2.9096361461444085 3.0768237583572935 2.731195253349231 3.0979849215595765 2.7356201618280624 3.0729875641984066 3.364240767616431 3.0116109154740145 2.6433483795235517 2.747051878647998 2.8282093612993573 2.9197065049820536 3.345109012445617 2.769943693371115 2.7831575234641504 3.197470063039756 2.803343115191069 3.105680152334259 3.508754781499257 2.9080977267789025 2.9686875188682498 2.690246178840304 3.1359868722093043 3.1299902644500937 2.5408948676620544 2.986323691651879 2.9391398214073203 2.886525819805916 2.996885986645555 2.734664474916818 3.0205702535571195 2.9514846461057633 2.9168905138441823 2.9647726498672737 3.019658434632166 2.774399897203609 3.1450476198264794 2.805491068590081 3.3880657128192726 2.872287086517692 3.0084726592424356 2.858269451802826 2.8363697960503007 2.8638278211611143 3.233105759359017 3.1011272070645437 2.8504553677004765 3.2381800757065626 2.916141833422073 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/normxnoms.txt: -------------------------------------------------------------------------------- 1 | 1.5593219789856734e7 1041.7272231850893 1.4717598440998812e9 105.65637418371398 3.6852304574140958e6 1.6396299649512687e9 2.033290244866051e8 795136.2696242091 48359.874493622774 1.3327475438852023e7 12453.17407458571 9071.541655785535 7.846764253031374e6 2.376421314222898e6 277437.7451276217 1.8689291245408326e8 5.860722714052393e6 1.5233054004835396e9 3.02676080293244e6 1.4246422033821201e10 1.3763749778785788e7 7.174585130762465e6 235547.64825687816 2.356708133674547e6 4.955559673881916e8 5161.583613572338 4.76602521119153e7 1.3829559783186328e6 713.6968614889814 58894.35522756907 6.986059848788121e7 150228.245084222 748958.0278494259 2.861880669227694e8 233923.16908342455 2.853504294608448e8 656.1403170576936 1.376539399602784e6 265.18715288011083 6.522071093103381e8 1.0150056138407384e6 311107.95514493546 1.5314775115430496e9 1.0786497264184576e8 2.4936054710579476e9 996806.9555936544 398143.76766076207 6863.652716611878 8.503570789913962e6 6852.931186874789 2 | 4.4712077416086763e8 2.2318446539175846e7 13902.036749238594 4223.202162403965 7.615162670743343e8 618849.465073448 3.920443469681581e9 4.035149726470375e7 218649.36948570755 1.2090362124126523e6 6299.634144187927 4.269199588450879e8 5.731545545856358e6 1.3905819893802502e9 1.5922382045452348e6 1.1262813538457363e10 8.653521153626375e7 614.5175623946039 2.7876113401428787e6 76651.61369804076 56421.80534060666 7.02212032084426e8 557688.1170868597 7.158940571569306e6 925852.1586126534 323636.9361223845 1.8040924503643602e8 5.1412824539980024e7 27587.766746275858 178078.95162270105 3.0908030021930885e9 266.4295739399939 9.422015215952377e9 7924.854927868897 5.958640406846117e6 304.9713721214977 2559.4615502359698 7.422329584737426e8 5.374512954547325e7 132.61376209030743 2850.0244503961853 4.790003036199213e8 2.2900814715361795e6 143760.64539517215 2.0048233030808645e6 3.0821698127957056e6 1.0088367562674534e6 220172.11482731364 3.0161207893348303e7 1896.051869927113 3 | 38643.45935739791 1.1110132246792836e6 8.548812984492607e6 1.8169081226034775e8 1.1920720834594106e7 4.511903438363495e8 2.3764829765019178e8 1.1113434801398989e7 2.2442433509826094e8 5.343590812090432e8 3.663901115655486e8 278217.7526558883 1.183201126425591e9 6.362942095677372e6 1.193470540081513e6 4436.820216964809 141.79700460472992 8.495912355861303e8 5106.557278135488 776381.2498355898 1.8618941527529877e7 486640.8303790364 4450.19477081781 339860.3734577447 1.539100619734602e8 1264.2496353057702 1.3668739126909022e9 1.308534805906545e8 4.321955693684794e7 4.332008675925334e7 7443.182527618974 2.9391683041135114e8 1.3386535404943852e9 6.317992239851154e6 2.4400894954586017e8 253314.56042608418 1565.9225528706895 175595.15396576762 1.9458484069367363e6 7.705905240665829e9 1.5756008676640747e9 3.261148497148537e6 120.43023630958557 5.788759771232934e6 2.484673314157154e7 2.5382460660652023e7 5.209465576412785e7 120431.71359343616 7.896694716527103e7 1.3797807130594861e6 4 | 1.2644057027530775e10 1.190954005528503e7 958165.8709630215 1.3896052230113761e7 2.6152327565788054e9 82205.99256518683 20263.741018996647 2.752328089172977e6 3.0361868984693125e7 9.589691845900686e6 6.368628947402003e8 158.0462481807237 3.8821571136134737e6 1.3218469243153714e7 820195.3751044709 1.588016784808832e6 21605.768211733513 4.47846777850964e7 6.071856404276492e6 2.1442687662922878e7 32461.196630577902 9.239342227045668e9 2.350727068369972e8 8.744409505873557e8 4.9268760094418805e6 3.8871483600515304e6 1.1533438740006424e6 1.4582566349322443e9 3.058314859565957e7 7.6709254753206605e6 5772.921202843246 8.768820403858586e7 554411.3645439262 8199.388705753096 456284.49668255076 9392.407220522855 117.96854329639214 1.9206538448893108e9 190848.78401395556 4.6084287548522964e7 4.771383173611309e8 2410.824245369866 4.011037956531832e8 2.491474442656274e9 1.6288265606822835e6 6.629147631415652e9 8.575773551765689e7 9507.508801721597 6809.89164091515 5.40521035476228e8 5 | 151.3050330855081 5.692126417922824e7 30750.492938956082 8.350474775470342e9 9.09507167514573e8 2.75304348524415e8 7.674865884897003e7 4.796278842887319e6 12935.660148632838 98176.57753740273 3.1038754315442877e9 1.1434560308060257e8 1.0673043332163892e6 1.2576234378218171e6 366.9193768253552 106065.42817322008 617.1353364372887 6.1101190119909935e7 7947.80600290586 4737.631288794483 7.074633455886576e6 2462.4540798491057 2.6202971962113142e8 7.60174819512403e7 2.311491809663072e6 9.57980669761653e8 18627.600068734944 1.511236811703075e7 5153.259203909674 21327.048461718634 919164.429732321 1.279841558650969e7 68069.90109419994 736795.6278400478 505.70563487798603 2.5960966098207942e8 2.7639872354978524e7 1.9568789597570125e7 6.5215900240322016e7 7.823864507802729e9 2.483759134967687e9 2.421552408916879e7 2634.25951562641 2.114633742113584e6 1.6924448529246798e9 132673.6494069451 1.0732122725061022e7 9.36338362904026e7 2.7762774312277234e8 2.0615102362863336e9 6 | 8.483421243592485e8 3.088492658930303e7 3.915789480348399e6 481725.3316947904 3201.473174893414 93540.12003847277 575746.4155703958 1.221477786248654e8 9.421690343399343e8 5.987247206001217e7 5.4313923567662425e6 481860.6326602598 1.728232564365266e8 1.6602380201184565e7 7.369585528599827e7 7.500436025241716e6 1.4446922919528506e9 9.590931510947522e6 5.68627203187768e9 4.6530518623481e8 12178.97293328553 2.0358358119417638e7 422477.6866536724 2.03237562791304e8 181711.6201650478 1.7267869046455786e9 9.002110105252874e8 102744.13764431157 83711.09955685158 5.002606591673105e8 27057.922533264413 4.381930584613246e8 5.0270412325732514e7 4.50894605195818e8 32326.74372689735 6.541961345975929e6 223.60540133258922 1.815370117357946e7 8.345965562779681e9 3.07243802590562e9 219.56369498580054 2.981828733732049e8 254495.4473587337 6.643623101257538e6 1.159408354736723e7 301.0238992373153 1696.8974867599834 1127.654803198838 7.242331548421246e8 17390.58381376005 7 | 4.8359992080187196e8 20488.969468534997 15092.888898126692 4.6280712166682236e7 1.2663585516216731e8 7.272388922749185e6 172977.640917304 2.914715486975007e9 299.5858414767643 1836.1666707638772 2.3883576398204844e6 177487.90493030054 2.4204615034469616e8 918651.8187908789 1.5040661079876218e9 923536.6314104907 2.2013158522399726e9 1.689130702143071e7 26967.81108822862 247919.32640561543 400.65275863785627 1.8909968168803689e6 21525.937116470464 8.358822038030873e7 6.51224711711515e8 4.200888417129541e7 122726.24023551954 119.17080696529273 1.845125686277993e7 5.5620749440045e6 1.3972792487818168e7 2.994982626026237e8 1.2606794047832565e10 5540.696208033491 1.1420848896180378e7 5670.171248435604 6.247363711228262e8 1.6381437062459213e6 1.344865716010254e8 64102.73820230692 9370.381535272682 15261.81467596722 3.4700749556085607e6 143713.5209630995 6.455821380753844e7 8.67567875318462e6 1.4122438586053718e7 71288.5786964892 5882.688246825424 1.5104844550379515e8 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/normxrobBs.txt: -------------------------------------------------------------------------------- 1 | 60.376372952842985 54.906076772544196 78.29776959484246 57.98456011482584 59.19887717105884 64.98891539328467 51.408846195419315 58.69332496656749 52.11615967596205 55.12350235970761 59.99471912016658 117.14725682583862 81.01499765547175 41.200340093632995 44.554750787432056 54.93646981188703 42.6397129717442 46.04679521911604 62.26632384896691 52.980406206405156 82.45623270717725 65.56088427616456 71.87653569249828 56.20012689496985 57.529489762608314 49.01762567327656 43.55582616753951 70.85854629072838 61.95824905481584 75.97276202444054 49.78258455025656 52.13689468566161 64.59499571598667 66.62554811980402 56.993549369749886 50.72124717577884 68.6478503178599 58.17711782160758 83.2901942129707 68.14282503495338 119.16818207599134 54.1887604603814 65.44070497921852 46.13092237789135 49.50289755970112 75.61937113405818 64.78797306826857 59.70520171940708 51.9435001931837 61.98106294807655 2 | 46.1386742998463 54.55525067863388 46.5818611254781 66.10812705094732 54.459406297983506 56.44373468046382 56.011496864020955 56.61777823016512 49.221420065828546 59.603746873334934 38.2880004483832 60.537156136462144 57.10640868594652 65.32172405410836 55.1742504758159 46.73525300951021 50.005350170496484 70.32979394412125 52.358367972509654 51.427116404146325 76.14483830879696 65.95331934743706 53.47356057155553 50.772295293890984 53.08760785349877 50.994896246939994 48.4057573932602 45.47955865787884 50.703357381574065 51.450292710997104 52.62736764730761 91.0207409882248 47.57236722198545 96.55923590737868 54.23916109820115 65.9985357142364 44.20007077238651 70.74816101254261 75.18749750868766 54.477861611657694 42.662911152128984 66.9071331924536 50.27196536398666 45.93426083456822 92.037195095065 55.95201112010745 54.3747066792171 57.04546509273228 68.6263744387137 44.87615946507343 3 | 49.97167443104514 59.0385109229677 73.55753874369714 46.75201463179494 52.646806383003984 54.18187024871816 56.54361248670607 51.840266111684286 126.36988395075004 45.77723914934395 53.60903294031024 52.8343225327679 64.07786596354306 58.8391802499882 59.083628709219624 50.24133978128591 57.35343116102368 50.36208042445763 62.53461492753712 46.55795995757917 55.44805400044307 62.64543925260776 48.31376875344335 51.27656795726881 58.83106512590519 45.664770978842164 59.7311495393215 68.43748176826259 50.38176812032108 54.096464784739474 45.7536722451083 82.93581229209636 42.519462350149816 66.96648413607925 47.494141545892404 68.97684745959744 46.66043946259877 45.04960642710915 66.53900547003082 62.2805332305017 66.49700232434647 52.92649840727442 64.11925156190767 66.43612011702287 68.78971684472883 43.04727162362922 52.723857117014056 66.15081645901591 48.88934320592794 2.830758802486149e14 4 | 44.481346431598645 74.14876445943926 70.36897219841615 63.64157209641407 67.71589366213266 56.478827039854266 46.37101091682986 45.8208334410316 58.72363409830345 57.41458567298555 43.46644926856402 55.193218460851746 56.0318449147027 60.50483036383577 53.42780767168761 56.52449941335212 51.757560984886794 55.89704325906909 54.49685436403743 48.273898369591855 57.57638877455024 52.49582891268524 88.07931847182037 44.71692815254196 55.56366814218183 68.89868078799698 66.17490443577546 48.08069526609821 47.84538792597996 44.32558385103759 65.56940389923129 59.47883782823061 70.1566504376925 42.37626912359847 64.19895059883503 46.0762096950118 64.9680088057697 49.99701256532885 51.98854498723884 43.79918884485831 70.31635020368071 50.075831331561254 50.255059938984154 67.7857453443295 62.26200816193417 58.295924129902836 57.45535048553103 46.54134723552973 51.164192609720054 61.18767927845514 5 | 336.6234639232706 62.226433795409946 58.22427967678224 77.04028052162661 60.242351343274315 49.935782034423966 64.92333835905463 76.25914794696986 57.75716807718398 59.3518298485441 73.46456460599727 49.268957516975526 63.273184262970645 48.17733141094097 57.07268064914795 50.153499711128475 61.78172979569604 69.21493309503023 92.7458015996151 48.596433598424554 49.17297925381688 190.76689172946587 55.40911076418436 61.03918062254213 49.571973849799825 47.0054990570597 50.718715510190506 118.75889906744456 66.06416132350127 54.500264639755876 56.939758021587636 73.70485166494767 45.505004535528755 54.04997859757909 45.29029270166923 72.4573367902132 65.4102917176478 49.095263997229495 66.3281742777065 51.88234145508545 62.44679542020562 76.95135350000088 86.89675220962171 71.72813560891247 58.99129931916116 65.79687971381728 57.9820576504473 63.35721742540222 53.50205072945805 62.24627277899779 6 | 68.95428714974298 55.625569310591885 43.35585401221154 45.63168132712526 58.24549158958586 57.68474092293874 54.0129397760104 74.91445057826073 51.68484750853374 53.92908136961143 49.951624119418014 57.547511835821055 51.680040802069506 68.69577029225003 47.0107501261128 65.52148660850112 71.32329770262538 51.96183453691725 55.48263673794595 43.97562792080455 59.89424275267121 66.80410060766742 122.0712753132598 52.644378483721106 54.56347289611857 56.03649962409028 50.20290516254025 66.86655135316904 51.46208163980092 48.70532010266275 89.97136830601141 49.98272236314841 54.475901006945705 53.67506335917313 56.08666036416735 52.422213962838 7.646529441220522e9 53.09186795527896 66.84219614647462 50.07137377696173 65.37035386490919 61.45582908259704 52.2915280796424 46.723151555851956 63.548468784282974 59.434479955072426 74.96250276691163 57.11306173647407 50.113690089490085 338.06753608276426 7 | 61.18487831824437 50.01066169488574 41.090064549787186 58.777168033887975 67.28320423562428 50.96468117631848 59.23508293238581 68.42503616497206 66.68081829909762 60.81833538100808 63.28061135700797 56.405871723489916 63.60245363624718 59.69649745323674 44.88740654295346 55.11525011423602 54.62507926916816 46.709885804176984 53.38383249494028 62.7250907153421 57.39357010934234 66.79209367027826 52.84987356364662 46.38484179490982 52.65120986513817 50.760854207464206 63.981527638072116 60.880997680294236 50.624234712266954 70.20571100838454 56.20640530687882 61.772296183754385 65.64102315485775 63.950674897529375 61.488357762194305 51.08075214810151 60.584543697643554 81.54686523491783 66.40505671741575 61.92555531513387 65.93907945077058 52.253064526622374 44.82774622674369 46.4724407217882 58.646212202187506 65.65241539410405 65.75129104511682 63.29668811774665 61.31185405611941 68.41056565045191 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/normxrobTs.txt: -------------------------------------------------------------------------------- 1 | 58.05375519999822 51.07033275602941 65.74091725835379 71.3289523050542 51.117863524941114 66.09772313521096 60.13910581981348 50.98874171360706 55.16182254099824 52.24761611747203 60.13583023330789 88.73753431681536 79.86094316277013 42.2418384379174 49.473447478615626 60.231962348553054 44.646875918082316 51.332571302108356 54.859725138784285 42.97514288618242 67.51968175216241 65.76039010275441 84.26663737865869 53.786688791269796 60.03000994660623 61.44790951313036 43.440322949195874 67.35047091752878 49.30345514207251 74.51200462346682 60.18861949116631 49.347828288534146 59.19608203272252 57.04153314317379 54.68739881806947 64.34446877184169 71.61261928690904 51.14873724001945 60.73311299326739 65.36763861441615 113.87662001032679 62.11312396026741 71.14181920109341 58.954000760064794 43.96033581647552 64.5048038538733 82.18182505983766 56.54200219457188 63.10504397306373 50.53238316711842 2 | 51.25764316948419 67.83752547452444 47.23523086222117 77.99079733769092 43.41891634167141 53.802657865646 50.88820546575757 51.44927715146345 47.59333721591996 63.37867390611266 40.74677823349667 61.68525513397557 54.08448503593519 62.543106368185796 67.44453729574202 53.12886732195183 52.67284035026654 82.71904887645495 64.13944681254415 53.42044977880463 77.19650852199658 80.99619253964985 55.552008329257404 50.671417727711095 77.23801929057126 47.69146277512537 60.85886782981055 41.324264781770765 59.16165011020788 57.78501864866342 57.84226000508506 98.61407543893938 49.19846045262518 62.654772332796455 48.41875730042727 67.98764740775314 61.90553937847339 67.14885004507705 65.15779222640644 63.33555470054929 42.237791805236206 92.4431126798428 51.22737435608939 45.946589401040605 97.11037861371983 69.25492994969503 59.8292892554819 65.78879367255213 61.377780067992305 49.72608210846866 3 | 49.51903465650542 55.269689839087825 74.8272285340202 58.194659021132104 50.11907293266535 62.391829346397394 50.63457935596746 63.77916617750131 72.52162836019126 54.28807630801504 43.405816420059686 43.29288792721694 72.66873380304204 57.81004371336965 56.38003701458156 50.17701036538047 57.2273415616099 44.514379897164474 66.57354185438574 48.93804734467887 47.33082775430276 55.91810437861798 56.62410638367661 71.84293910505012 57.60076065840781 55.1055117168294 65.06031106074134 76.212180648128 47.582202327153084 63.704337598823905 43.748485316168484 71.48095954680103 54.0680705155401 65.42992240930404 59.07289386109569 68.84787018852136 49.784797665873214 42.6688483396063 71.12092857697468 64.35219810956622 64.64185469534692 55.50513379821225 62.78484589020392 64.03894191310403 65.36305285647416 46.84687057895389 51.63283878941662 56.745052998649896 53.831464493408326 5.082894716093195e15 4 | 45.771078025203416 73.54626623768254 67.28830954810043 58.745456475429506 61.77876821856396 69.4402795437527 56.496990488720385 51.77474931715054 51.16476701607692 61.85854986588812 54.75204766055399 53.40342789553828 59.23124540771646 65.80280896616027 50.23997574979717 56.93579643697875 56.519191407558985 57.707956708926886 55.88124240651563 52.32062758216044 55.40619729995145 54.37657999910652 99.2491169254317 43.606316574786 58.234071244753885 51.346044011793005 65.82091168292989 47.79326607004249 53.922494820303626 50.025442975752945 69.60887361623173 58.18569793363024 62.20543467654983 54.45648669920531 67.86567193708338 51.181111273055855 61.557171712831206 59.711561406834626 44.75053998286831 49.20863438679531 70.15505324703345 50.19329937877696 52.28910222140458 61.95384824135544 56.45322454831548 49.37379999966947 60.576212204476874 52.58080369692429 57.08180424319058 61.43377113966525 5 | 141.25201767995114 59.59420766021997 51.33382305056377 82.9967142698511 56.974483570237865 51.01051126209181 50.713538974371566 67.90982731152506 44.59760960302947 68.64526411095432 64.06027596230041 55.947448922346695 52.72643200805203 54.32927723514678 64.37277584681318 50.573250239423786 71.21910980716879 96.76097265745334 95.0298294754722 45.81382506054498 52.24995462375178 141.83907530204092 56.088448818185235 57.286799487374594 49.97207287860255 43.91346331397571 50.85104510671979 90.13554045554874 72.0780692305256 52.84721886906792 47.112632296395375 70.4186880932176 50.206189348250135 59.93988211655377 49.24808526434539 64.81604448475997 67.17289544262165 46.3530217263207 72.49725377638289 48.68479643028725 60.096946779220495 69.93170282373035 59.69710639380725 62.60894256182346 70.17188158938144 57.80600420391899 56.83844905848557 64.66526107374689 53.725042027511044 58.16468330672323 6 | 68.1258283035649 65.72368141012855 50.29915551787739 52.93860859231283 62.85988841931592 50.99259361852892 59.08468340876669 106.38683886749911 45.51358819668559 58.9410242535935 59.55971867261924 69.73897389106729 57.83447073464894 53.86813351726512 45.150056235674754 56.98710810225406 57.148158633038356 61.909454490671294 60.67572229465595 48.36146525459515 63.969812213160786 56.393829065746054 133.7856567092805 61.82654757830985 49.32656504904899 53.74423558339015 47.43490575903723 61.97145015423094 57.99628143958053 57.99229106514307 88.09632491053522 72.924464746257 67.493402604616 59.22934467937244 53.25927097286575 59.97718574271551 3.378707960496724e7 54.54872566815953 45.796877370411714 50.54253888159132 78.12124912241245 61.448303030274175 59.15483760690679 42.458858121950946 59.52814819963244 86.05598341443172 68.08774700143823 53.72918474246711 45.25560459396565 79.43150244735536 7 | 52.39310555747344 62.78973011440075 42.56334298273358 57.47584064892363 61.806539764449596 53.67136480098639 60.569185115107004 55.30428960328796 60.51451201350349 58.52167802605316 58.97255263116859 62.67809114289195 61.964062485411795 60.85797208504689 45.299086513852004 55.13570647773951 59.42826143084572 59.45558885743024 70.90423868484598 60.16688821048574 53.61097349127321 60.31895125254399 43.73014694954585 54.95907561903183 54.91776303393514 53.40006564288068 53.535563635462914 52.12879018766512 46.03150613568595 84.76889020411208 57.55092669725815 49.574528263850326 69.60808016423584 56.75629124174517 55.549014985487496 58.282446692613405 70.45597817161952 70.01056200577933 55.757975018704784 52.773060331707434 53.66442188345805 60.09383128252711 47.72158724462195 47.07132288536712 48.98425347907241 70.00941496691198 68.80838966609494 59.81867445612295 55.37338637947416 61.08161275481093 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/normxstars.txt: -------------------------------------------------------------------------------- 1 | 62.67211133455305 73.175238548871 64.60379427622193 70.20400249838406 77.38099073814615 66.09773518232787 68.05485777936882 64.86048764219085 66.52069977523956 63.633233908507115 59.519697112122664 66.3176944557944 63.79196426769108 75.57018891917431 64.06587422000574 70.34334311695882 69.91376518118516 50.29054920285329 71.05051193974694 66.25379559625571 67.5242108392795 62.960449859911385 68.82908735619601 67.41780631836308 59.58284484149614 71.93202662269408 74.21968639940337 69.74749859240808 69.33344947135247 66.01067549417165 62.34281732446298 66.29958382236924 75.52897059008455 73.0437585024919 70.67648602484624 60.97104736565832 65.8589792107458 65.43231430365316 64.96318251596435 60.05921969976653 59.0143650652317 61.249412099508035 77.16809550405372 64.60112740566554 68.42965783334739 70.39119045228236 66.57968073601228 64.28636665511347 65.44439999417204 68.9119524617871 2 | 78.70125300633141 63.11548232025913 71.38512713095984 73.21393005302693 69.20650687450883 68.15109543967688 71.92934386079632 63.519196334338446 70.24663904603965 63.693752776264745 64.5631295309652 67.7989595144783 66.68906996036291 69.62170242364714 62.315630231539046 64.0319455043393 65.28492117385865 63.970224336839195 64.0282473515789 63.18580695990036 70.81678552750664 69.05730910793605 65.43069021411978 68.45641425280424 58.0374116847738 66.17593974472244 72.70191211802911 65.2615246535859 64.16666842793998 69.05713665385987 70.42200077227176 65.86238650412892 61.873026486577125 64.92830813114345 65.85926304180661 64.83946263653426 70.44244609855878 65.97369194649531 64.06274107639781 65.78872467363922 71.59709445900896 77.04786085362741 63.852868459012875 68.17021529445051 74.60654421115541 63.46702941546504 70.22486163375851 59.23978261881855 74.25176966730788 74.43433250045656 3 | 65.52033298636219 68.73149928398375 70.48310299639495 65.78107060315601 65.23627461442072 61.74496031913445 78.34982374789443 65.1493726174206 79.33657191040234 72.31278276055745 62.46530568291858 67.7244668222502 72.54707367916386 65.61333172059409 63.5267711197126 63.76216320423605 65.77650796950532 58.487299599538666 63.136571993290275 63.202284965080075 70.18979043014261 65.39344641200663 62.856191290015076 73.12985482324719 71.47736456256982 63.87158966375343 72.4963729452308 65.68912253889457 59.67058020959748 56.974352965333814 62.86981190832038 61.15692186425923 61.68539630620676 68.56301069751427 73.05670320672384 63.7443199032322 70.22771624243052 60.76010555899508 64.1711063432591 61.83915600926922 64.39797069475493 58.207783282252805 63.09186721860887 68.55350842225988 62.22522864986171 54.23801339242874 62.32137833624526 68.39739782795638 71.80197465649049 58.34550635736672 4 | 64.18850566893282 66.13656027295445 69.86233686542677 61.02529214383989 69.81530944419607 74.58003805027707 65.53010972405485 73.8540425668869 63.31071986747327 67.9713737250795 71.02964915343593 65.25862598573292 66.32246182952228 64.97613300638551 68.8048585911173 70.95141750435415 68.16911358210577 59.26506537593256 61.71720794557854 69.51659309719467 66.55608016720099 65.43069140211988 60.47853507741897 70.12934786933603 66.24108969608595 57.45255605971149 68.78139576265028 62.2492895390261 68.16141725822003 60.995175216159744 69.89402434798231 61.58019689527678 58.1979275763809 60.57633253582597 64.02475588071022 70.54204454578195 69.57092771816095 70.71593541962382 64.60441558171271 64.71127108053453 66.43306965956167 71.75450359807047 60.74074017803316 89.28144077014721 71.58020177367915 66.93164646277147 60.12288715922195 60.000016084564415 64.14710177172924 67.56708418715951 5 | 67.35783919828565 65.37785777045517 61.496383701965534 65.21739802017781 69.46086332880542 72.55725072216217 63.23004808646389 64.61878294136827 63.234851349465465 69.90461834987 60.92562045097812 62.196372592165126 62.86252900803472 63.56200952887834 63.800292917377746 61.99373476681576 68.260666830712 65.96506676223117 67.83040223509595 69.28649894160054 64.34077694169639 64.92133515927509 74.80895377619424 65.89117010682374 61.33661875408089 64.72476066630827 59.229100985126294 69.01475606433208 68.51860009068776 71.61520193468687 61.37149485407105 66.91580170736584 60.34692575238486 62.30552947413343 64.87600422432209 66.87669905861152 66.61261180862392 68.03404068026678 65.38025016880228 57.96490973766273 66.79924474402381 60.975562699232384 62.16601851152292 60.070160252008996 66.91597053091635 66.35912185355245 67.93796192923975 62.923510250229675 64.9782962343757 68.33201900707174 6 | 57.26993579453431 69.49551406288519 63.79918299974368 68.62831846951713 61.33069276374071 66.77087289439855 57.83981791298868 73.06587133080187 68.66560292707908 62.13501485331245 69.64701475040498 67.1465712210696 62.915093822635775 62.79492229643974 71.0315580614332 60.85127269583679 59.76535605564753 74.37391044157255 59.977883637801334 71.83118879222869 62.44646873453436 59.74265658840298 66.97641845933536 75.33448916591158 71.88617946397179 67.84446532635695 57.85189944701853 65.76278139074384 63.477005388242794 59.96308039727834 66.98207606234264 59.440590615577534 63.46824778796778 63.88925740011549 64.0520097879517 70.50082218314431 73.48794089616803 63.808911598692625 61.12164532831685 60.14662164002383 73.67759051165869 71.89103149655958 68.8671070825298 65.56975129497583 65.97669209390943 64.63397752351057 73.6334006310391 67.30259149502567 63.85581690290937 63.253606196448 7 | 62.9767606633619 71.58716164223041 67.75905417760742 60.667473227594485 69.09166150850308 63.56271184249329 70.48309565426564 76.30740574216304 64.29693805750156 61.23861862534844 62.966142861221314 63.203843037831426 61.989500521206395 77.33806444983934 61.326179644891035 66.40873561024053 62.883902875657895 61.445687717021706 67.48267921701466 72.06602438721463 63.01558177185561 66.04853071163119 60.04370790599589 71.03476181328463 65.60767270677815 55.97756466440567 66.30085996606022 63.70102725307116 58.94675003245939 66.75644020242761 56.439520937099836 67.25271248699627 66.44660233351462 66.42650673577874 69.85103622432584 64.10979632163381 67.59453435244944 70.85800989213871 59.86379585594861 71.46781509618927 66.5975553311157 64.25182388814935 64.43001092993224 61.32491733942138 63.3753150062457 74.08416443745185 67.55697455273288 62.10522690341592 72.92362779679914 65.54601669520517 8 | -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/unorms.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2021_L4DC_DataDriven-SLS/experiments/unorms.png -------------------------------------------------------------------------------- /2021_L4DC_DataDriven-SLS/experiments/xnorms.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2021_L4DC_DataDriven-SLS/experiments/xnorms.png -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig1_Optimality/plot_optimality.m: -------------------------------------------------------------------------------- 1 | env_name = 'chain'; 2 | load(strcat('../results/optimality_', env_name)); 3 | 4 | color_distributed = [0.4660 0.6740 0.1880]; 5 | color_centralized = [0.8500 0.3250 0.0980]; 6 | 7 | %% Plot 8 | figure(1) 9 | 10 | % Plot dlmpc trajectory 11 | subplot(1,2,1); 12 | plot(1:Tsim+1,x_cent(1,:),'-', 'LineWidth', 4, ... 13 | 'MarkerSize', 6, 'Color', color_centralized, 'MarkerFaceColor', ... 14 | color_centralized) 15 | hold on 16 | plot(1:Tsim+1,x_ddd(1,:), 's', 'LineWidth', 4, ... 17 | 'MarkerSize', 6, 'Color', color_distributed, 'MarkerFaceColor', ... 18 | color_distributed) 19 | 20 | xlabel('Time','interpreter','latex','Fontsize', 18) 21 | ylabel('$$\theta_{1}$$','Interpreter','Latex','Fontsize', 18) 22 | leg1 = legend('Model-based','Alg. 1'); 23 | set(leg1,'Interpreter','latex'); set(leg1, 'Fontsize', 15) 24 | 25 | subplot(1,2,2); 26 | plot(1:Tsim+1,x_cent(2,:),'-', 'LineWidth', 4, ... 27 | 'MarkerSize', 6, 'Color', color_centralized, 'MarkerFaceColor', ... 28 | color_centralized) 29 | hold on 30 | plot(1:Tsim+1,x_ddd(2,:), 's', 'LineWidth', 4, ... 31 | 'MarkerSize', 6, 'Color', color_distributed, 'MarkerFaceColor', ... 32 | color_distributed) 33 | xlabel('Time','interpreter','latex','Fontsize', 18) 34 | ylabel('$$\omega_{1}$$','Interpreter','Latex','Fontsize', 18) 35 | leg1 = legend('Model-based','Alg. 1'); 36 | set(leg1,'Interpreter','latex'); set(leg1, 'Fontsize', 15) 37 | 38 | 39 | sgtitle('\textbf{Evolution of System Trajectory}','Interpreter','Latex',... 40 | 'Fontsize', 20); 41 | %% Save the figure 42 | ax = gcf; 43 | exportgraphics(ax, strcat('~/Desktop/optimality_', env_name, '.png')); -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig1_Optimality/script_optimality.m: -------------------------------------------------------------------------------- 1 | addpath('../lib/') 2 | %% Parameters 3 | clc; clear all; close all; 4 | locality = 2; % this is between subsystems 5 | network = 64; 6 | prob = 0.4; 7 | Ts = .1; % Time step for discretization 8 | T = 5; % Time horizon (FIR) 9 | Tsim = 30; % Simulation time 10 | 11 | env_name = 'chain'; 12 | if strcmp(env_name, 'chain') 13 | rho = 8000 / network; 14 | else 15 | rho = 2000 / network; 16 | end 17 | 18 | %% Plant dynamics 19 | if strcmp(env_name, 'chain') 20 | rng(2021) 21 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.chain(network); 22 | else 23 | rng(2021) 24 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.grid(network, prob); 25 | end 26 | x0 = rand(Nx,1); 27 | d = locality; 28 | 29 | N = network; 30 | row_mask = cell(N); 31 | x_column_mask = cell(N); 32 | u_column_mask = cell(N); 33 | max_patch_size = 0; 34 | for i=1:N 35 | x_row_mask = data_driven_lib.patch_mask(A, d, p, p, i); 36 | u_row_mask = data_driven_lib.patch_mask(A, d+1, p, q, i); 37 | row_mask{i} = [repmat(x_row_mask, T, 1); repmat(u_row_mask, T, 1)]; 38 | x_column_mask{i} = data_driven_lib.patch_mask(A, d, p, p, i); 39 | u_column_mask{i} = data_driven_lib.patch_mask(A, d+1, p, p, i); 40 | if sum(u_row_mask) > max_patch_size 41 | max_patch_size = sum(u_row_mask); 42 | end 43 | end 44 | 45 | %% Centralized SLS 46 | x_cent = zeros(Nx, Tsim+1); 47 | u_cent = zeros(Nu, Tsim+1); 48 | x_cent(:,1) = x0; 49 | for k = 1:Tsim 50 | clear LocalityR LocalityM 51 | xi = x_cent(:, k); 52 | [X, R, M] = cent_opt(A, B, p, q, Q, S, T, d, xi); 53 | % dynamics 54 | u_cent(:,k) = M(1:Nu, :)*xi; % control action 55 | x_cent(:, k+1) = A * xi + B * u_cent(:,k); 56 | end 57 | 58 | %% Distributed data-driven SLS 59 | [Hx, Hu, Hb] = data_driven_lib.subsystem_hankel(A, B, p, q, d, T); 60 | x_ddd = zeros(Nx, Tsim+1); 61 | u_ddd = zeros(Nu, Tsim+1); 62 | x_ddd(:,1) = x0; 63 | Psi_warm = zeros((Nx+Nu)*T, Nx); 64 | t_ddd = zeros(Tsim, 1); 65 | 66 | Phi_prev = Psi_warm; 67 | Phi_curr = Psi_warm; 68 | for k = 1:Tsim 69 | xi = x_ddd(:, k); 70 | [R, M, ti] = ddd(Hx, Hu, Hb, A, B, Q, S, T, d, p, q, xi, rho, ... 71 | row_mask, x_column_mask, u_column_mask, max_patch_size, Psi_warm); 72 | t_ddd(k) = ti; 73 | Psi_warm = [R; M]; 74 | % dynamics 75 | u_ddd(:,k) = M(1:Nu, :)*xi; % control action 76 | x_ddd(:, k+1) = A * xi + B * u_ddd(:,k); 77 | end 78 | 79 | %% Cost 80 | obj_cent=0; 81 | obj_ddd = 0; 82 | for t =1:Tsim 83 | obj_cent = obj_cent + x_cent(:,t)'*Q*x_cent(:,t)+... 84 | u_cent(:,t)'*S*u_cent(:,t); 85 | obj_ddd = obj_ddd + x_ddd(:,t)'*Q*x_ddd(:,t)+... 86 | u_ddd(:,t)'*S*u_ddd(:,t); 87 | end 88 | obj_cent = obj_cent + x_cent(:,t+1)'*Q*x_cent(:,t+1); 89 | obj_ddd = obj_ddd + x_ddd(:,t+1)'*Q*x_ddd(:,t+1); 90 | 91 | %% Save data 92 | save(strcat('../results/optimality_', env_name)) 93 | 94 | -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig2_cost_locality/plot_cost_locality.m: -------------------------------------------------------------------------------- 1 | env_name = 'chain'; 2 | load(strcat('../results/cost_locality_', env_name)); 3 | 4 | %% Plotting 5 | color_distributed = [0.4660 0.6740 0.1880]; 6 | color_cent = [0 0.1059 0.6392]; 7 | 8 | figure(1) 9 | plot(1:5, costs, '-s', 'LineWidth', 4, ... 10 | 'MarkerSize', 12, 'Color', color_distributed, 'MarkerFaceColor', ... 11 | color_distributed); 12 | hold on 13 | plot(1:5, ones(5, 1)* obj_cent, '--', 'LineWidth', 4, 'Color', color_cent); 14 | xlabel('Locality $$d$$','interpreter','latex','Fontsize', 18) 15 | ylabel('Cost','Interpreter','Latex','Fontsize', 18) 16 | 17 | leg1 = legend('DLMPC','Cent. MPC'); 18 | set(leg1,'Interpreter','latex'); set(leg1, 'Fontsize', 18) 19 | 20 | title('\textbf{Cost vs. Locality}','Interpreter','Latex',... 21 | 'Fontsize', 20) 22 | 23 | %% Save the figure 24 | ax = gca; 25 | exportgraphics(ax, strcat('~/Desktop/cost_locality_', env_name, '.png')); -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig2_cost_locality/script_cost_locality.m: -------------------------------------------------------------------------------- 1 | addpath('../lib/') 2 | %% Parameters 3 | %clc; clear all; close all; 4 | network = 64; 5 | prob = 0.4; 6 | Ts = .1; % Time step for discretization 7 | T = 5; % Time horizon (FIR) 8 | Tsim = 30; % Simulation time 9 | 10 | env_name = 'chain'; 11 | if strcmp(env_name, 'chain') 12 | rho = 8000 / network; 13 | else 14 | rho = 2000 / network; 15 | end 16 | 17 | %% Plant dynamics 18 | if strcmp(env_name, 'chain') 19 | rng(2021); 20 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.chain(network); 21 | else 22 | rng(2021); 23 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.grid(network, prob); 24 | end 25 | x0 = rand(Nx,1); 26 | N = network; 27 | 28 | %% Solve for centralized cost 29 | x_cent = zeros(Nx, Tsim+1); 30 | u_cent = zeros(Nu, Tsim+1); 31 | x_cent(:,1) = x0; 32 | for k = 1:Tsim 33 | clear LocalityR LocalityM 34 | xi = x_cent(:, k); 35 | [X, R, M] = centralized(A, B, p, q, Q, S, T, d, xi); 36 | % dynamics 37 | u_cent(:,k) = M(1:Nu, :)*xi; % control action 38 | x_cent(:, k+1) = A * xi + B * u_cent(:,k); 39 | end 40 | % Cost 41 | obj_cent = 0; 42 | for t =1:Tsim 43 | obj_cent = obj_cent + x_cent(:,t)'*Q*x_cent(:,t)+... 44 | u_cent(:,t)'*S*u_cent(:,t); 45 | end 46 | obj_cent = obj_cent + x_cent(:,t+1)'*Q*x_cent(:,t+1); 47 | 48 | %% Solve over increasing locality 49 | costs = zeros(5, 1); 50 | 51 | for d=1:5 52 | row_mask = cell(N); 53 | x_column_mask = cell(N); 54 | u_column_mask = cell(N); 55 | max_patch_size = 0; 56 | for i=1:N 57 | x_row_mask = data_driven_lib.patch_mask(A, d, p, p, i); 58 | u_row_mask = data_driven_lib.patch_mask(A, d+1, p, q, i); 59 | row_mask{i} = [repmat(x_row_mask, T, 1); repmat(u_row_mask, T, 1)]; 60 | x_column_mask{i} = data_driven_lib.patch_mask(A, d, p, p, i); 61 | u_column_mask{i} = data_driven_lib.patch_mask(A, d+1, p, p, i); 62 | if sum(u_row_mask) > max_patch_size 63 | max_patch_size = sum(u_row_mask); 64 | end 65 | end 66 | 67 | % Distributed data-driven SLS 68 | [Hx, Hu, Hb] = data_driven_lib.subsystem_hankel(A, B, p, q, d, T); 69 | x_ddd = zeros(Nx, Tsim+1); 70 | u_ddd = zeros(Nu, Tsim+1); 71 | x_ddd(:,1) = x0; 72 | Psi_warm = zeros((Nx+Nu)*T, Nx); 73 | t_ddd = zeros(Tsim, 1); 74 | 75 | Phi_prev = Psi_warm; 76 | Phi_curr = Psi_warm; 77 | for k = 1:Tsim 78 | xi = x_ddd(:, k); 79 | [R, M, ti] = ddd(Hx, Hu, Hb, A, B, Q, S, T, d, p, q, xi, rho, ... 80 | row_mask, x_column_mask, u_column_mask, max_patch_size, Psi_warm); 81 | t_ddd(k) = ti; 82 | Psi_warm = [R; M]; 83 | % dynamics 84 | u_ddd(:,k) = M(1:Nu, :)*xi; % control action 85 | x_ddd(:, k+1) = A * xi + B * u_ddd(:,k); 86 | end 87 | 88 | % Cost 89 | obj_ddd = 0; 90 | for t =1:Tsim 91 | obj_ddd = obj_ddd + x_ddd(:,t)'*Q*x_ddd(:,t)+... 92 | u_ddd(:,t)'*S*u_ddd(:,t); 93 | end 94 | obj_ddd = obj_ddd + x_ddd(:,t+1)'*Q*x_ddd(:,t+1); 95 | costs(d) = obj_ddd; 96 | end 97 | 98 | %% Save data 99 | save(strcat('../results/cost_locality_', env_name)) 100 | 101 | -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig3_tl_d/plot_tl_d.m: -------------------------------------------------------------------------------- 1 | %% Trajectory Length vs. Locality Size 2 | 3 | env_name = 'chain'; 4 | load(strcat('../results/tl_d_', env_name)); 5 | color_distributed = [0.4660 0.6740 0.1880]; 6 | 7 | plot((d_min:d_max), mean(d_tl, 2), '-s', 'LineWidth', 4, ... 8 | 'MarkerSize', 12, 'Color', color_distributed, 'MarkerFaceColor', ... 9 | color_distributed); 10 | xlabel('Locality $$d$$','interpreter','latex','Fontsize', 18) 11 | ylabel('Trajectory Length','Interpreter','Latex','Fontsize', 18) 12 | title('\textbf{Amount of data vs. Locality}','Interpreter','Latex',... 13 | 'Fontsize', 20) 14 | %% Save the figure 15 | ax = gcf; 16 | exportgraphics(ax, strcat('~/Desktop/tl_d_', env_name, '.png')); 17 | 18 | -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig3_tl_d/script_tl_d.m: -------------------------------------------------------------------------------- 1 | addpath('../lib/') 2 | clear; clc; 3 | 4 | prob = 0.4; 5 | d_min = 1; 6 | d_max = 5; 7 | network = 64; 8 | T = 5; 9 | 10 | env_name = 'chain'; 11 | iter = 1; 12 | d_tl = zeros(d_max-d_min+1, network * iter); 13 | 14 | for ii=1:iter 15 | if strcmp(env_name, 'chain') 16 | rng(2021); 17 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.chain(network); 18 | else 19 | rng(2021); 20 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.grid(network, prob); 21 | end 22 | for d=d_min:d_max 23 | d_tl(d-d_min+1, (ii-1)*network+1:ii*network) = ... 24 | data_driven_lib.find_traj_length(A, p, q, d, T); 25 | end 26 | end 27 | 28 | %% Save data 29 | save(strcat('../results/tl_d_', env_name)); -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig4_runtime/plot_scalability.m: -------------------------------------------------------------------------------- 1 | env_name = 'chain'; 2 | fn = strcat('../results/scalability_', env_name); 3 | load(fn); 4 | 5 | %% Process Data 6 | for num = 1:length(networks) 7 | avg(num) = mean(times(num,:)); 8 | stnd(num) = std(times(num,:)); 9 | 10 | lower_curve(num) = avg(num)-stnd(num); 11 | upper_curve(num) = avg(num)+stnd(num); 12 | end 13 | 14 | color = [0.4660 0.6740 0.1880]; 15 | 16 | %% Plot 17 | figure(1) 18 | 19 | 20 | semilogy(networks, avg, '-s', 'LineWidth', 4, 'MarkerSize', 12, ... 21 | 'Color', color, 'MarkerFaceColor', color); 22 | hold on 23 | 24 | h = fill([networks,fliplr(networks)], [lower_curve,fliplr(upper_curve)],color); 25 | alpha(.4) 26 | set(h,'edgecolor','white') 27 | 28 | semilogy(networks, avg, '-s', 'LineWidth', 4, 'MarkerSize', 12, ... 29 | 'Color', color, 'MarkerFaceColor', color); 30 | 31 | xlabel('Network Size','interpreter','latex','Fontsize', 18) 32 | ylabel('Time(s)','Interpreter','Latex','Fontsize', 18) 33 | ylim([0.03 0.1]); 34 | 35 | title('\textbf{Runtime vs. network size}','Interpreter','Latex','Fontsize', 20) 36 | 37 | %% Save the figure 38 | ax = gca; 39 | exportgraphics(ax, strcat('~/Desktop/scalability_',env_name, '.png')); -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig4_runtime/script_scalability.m: -------------------------------------------------------------------------------- 1 | addpath('../lib/') 2 | %% Parameters 3 | clc; clear all; close all; 4 | locality = 2; % this is between states, not subsystems 5 | prob = 0.4; 6 | Ts = .1; % Time step for discretization 7 | T = 5; % Time horizon (FIR) 8 | Tsim = 30; % Simulation time 9 | 10 | % The number of subsystems 11 | networks = [9 16 36 64 81 100 121]; 12 | env_per_size = 10; 13 | times = zeros(length(networks), env_per_size); 14 | rng(2020) 15 | 16 | exp_env = 'chain'; 17 | 18 | %% Experiment 19 | for num=1:length(networks) 20 | networks(num) 21 | for ee=1:env_per_size 22 | if strcmp(exp_env, 'chain') 23 | [Nx, Nu, p, q, A, B, Q, S] = environment.chain(... 24 | networks(num)); 25 | rhos = 8000 ./ networks; 26 | else 27 | [Nx, Nu, p, q, A, B, Q, S] = environment.grid(... 28 | networks(num), prob); 29 | rhos = 2000 ./ networks; 30 | end 31 | x0 = rand(Nx,1); 32 | d = locality; 33 | 34 | % Compute masks (as it's common across all env of this size) 35 | N = networks(num); 36 | row_mask = cell(N); 37 | x_column_mask = cell(N); 38 | u_column_mask = cell(N); 39 | max_patch_size = 0; 40 | for i=1:N 41 | x_row_mask = data_driven_lib.patch_mask(A, d, p, p, i); 42 | u_row_mask = data_driven_lib.patch_mask(A, d+1, p, q, i); 43 | row_mask{i} = [repmat(x_row_mask, T, 1); repmat(u_row_mask, T, 1)]; 44 | x_column_mask{i} = data_driven_lib.patch_mask(A, d, p, p, i); 45 | u_column_mask{i} = data_driven_lib.patch_mask(A, d+1, p, p, i); 46 | if sum(u_row_mask) > max_patch_size 47 | max_patch_size = sum(u_row_mask); 48 | end 49 | end 50 | 51 | % Simulate 52 | [Hx, Hu, Hb] = data_driven_lib.subsystem_hankel(A, B, p, q, d, T); 53 | x_ddd = zeros(Nx, Tsim+1); 54 | u_ddd = zeros(Nu, Tsim+1); 55 | x_ddd(:,1) = x0; 56 | Psi_warm = zeros((Nx+Nu)*T, Nx); 57 | t_ddd = zeros(Tsim, 1); 58 | 59 | Phi_prev = Psi_warm; 60 | Phi_curr = Psi_warm; 61 | for k = 1:Tsim 62 | xi = x_ddd(:, k); 63 | [R, M, ti] = ddd(Hx, Hu, Hb, A, B, Q, S, T, d, p, q, xi, ... 64 | rhos(num), row_mask, x_column_mask, u_column_mask, ... 65 | max_patch_size, Psi_warm); 66 | t_ddd(k) = ti; 67 | Psi_warm = [R; M]; 68 | % dynamics 69 | u_ddd(:,k) = M(1:Nu, :)*xi; % control action 70 | x_ddd(:, k+1) = A * xi + B * u_ddd(:,k); 71 | end 72 | times(num, ee) = mean(t_ddd(2:end)); 73 | mean(t_ddd(2:end)) 74 | end 75 | end 76 | 77 | %% Save data 78 | save(strcat('../results/scalability_', exp_env)); 79 | 80 | 81 | 82 | -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig5_tl_network/plot_tl_net.m: -------------------------------------------------------------------------------- 1 | %% Trajectory Length vs. Network Size 2 | env_name = 'chain'; 3 | load(strcat('../results/tl_net_', env_name)); 4 | 5 | color_distributed = [0.4660 0.6740 0.1880]; 6 | color_centralized = [0.8500 0.3250 0.0980]; 7 | 8 | % Plot the centralized trajectory length growth 9 | semilogy((nn_min:nn_max).^2, centralized_tl, '-s', 'LineWidth', 4, ... 10 | 'MarkerSize', 12, 'Color', color_centralized, 'MarkerFaceColor', ... 11 | color_centralized); 12 | hold on 13 | 14 | % Plot the distributed traj length growth 15 | ddd_tl_array = zeros(length(ddd_tl), 1); 16 | for i=1:length(ddd_tl) 17 | ddd_tl_array(i) = mean(ddd_tl{i}); 18 | end 19 | semilogy((nn_min:nn_max).^2, ddd_tl_array, '-s', 'LineWidth', 4, ... 20 | 'MarkerSize', 12, 'Color', color_distributed, 'MarkerFaceColor', ... 21 | color_distributed); 22 | 23 | xlabel('Network Size','interpreter','latex','Fontsize', 18) 24 | ylabel('Past trajectory length','Interpreter','Latex','Fontsize', 18) 25 | 26 | leg1 = legend('Centralized','Distributed'); 27 | set(leg1,'Interpreter','latex'); set(leg1, 'Fontsize', 15); 28 | set(leg1,'Location','northwest'); 29 | 30 | title('\textbf{Amount of data vs. network size}','Interpreter','Latex',... 31 | 'Fontsize', 20) 32 | 33 | %% Save the figure 34 | ax = gcf; 35 | exportgraphics(ax, strcat('~/Desktop/tl_network_', env_name, '.png')); -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/Fig5_tl_network/script_tl_net.m: -------------------------------------------------------------------------------- 1 | addpath('../lib/') 2 | clear; clc; 3 | 4 | prob = 0.4; 5 | nn_min = 3; 6 | nn_max = 15; 7 | T = 5; 8 | d = 2; 9 | 10 | env_name = 'chain'; 11 | iter = 1; % iter should be higher for grid since topology is random 12 | 13 | centralized_tl = zeros(nn_max-nn_min+1, 1); 14 | ddd_tl = cell(nn_max-nn_min+1, 1); 15 | for nn = nn_min:nn_max 16 | network = nn^2; 17 | if strcmp(env_name, 'chain') 18 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.chain(network); 19 | else 20 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.grid(network, prob); 21 | end 22 | centralized_tl(nn-nn_min+1) = (Nx + T) * (Nu + 1) - 1; 23 | for ii=1:iter 24 | if strcmp(env_name, 'chain') 25 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.chain(network); 26 | else 27 | [Nx, Nu, p, q, A, B, Q, S, Adj] = environment.grid(network, prob); 28 | end 29 | ddd_tl{nn-nn_min+1} = [ddd_tl{nn-nn_min+1}; ... 30 | data_driven_lib.find_traj_length(A, p, q, d, T)]; 31 | end 32 | end 33 | 34 | %% Save result 35 | save(strcat('../results/tl_net_', env_name)); -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/README.md: -------------------------------------------------------------------------------- 1 | This folder hosts the code needed to reproduce the examples in the preprint "C. Amo Alonso, F. Yang, and N. Matni. Data-Driven Distributed and Localized Model Predictive Control via System Level Synthesis. Submitted to IEEE Open Journal of Control Systems, 2022" at https://arxiv.org/abs/2112.12229. 2 | 3 | The names of the subfolders correspond to the figure's number that they generate. To run the script, make sure to change the current directory to the one the script is in. 4 | 5 | *Warning*: some of the scripts, in particular the ones concerning runtime measures, might take several hours to run. -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/lib/cent_opt.m: -------------------------------------------------------------------------------- 1 | function [X, R, M] = cent_opt(A, B, p, q, Q, S, T, d, xi) 2 | [Nx, Nu] = size(B); 3 | 4 | cvx_begin quiet 5 | cvx_precision low 6 | variable Px(Nx*T, Nx) 7 | variable Pu(Nu*T, Nx) 8 | 9 | % Objective 10 | vec_xu = vec([Px; Pu] * xi); 11 | objective = vec_xu' * vec_xu; 12 | minimize(objective); 13 | 14 | % Constraints 15 | subject to 16 | Px(1:Nx, :) == eye(Nx); 17 | for t=1:T-1 18 | Px(1+Nx*t : Nx*(t+1), :) == ... 19 | A*Px(1+Nx*(t-1) : Nx*t, :) + B * Pu(1+Nu*(t-1) : Nu*t, :); 20 | end 21 | 22 | network = Nx / p; 23 | for i=1:network 24 | % Locality of state response 25 | x_patch_mask = data_driven_lib.patch_mask(A, d, p, p, i); 26 | u_patch_mask = data_driven_lib.patch_mask(A, d+1, p, q, i); 27 | x_mask = repmat(x_patch_mask, T, 1); 28 | x_mask(1:Nx) = 1; 29 | u_mask = repmat(u_patch_mask, T, 1); 30 | Px(~x_mask, data_driven_lib.subsys_mask(Nx, p, i)) == 0; 31 | Pu(~u_mask, data_driven_lib.subsys_mask(Nx, p, i)) == 0; 32 | 33 | % Start Debug 34 | % x_bb_mask = xor(data_driven_lib.patch_mask(A, d+2, p, p, i),... 35 | % x_patch_mask); 36 | % u_bb_mask = xor(data_driven_lib.patch_mask(A, d+2, p, q, i),... 37 | % u_patch_mask); 38 | % x_bb_mask = repmat(x_bb_mask, T, 1); 39 | % x_bb_mask(1:Nx) = 0; 40 | % u_bb_mask = repmat(u_bb_mask, T, 1); 41 | % Px(x_bb_mask, data_driven_lib.subsys_mask(Nx, p, i)) == 0; 42 | % Pu(u_bb_mask, data_driven_lib.subsys_mask(Nx, p, i)) == 0; 43 | % End Debug 44 | end 45 | cvx_end 46 | 47 | X = 0; 48 | R = Px; 49 | M = Pu; 50 | end 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/lib/centralized.m: -------------------------------------------------------------------------------- 1 | function [X, R, M] = centralized(A, B, p, q, Q, S, T, d, xi) 2 | [Nx, Nu] = size(B); 3 | 4 | cvx_begin quiet 5 | variable Px(Nx*T, Nx) 6 | variable Pu(Nu*T, Nx) 7 | 8 | % Objective 9 | vec_xu = vec([Px; Pu] * xi); 10 | objective = vec_xu' * vec_xu; 11 | minimize(objective); 12 | 13 | % Constraints 14 | subject to 15 | Px(1:Nx, :) == eye(Nx); 16 | for t=1:T-1 17 | Px(1+Nx*t : Nx*(t+1), :) == ... 18 | A*Px(1+Nx*(t-1) : Nx*t, :) + B * Pu(1+Nu*(t-1) : Nu*t, :); 19 | end 20 | cvx_end 21 | 22 | X = 0; 23 | R = Px; 24 | M = Pu; 25 | end 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/lib/data_driven_lib.m: -------------------------------------------------------------------------------- 1 | classdef data_driven_lib 2 | methods ( Static = true ) 3 | function [xtraj, utraj] = generate_traj(A, B, T) 4 | % Generates a trajectory 5 | % get parameters 6 | [Nx, Nu] = size(B); 7 | xtraj = zeros(Nx, T+1); 8 | utraj = zeros(Nu, T); 9 | 10 | % random initial condition 11 | xtraj(:, 1) = randn(Nx, 1); 12 | 13 | % simulate trajectory using (LQR controller + noise) 14 | [~, K, ~] = idare(A, B, eye(Nx), eye(Nu), [], []); 15 | for t = 1:T 16 | x = xtraj(:, t); 17 | u = -K * x + rand(Nu, 1) * 10; 18 | xtraj(:, t+1) = A * x + B * u; 19 | utraj(:, t) = u; 20 | end 21 | end 22 | 23 | function [H] = hankelize(signal, L) 24 | % Hankelize a matrix 25 | % signal - the signal to be converted to Hankel matrix form 26 | % L - the order of the Hankel matrix 27 | [s, T] = size(signal); % s denotes the signal dimension 28 | H = zeros(L*s, T-L+1); 29 | for i=1:L 30 | H((i-1)*s+1:i*s, :) = signal(:, i:T-L+i); 31 | end 32 | end 33 | 34 | function [mask] = patch_mask(A, d, state_dim, sig_dim, i) 35 | % Picking out columns relevant to locality 36 | % signal_dim is the dimension of the desired signal; 37 | % it could be the state, or it could be the control. 38 | A_subsys = data_driven_lib.subsystem_adjacency(A, state_dim); 39 | path_mat = A_subsys^d>0; 40 | patch_subsys = path_mat(:, i); % See which subsystems I affect 41 | mask = logical(kron(patch_subsys, ones(sig_dim, 1))); 42 | 43 | %comms_adj = abs(A)>0; 44 | %localityR = comms_adj^d>0; 45 | %subsystem_rows = (state_dim)*(i-1)+1 : state_dim * i; 46 | %mask = any(localityR(subsystem_rows, :), 1); 47 | end 48 | 49 | function [mask] = control_mask_from_state(p, q, state_mask) 50 | % Get control mask from state mask 51 | [~, Nx] = size(state_mask); 52 | N = Nx / p; 53 | mask = zeros(1, N*q); 54 | for i=1:N 55 | x_ind = p*(i-1)+1 : p*i; 56 | u_ind = q*(i-1)+1 : q*i; 57 | mask(u_ind) = any(state_mask(x_ind), 'all'); 58 | end 59 | mask = logical(mask); 60 | end 61 | 62 | function [sys_adj] = subsystem_adjacency(A, state_dim) 63 | % Find subsystem adjacency matrix 64 | [Nx, ~] = size(A); 65 | num_systems = Nx / state_dim; 66 | sys_adj = zeros(num_systems, num_systems); 67 | for i=1:num_systems 68 | for j=1:num_systems 69 | i_ind = (state_dim)*(i-1)+1 : state_dim * i; 70 | j_ind = (state_dim)*(j-1)+1 : state_dim * j; 71 | sys_adj(i,j) = any(A(i_ind,j_ind) ~= 0, 'all'); 72 | end 73 | end 74 | end 75 | 76 | function [mask] = subsys_mask(joint_dim, subsys_dim, i) 77 | % Get subsystem mask 78 | int_mask = zeros(1, joint_dim); 79 | int_mask(:, (i-1)*(subsys_dim)+1:i*subsys_dim) = 1; 80 | mask = logical(int_mask)'; 81 | end 82 | 83 | function [Hx, Hu, Hb] = sep_subsystem_hankel(A, B, p, q, d, L) 84 | % Sample a hankel matrix for each patch separately 85 | % Preallocate cell array 86 | [Nx, Nu] = size(B); 87 | N = Nx / p; 88 | Hx = cell(N, 1); 89 | Hu = cell(N, 1); 90 | Hb = cell(N, 1); 91 | % construct local hankel matrices 92 | for i=1:N 93 | % global masks 94 | x_mask = data_driven_lib.patch_mask(A, d, p, p, i); 95 | xx_mask = data_driven_lib.patch_mask(A, d+2, p, p, i); 96 | x_bd_mask = xor(x_mask, xx_mask); 97 | u_mask = data_driven_lib.patch_mask(A, d+1, p, q, i); 98 | uu_mask = data_driven_lib.patch_mask(A, d+2, p, q, i); 99 | u_bd_mask = xor(u_mask, uu_mask); 100 | % masks within the patch 101 | x_sub_bd_mask = and(xx_mask, x_bd_mask); 102 | x_sub_bd_mask = x_sub_bd_mask(xx_mask == 1); 103 | x_sub_bd_mask = repmat(x_sub_bd_mask, L, 1); 104 | u_sub_bd_mask = and(uu_mask, u_bd_mask); 105 | u_sub_bd_mask = u_sub_bd_mask(uu_mask == 1); 106 | u_sub_bd_mask = repmat(u_sub_bd_mask, L, 1); 107 | % Collect subsystem trajectory 108 | Ai = A(xx_mask, xx_mask); 109 | Bi = B(xx_mask, uu_mask); 110 | Nx_patch = sum(xx_mask); 111 | Nu_patch = sum(uu_mask); 112 | Ti = (Nx_patch+L) * Nu_patch + Nx_patch + L - 1; 113 | [xtraj, utraj] = data_driven_lib.generate_traj(Ai, Bi, Ti); 114 | % Hankelize 115 | xhank = data_driven_lib.hankelize(xtraj(:, 1:Ti), L); 116 | uhank = data_driven_lib.hankelize(utraj, L); 117 | Hx{i} = xhank(~x_sub_bd_mask, :); 118 | Hu{i} = uhank(~u_sub_bd_mask, :); 119 | Hb{i} = [xhank(x_sub_bd_mask, :); uhank(u_sub_bd_mask, :)]; 120 | end 121 | end 122 | 123 | function [Hx, Hu, Hb] = subsystem_hankel(A, B, p, q, d, L) 124 | % Take global hankel matrices and construct local ones 125 | % Preallocate cell array 126 | [Nx, Nu] = size(B); 127 | N = Nx / p; 128 | Hx = cell(N, 1); 129 | Hu = cell(N, 1); 130 | Hb = cell(N, 1); 131 | % Compute necessary trajectory length 132 | %Nx_patch = min((2*(d+1)+1)*p, Nx); 133 | %Nu_patch = min((2*(d+2)+1)*q, Nu); 134 | %traj_length = (Nx_patch+L) * Nu_patch + Nx_patch + L - 1; 135 | traj_lengths = data_driven_lib.find_traj_length(A, p, q, d, L); 136 | [xtraj, utraj] = data_driven_lib.generate_traj(A, B, ... 137 | max(traj_lengths)); 138 | %xhank = data_driven_lib.hankelize(xtraj(:, 1:traj_length), L); 139 | %uhank = data_driven_lib.hankelize(utraj, L); 140 | % Construct local hankel matrices 141 | for i=1:N 142 | xhanki = data_driven_lib.hankelize(... 143 | xtraj(:, 1:traj_lengths(i)), L); 144 | uhanki = data_driven_lib.hankelize(... 145 | utraj(:, 1:traj_lengths(i)), L); 146 | % Compute masks 147 | x_mask = data_driven_lib.patch_mask(A, d, p, p, i); 148 | xx_mask = data_driven_lib.patch_mask(A, d+2, p, p, i); 149 | u_mask = data_driven_lib.patch_mask(A, d+1, p, q, i); 150 | uu_mask = data_driven_lib.patch_mask(A, d+2, p, q, i); 151 | x_bd = xor(x_mask, xx_mask); 152 | u_bd = xor(u_mask, uu_mask); 153 | % Construct the patch hankel matrices 154 | x_mask = repmat(x_mask, L, 1); 155 | u_mask = repmat(u_mask, L, 1); 156 | x_bd = repmat(x_bd, L, 1); 157 | u_bd = repmat(u_bd, L, 1); 158 | Hx{i} = xhanki(x_mask, :); 159 | Hu{i} = uhanki(u_mask, :); 160 | Hb{i} = [xhanki(x_bd, :); uhanki(u_bd, :)]; 161 | end 162 | end 163 | 164 | function [shared_x_ind, shared_u_ind] = find_overlap(A, p, q, d, T) 165 | N = size(A, 1) / p; 166 | Phix_count = zeros(N*p, N*p); 167 | Phiu_count = zeros(N*q, N*p); 168 | for i=1:N 169 | x_patch_mask = data_driven_lib.patch_mask(A, d+1, p, p, i); 170 | u_patch_mask = data_driven_lib.patch_mask(A, d+2, p, q, i); 171 | %subsys_mask = data_driven_lib.subsys_mask(size(A, 1), p, i); 172 | Phi_x_mask = x_patch_mask * x_patch_mask'; 173 | Phi_u_mask = u_patch_mask * x_patch_mask'; 174 | Phix_count = Phix_count + Phi_x_mask; 175 | Phiu_count = Phiu_count + Phi_u_mask; 176 | end 177 | Phix_count = repmat(Phix_count, T, 1); 178 | Phiu_count = repmat(Phiu_count, T, 1); 179 | 180 | % Assign indices to all shared variables 181 | xmask = Phix_count > 1; 182 | shared_x_ind = zeros(size(Phix_count)); 183 | shared_x_ind(xmask) = 1:sum(xmask, 'all'); 184 | umask = Phiu_count > 1; 185 | shared_u_ind = zeros(size(Phiu_count)); 186 | shared_u_ind(umask) = (1:sum(umask, 'all')) + sum(xmask, 'all'); 187 | end 188 | 189 | function [traj_lengths] = find_traj_length(A, p, q, d, T) 190 | [Nx, ~] = size(A); 191 | N = Nx / p; 192 | traj_lengths = zeros(N, 1); 193 | for i=1:N 194 | x_mask = data_driven_lib.patch_mask(A, d+1, p, p, i); 195 | u_mask = data_driven_lib.patch_mask(A, d+2, p, q, i); 196 | u_bar_mask = xor(x_mask,... 197 | data_driven_lib.patch_mask(A, d+2, p, p, i)); 198 | nx = sum(x_mask); 199 | nu = sum(u_mask) + sum(u_bar_mask); 200 | traj_lengths(i) = (nx+T)* (nu+1) - 1; 201 | end 202 | traj_length = max(traj_lengths); 203 | end 204 | 205 | function [ZZ] = construct_Z(A, B, T) 206 | [Nx, ~] = size(A); 207 | ZA = kron(eye(T), A); 208 | ZA = [zeros(Nx, size(ZA, 2)); ZA(1:end-Nx, :)]; 209 | ZB = kron(eye(T), B); 210 | ZB = [zeros(Nx, size(ZB, 2)); ZB(1:end-Nx, :)]; 211 | ZZ = [eye(size(ZA, 1))-ZA -ZB]; 212 | end 213 | end 214 | end 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/lib/data_opt.m: -------------------------------------------------------------------------------- 1 | function [G, time] = data_opt(xhank, uhank, A, B, Q, S, T, d, p, q, xi, G_warm) 2 | [Nx, Nu] = size(B); 3 | global_H = [xhank; uhank]; 4 | network = Nx / p; 5 | time = 0; 6 | 7 | tic; 8 | cvx_begin quiet 9 | cvx_precision low 10 | variable G(size(global_H, 2), Nx) 11 | 12 | % Objective 13 | vec_xu = vec(global_H * G * xi); 14 | objective = vec_xu' * vec_xu; 15 | minimize(objective); 16 | 17 | % Constraints 18 | subject to 19 | network = Nx / p; 20 | for i=1:network 21 | 22 | % Achievability constraint for this subsystem 23 | x_row_mask = data_driven_lib.subsys_mask(Nx, p, i); 24 | global_I = eye(Nx); 25 | xhank(x_row_mask, :) * G == global_I(x_row_mask, :); 26 | 27 | % Locality of state response 28 | x_patch_mask = data_driven_lib.patch_mask(A, d, p, p, i); 29 | u_patch_mask = data_driven_lib.patch_mask(A, d+1, p, q, i); 30 | x_mask = repmat(x_patch_mask, T, 1); 31 | x_mask(1:Nx) = 1; 32 | u_mask = repmat(u_patch_mask, T, 1); 33 | xhank(~x_mask, :) * G(:, data_driven_lib.subsys_mask(Nx, p, i)) == 0; 34 | uhank(~u_mask, :) * G(:, data_driven_lib.subsys_mask(Nx, p, i)) == 0; 35 | 36 | end 37 | cvx_end 38 | time = toc / network; 39 | 40 | % Q_rt = kron(xi', global_H); 41 | % model.Q = sparse( Q_rt' * Q_rt ); 42 | % A_gurobi = sparse( kron(eye(Nx), xhank(1:Nx, :)) ); 43 | % I_g = eye(Nx); 44 | % rhs = vec(I_g); 45 | % 46 | % for i=1:network 47 | % ss_mask = p*(i-1)+1 : (p*i); 48 | % Ei = I_g(:, ss_mask); 49 | % 50 | % x_patch_mask = data_driven_lib.patch_mask(A, d, p, p, i); 51 | % u_patch_mask = data_driven_lib.patch_mask(A, d+1, p, q, i); 52 | % 53 | % x_mask = repmat(x_patch_mask, T, 1); 54 | % x_mask(1:Nx) = 1; 55 | % u_mask = repmat(u_patch_mask, T, 1); 56 | % Hb = [xhank(~x_mask, :); uhank(~u_mask, :)]; 57 | % 58 | % A_gurobi = [A_gurobi; kron(Ei', Hb)]; 59 | % rhs = [rhs; zeros(size(Hb, 1) * p, 1)]; 60 | % end 61 | % model.A = sparse(A_gurobi); 62 | % model.rhs = rhs; 63 | % model.lb = -1e2 * ones(size(model.Q, 1), 1); 64 | % model.sense = '='; 65 | % model.pstart = vec(G_warm); 66 | % params.outputflag = 0; 67 | % 68 | % tic; 69 | % results = gurobi(model, params); 70 | % time = toc / network; 71 | % 72 | % G = reshape(results.x, size(xhank, 2), Nx); 73 | end 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/lib/ddd.m: -------------------------------------------------------------------------------- 1 | function [R, M, ti] = ddd(Hx, Hu, Hb, A, B, Q, R, T, d, p, q, xi, rho, ... 2 | row_mask, x_column_mask, u_column_mask, max_patch_size, Psi_warm) 3 | [Nx, Nu] = size(B); 4 | N = Nx / p; 5 | 6 | eps_p = 6e-3; 7 | eps_d = 6e-3; 8 | max_iter = 100; 9 | X = zeros(max_iter, 1); 10 | 11 | time = 0; 12 | 13 | % Scale the termination condition based on patch size 14 | eps_p = eps_p * max_patch_size; 15 | eps_d = eps_d * max_patch_size; 16 | 17 | % Initialize the variables 18 | Phi = zeros((Nx+Nu)*T, Nx); 19 | Psi = Psi_warm; 20 | Psi_prev = Psi_warm; 21 | Lbd = zeros(size(Phi)); 22 | 23 | % big loop until convergence 24 | for it=1:max_iter+1 25 | if it == max_iter+1 26 | disp('did not converge'); 27 | break; 28 | end 29 | 30 | % Compute Phi (using a loop over subsystems) 31 | for i=1:N 32 | % Row masks for the given subsystem 33 | x_subsys_row = false((Nx+Nu)*T, 1); 34 | x_subsys_row(1:Nx*T) = repmat(... 35 | data_driven_lib.subsys_mask(Nx, p, i), T, 1); 36 | u_subsys_row = false((Nx+Nu)*T, 1); 37 | u_subsys_row(Nx*T+1:end) = repmat(... 38 | data_driven_lib.subsys_mask(Nu, q, i), T, 1); 39 | 40 | tic; 41 | % Using Gurobi Optimizer 42 | % Solve for Phi_x 43 | I_x = kron(eye(p*T), xi(x_column_mask{i})'); 44 | 45 | model.Q = sparse( I_x' * I_x + rho/2*eye(size(I_x, 2)) ); 46 | model.obj = -rho * vec( Psi(x_subsys_row, x_column_mask{i})'-... 47 | Lbd(x_subsys_row, x_column_mask{i})' ); 48 | model.A = sparse( zeros(size(I_x, 2)) ); 49 | model.rhs = zeros(size(I_x, 2), 1); 50 | model.lb = -1e2 * ones(size(I_x, 2), 1); 51 | model.sense = '='; 52 | params.outputflag = 0; 53 | results = gurobi(model, params); 54 | Px_gurobi = reshape(results.x, sum(x_column_mask{i}), p*T)'; 55 | 56 | 57 | % Solve for Pu 58 | I_u = kron(eye(q*T), xi(u_column_mask{i})'); 59 | model.Q = sparse( I_u' * I_u + rho/2*eye(size(I_u, 2)) ); 60 | model.obj = -rho * vec( Psi(u_subsys_row, u_column_mask{i})' -... 61 | Lbd(u_subsys_row, u_column_mask{i})' ); 62 | model.A = sparse( zeros(size(I_u, 2)) ); 63 | model.rhs = zeros(size(I_u, 2), 1); 64 | model.lb = -1e3 * ones(size(I_u, 2), 1); 65 | params.outputflag = 0; 66 | results = gurobi(model, params); 67 | 68 | Pu_gurobi = reshape(results.x, sum(u_column_mask{i}), q*T)'; 69 | Phi(x_subsys_row, x_column_mask{i}) = Px_gurobi; 70 | Phi(u_subsys_row, u_column_mask{i}) = Pu_gurobi; 71 | 72 | time = time + toc; 73 | end 74 | 75 | % Compute Psi (using a loop over subsystems) 76 | for i=1:N 77 | subsys_cols = data_driven_lib.subsys_mask(Nx, p, i); 78 | Hi = [Hx{i}; Hu{i}]; 79 | rr = row_mask{i}(1:Nx); 80 | id = eye(sum(rr)); 81 | in_patch_mask = and(rr, subsys_cols); 82 | in_patch_mask = in_patch_mask(rr==1); 83 | 84 | tic; 85 | % Solve for Psi in closed form 86 | Htilde = kron(Hi, eye(p)); 87 | PL = Phi(row_mask{i}, subsys_cols) + Lbd(row_mask{i}, subsys_cols); 88 | bb = 2 * Htilde' * vec(PL'); 89 | Atilde = kron([Hi(1:sum(rr), :); Hb{i}], eye(p)); 90 | rhs = vec([id(:, in_patch_mask);zeros(size(Hb{i},1),p)]'); 91 | mat_lhs = [2*(Htilde'*Htilde) Atilde'; ... 92 | Atilde zeros(size(Atilde, 1))]; 93 | mat_rhs = [bb; rhs]; 94 | gl = pinv(mat_lhs) * mat_rhs; 95 | ggg = reshape(gl(1:p*size(Hx{i}, 2)), p, size(Hx{i}, 2))'; 96 | Psi(row_mask{i}, subsys_cols) = Hi * ggg; 97 | 98 | time = time + toc; 99 | 100 | end 101 | 102 | % Compute Lambda 103 | Lbd = Lbd + Phi - Psi; 104 | 105 | % Check whether converged; bookkeeping 106 | max_p_gap = 0; 107 | max_d_gap = 0; 108 | for i=1:N 109 | subsys_cols = data_driven_lib.subsys_mask(Nx, p, i); 110 | pi = norm(Phi(row_mask{i}, subsys_cols) - ... 111 | Psi(row_mask{i}, subsys_cols), 'fro'); 112 | di = norm(Psi(row_mask{i}, subsys_cols) - ... 113 | Psi_prev(row_mask{i}, subsys_cols), 'fro'); 114 | if pi > max_p_gap 115 | max_p_gap = pi; 116 | end 117 | if di > max_d_gap 118 | max_d_gap = di; 119 | end 120 | end 121 | 122 | fprintf("Iteration: %d\ts: %d\t d: %d\t time:%d\n", it, ... 123 | max_p_gap, max_d_gap, time/N); 124 | 125 | if max_p_gap < eps_p && max_d_gap < eps_d 126 | break 127 | end 128 | 129 | Psi_prev = Psi; 130 | end 131 | 132 | R = Psi(1:Nx*T,:); 133 | M = Psi(Nx*T+1:end,:); 134 | ti = time/N; 135 | end -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/lib/environment.m: -------------------------------------------------------------------------------- 1 | classdef environment 2 | methods ( Static = true ) 3 | function [Nx, Nu, p, q, A, B, Q, S] = pendulum(n, Ts) 4 | p = 2; 5 | q = 1; 6 | Nx = p*n; Nu = q*n; 7 | 8 | % A matrix 9 | m = 1; k = 1; d = 3; g = 10; l = 1; 10 | 11 | block_off_diag = [0 0; k*l/m d/(m*l)]; 12 | block_diag_extr = [0 1; -g-k*l/m -d/(m*l)]; 13 | block_diag = [0 1; -g-2*k*l/m -2*d/(m*l)]; 14 | 15 | Ac = zeros(Nx,Nx); j = 0; 16 | for i = 1:2:Nx 17 | j = j+1; 18 | if j == 1 % first node 19 | Ac (i:i+1,i+2:i+3) = block_off_diag; 20 | Ac (i:i+1,i:i+1) = block_diag; 21 | elseif j == Nx/2 % last node 22 | Ac (i:i+1,i:i+1) = block_diag; 23 | Ac (i:i+1,i-2:i-1) = block_off_diag; 24 | else 25 | Ac (i:i+1,i+2:i+3) = block_off_diag; 26 | Ac (i:i+1,i:i+1) = block_diag; 27 | Ac (i:i+1,i-2:i-1) = block_off_diag; 28 | end 29 | end 30 | 31 | % B matrix 32 | Bc = zeros(Nx,Nu); j = 0; 33 | for i = 1:2:Nx 34 | j = j+1; 35 | Bc (i:i+1,j) = [0; 1]; 36 | end 37 | 38 | % Discretize 39 | A = (eye(Nx)+Ac*Ts); 40 | B = Ts*Bc; 41 | 42 | 43 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 44 | % Coupling weights and constraints 45 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 46 | % Set-point (scenarios 1 & 2) 47 | Q = eye(Nx); 48 | S = diag(ones(Nu,1)); 49 | end 50 | function [Nx, Nu, p, q, A, B, Q, S] = scaler_sys(n, Anorm) 51 | p = 1; 52 | q = 1; 53 | Nx = p*n; Nu = q*n; 54 | 55 | % A matrix: randomly sample a banded matrix (discrete-time A). 56 | A = zeros(Nx, Nx); 57 | A(1, 1:2) = rand(1,2) - 0.5; 58 | for i = 2:Nx-1 59 | A(i, i-1:i+1) = rand(1,3) - 0.5; 60 | end 61 | A(Nx, Nx-1:Nx) = rand(1,2) - 0.5; 62 | A = A / max(abs(eig(A))) * Anorm; 63 | 64 | B = eye(Nx); 65 | Q = eye(Nx); 66 | S = diag(ones(Nu,1)); 67 | end 68 | function [Nx, Nu, p, q, A_dyn, B_dyn, Q, S, A] = chain(N) 69 | Nx = 2*N; 70 | Nu = N; 71 | Q = eye(Nx); 72 | S = eye(Nu); 73 | p = 2; 74 | q = 1; 75 | 76 | A = zeros(N); 77 | dt = 0.2; 78 | 79 | % Sample an adjacency matrix for the graph 80 | for i=1:N-1 81 | A(i, i+1) = 1; 82 | A(i+1, i) = 1; 83 | end 84 | 85 | % Sample parameters 86 | minv = rand(N, 1) * 2; 87 | d = 0.5 + rand(N, 1) * 0.5; 88 | K = 1 + rand(N, N) * 0.5; 89 | K = (K + K') / 2; % Do we need to symmetrize? 90 | for i=1:N 91 | K(i,i) = A(i,:) * K(:, i); 92 | end 93 | 94 | % Construct dynamic matrices 95 | A_dyn = zeros(2*N); 96 | B_dyn = zeros(2*N, N); 97 | for i=1:N 98 | for j=1:N 99 | if i==j 100 | A_dyn(2*i-1:2*i, 2*i-1:2*i) = ... 101 | [1 dt; -K(i,i)*minv(i)*dt 1-d(i)*minv(i)*dt]; 102 | B_dyn(2*i-1:2*i, i) = [0; 1]; 103 | elseif A(i,j) == 1 104 | A_dyn(2*i-1:2*i, 2*j-1:2*j) = [0 0; K(i,j)*minv(i)*dt 0]; 105 | end 106 | end 107 | end 108 | end 109 | function [Nx, Nu, p, q, A_dyn, B_dyn, Q, S, A] = grid(N, prob) 110 | Nx = 2*N; 111 | Nu = N; 112 | Q = eye(Nx); 113 | S = eye(Nu); 114 | p = 2; 115 | q = 1; 116 | 117 | n = sqrt(N); 118 | A = zeros(N); 119 | dt = 0.2; 120 | 121 | % Sample an adjacency matrix for the graph 122 | for i=1:N 123 | % connect up 124 | if mod(i, n) ~= 0 125 | if rand() < prob 126 | A(i, i+1) = 1; 127 | A(i+1, i) = 1; 128 | end 129 | end 130 | % connect right 131 | if i + n <= N 132 | if rand() < prob 133 | A(i, i+n) = 1; 134 | A(i+n, i) = 1; 135 | end 136 | end 137 | end 138 | 139 | % Sample parameters 140 | minv = rand(N, 1) * 2; 141 | d = 0.5 + rand(N, 1) * 0.5; 142 | K = 1 + rand(N, N) * 0.5; 143 | K = (K + K') / 2; % Do we need to symmetrize? 144 | for i=1:N 145 | K(i,i) = A(i,:) * K(:, i); 146 | end 147 | 148 | % Construct dynamic matrices 149 | A_dyn = zeros(2*N); 150 | B_dyn = zeros(2*N, N); 151 | for i=1:N 152 | for j=1:N 153 | if i==j 154 | A_dyn(2*i-1:2*i, 2*i-1:2*i) = ... 155 | [1 dt; -K(i,i)*minv(i)*dt 1-d(i)*minv(i)*dt]; 156 | B_dyn(2*i-1:2*i, i) = [0; 1]; 157 | elseif A(i,j) == 1 158 | A_dyn(2*i-1:2*i, 2*j-1:2*j) = [0 0; K(i,j)*minv(i)*dt 0]; 159 | end 160 | end 161 | end 162 | end 163 | function [] = plot_grid(A) % Plot the grid 164 | figure; 165 | N = size(A, 1); 166 | n = sqrt(N); 167 | for i=1:N 168 | for j=i+1:N 169 | if A(i,j) == 1 170 | % Plot an edge 171 | pos_i_x = mod(i-1, n); 172 | pos_i_y = -floor((i-1) / n); 173 | pos_j_x = mod(j-1, n); 174 | pos_j_y = -floor((j-1) / n); 175 | plot([pos_i_x, pos_j_x], [pos_i_y, pos_j_y], 'b'); 176 | hold on 177 | end 178 | end 179 | end 180 | xlim([-0.5, n-0.5]); 181 | ylim([-n+0.5, 0.5]); 182 | end 183 | end 184 | end 185 | -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/results/cost_locality.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2022_OJCS_DataDriven-DLMPC/results/cost_locality.mat -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/results/cost_locality_chain.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2022_OJCS_DataDriven-DLMPC/results/cost_locality_chain.mat -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/results/optimality.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2022_OJCS_DataDriven-DLMPC/results/optimality.mat -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/results/optimality_chain.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2022_OJCS_DataDriven-DLMPC/results/optimality_chain.mat -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/results/scalability_chain.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2022_OJCS_DataDriven-DLMPC/results/scalability_chain.mat -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/results/tl_d.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2022_OJCS_DataDriven-DLMPC/results/tl_d.mat -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/results/tl_d_chain.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2022_OJCS_DataDriven-DLMPC/results/tl_d_chain.mat -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/results/tl_net.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2022_OJCS_DataDriven-DLMPC/results/tl_net.mat -------------------------------------------------------------------------------- /2022_OJCS_DataDriven-DLMPC/results/tl_net_chain.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/unstable-zeros/data-driven-sls/8593b160b6f8b056bef0348ffd32e5bbef9be424/2022_OJCS_DataDriven-DLMPC/results/tl_net_chain.mat -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Data-Driven System Level Synthesis 2 | 3 | This repository hosts the code needed to reproduce the examples in the published work: 4 | 5 | 1. A. Xue, and N. Matni. Data-Driven System Level Synthesis. In _Proceedings of Machine Learning Research_, Vol. 144:1–12, 2021. Preprint (extended version) available at https://arxiv.org/abs/2011.10674. 6 | 7 | 2. C. Amo Alonso*, F. Yang*, and N. Matni. Data-Driven Distributed and Localized Model Predictive Control via System Level Synthesis. Submitted to _IEEE Open Journal of Control Systems_, 2022. Preprint available at https://arxiv.org/abs/2112.12229. 8 | 9 | *denotes equal contribution 10 | 11 | ## 2021_L4DC_DataDriven-SLS 12 | 13 | This folder hosts the code needed to reproduce the examples in article [1] and its extended version available at https://arxiv.org/abs/2011.10674. Extended versions of the paper can be found in this folder in both the L4DC (abridged format with proofs in the appendix) and arXiv (no appendices, self-contained document) formats. 14 | 15 | A README file can be found in the "experiments" folder, where a detailed explanation of how the files should be run is available. 16 | 17 | ## 2022_OJCS_DataDriven-DLMPC 18 | 19 | This folder hosts the code needed to reproduce the examples in article [2] and its preprint https://arxiv.org/abs/2112.12229. 20 | 21 | The names of the subfolders correspond to the figure's number that they generate. Users must first run the script named `script_[corresponging figure].m`, which will save the data in folder named `results` as a .mat file. Once this is done, users must run the script named `plot_[corresponging figure].m`, located in the same folder where the first script was run. This will produce the desired figure. 22 | 23 | *Note*: To run the script, users must change the current directory to the one the script is in. 24 | 25 | *Warning*: some of the scripts, in particular the ones concerning runtime measures, might take several hours to run. 26 | --------------------------------------------------------------------------------