{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Iterative Linearization 迭代线性化" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The goal is to have a more accurate linearization of the diff equations. For every time step the optimization is iterativelly repeated using he previous optimization results **u_bar** to approximate the vehicle dynamics, instead of a random starting guess and/or the rsult at time t-1.\n", "目标是对差分方程进行更准确的线性化。对于每个时间步,优化是通过使用前一个优化结果**u_bar**迭代地重复来近似车辆动态,而不是随机的起始猜测和/或时间t-1的结果。\n", "\n", "In previous case the results at t-1 wer used to approimate the dynamics art time t!\n", "在以前的情况下,时间t-1的结果被用来近似时间t的动态!\n", "\n", "This maks the results less correlated but makes the controller slower!\n", "这使得结果准确性更差而且花费更多的时间" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2024-10-23T09:00:00.554665Z", "start_time": "2024-10-23T08:59:59.738230Z" } }, "outputs": [], "source": [ "import numpy as np\n", "from scipy.integrate import odeint\n", "from scipy.interpolate import interp1d\n", "import cvxpy as cp\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "plt.style.use(\"ggplot\")\n", "\n", "import time" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2024-10-23T09:00:02.359610Z", "start_time": "2024-10-23T09:00:02.344735Z" } }, "outputs": [], "source": [ "\"\"\"\n", "Control problem statement.\n", "\"\"\"\n", "\n", "N = 4 # number of state variables\n", "M = 2 # number of control variables\n", "T = 20 # Prediction Horizon\n", "DT = 0.2 # discretization step\n", "\n", "\n", "def get_linear_model(x_bar, u_bar):\n", " \"\"\"\n", " Computes the LTI approximated state space model x' = Ax + Bu + C\n", " \"\"\"\n", "\n", " L = 0.3 # vehicle wheelbase\n", "\n", " x = x_bar[0]\n", " y = x_bar[1]\n", " v = x_bar[2]\n", " theta = x_bar[3]\n", "\n", " a = u_bar[0]\n", " delta = u_bar[1]\n", "\n", " A = np.zeros((N, N))\n", " A[0, 2] = np.cos(theta)\n", " A[0, 3] = -v * np.sin(theta)\n", " A[1, 2] = np.sin(theta)\n", " A[1, 3] = v * np.cos(theta)\n", " A[3, 2] = v * np.tan(delta) / L\n", " A_lin = np.eye(N) + DT * A\n", "\n", " B = np.zeros((N, M))\n", " B[2, 0] = 1\n", " B[3, 1] = v / (L * np.cos(delta) ** 2)\n", " B_lin = DT * B\n", "\n", " f_xu = np.array(\n", " [v * np.cos(theta), v * np.sin(theta), a, v * np.tan(delta) / L]\n", " ).reshape(N, 1)\n", " C_lin = DT * (\n", " f_xu - np.dot(A, x_bar.reshape(N, 1)) - np.dot(B, u_bar.reshape(M, 1))\n", " )\n", "\n", " return np.round(A_lin, 4), np.round(B_lin, 4), np.round(C_lin, 4)\n", "\n", "\n", "\"\"\"\n", "the ODE is used to update the simulation given the mpc results\n", "I use this insted of using the LTI twice\n", "\"\"\"\n", "\n", "\n", "def kinematics_model(x, t, u):\n", " \"\"\"\n", " Returns the set of ODE of the vehicle model.\n", " \"\"\"\n", "\n", " L = 0.3 # vehicle wheelbase\n", " dxdt = x[2] * np.cos(x[3])\n", " dydt = x[2] * np.sin(x[3])\n", " dvdt = u[0]\n", " dthetadt = x[2] * np.tan(u[1]) / L\n", "\n", " dqdt = [dxdt, dydt, dvdt, dthetadt]\n", "\n", " return dqdt\n", "\n", "\n", "def predict(x0, u):\n", " \"\"\" \"\"\"\n", "\n", " x_ = np.zeros((N, T + 1))\n", "\n", " x_[:, 0] = x0\n", "\n", " # solve ODE\n", " for t in range(1, T + 1):\n", "\n", " tspan = [0, DT]\n", " x_next = odeint(kinematics_model, x0, tspan, args=(u[:, t - 1],))\n", "\n", " x0 = x_next[1]\n", " x_[:, t] = x_next[1]\n", "\n", " return x_\n", "\n", "\n", "def compute_path_from_wp(start_xp, start_yp, step=0.1):\n", " \"\"\"\n", " Computes a reference path given a set of waypoints\n", " \"\"\"\n", "\n", " final_xp = []\n", " final_yp = []\n", " delta = step # [m]\n", "\n", " for idx in range(len(start_xp) - 1):\n", " section_len = np.sum(\n", " np.sqrt(\n", " np.power(np.diff(start_xp[idx : idx + 2]), 2)\n", " + np.power(np.diff(start_yp[idx : idx + 2]), 2)\n", " )\n", " )\n", "\n", " interp_range = np.linspace(0, 1, np.floor(section_len / delta).astype(int))\n", "\n", " fx = interp1d(np.linspace(0, 1, 2), start_xp[idx : idx + 2], kind=1)\n", " fy = interp1d(np.linspace(0, 1, 2), start_yp[idx : idx + 2], kind=1)\n", "\n", " final_xp = np.append(final_xp, fx(interp_range))\n", " final_yp = np.append(final_yp, fy(interp_range))\n", "\n", " dx = np.append(0, np.diff(final_xp))\n", " dy = np.append(0, np.diff(final_yp))\n", " theta = np.arctan2(dy, dx)\n", "\n", " return np.vstack((final_xp, final_yp, theta))\n", "\n", "\n", "def get_nn_idx(state, path):\n", " \"\"\"\n", " Computes the index of the waypoint closest to vehicle\n", " \"\"\"\n", "\n", " dx = state[0] - path[0, :]\n", " dy = state[1] - path[1, :]\n", " dist = np.hypot(dx, dy)\n", " nn_idx = np.argmin(dist)\n", "\n", " try:\n", " v = [\n", " path[0, nn_idx + 1] - path[0, nn_idx],\n", " path[1, nn_idx + 1] - path[1, nn_idx],\n", " ]\n", " v /= np.linalg.norm(v)\n", "\n", " d = [path[0, nn_idx] - state[0], path[1, nn_idx] - state[1]]\n", "\n", " if np.dot(d, v) > 0:\n", " target_idx = nn_idx\n", " else:\n", " target_idx = nn_idx + 1\n", "\n", " except IndexError as e:\n", " target_idx = nn_idx\n", "\n", " return target_idx\n", "\n", "\n", "def get_ref_trajectory(state, path, target_v):\n", " \"\"\"\n", " Adapted from pythonrobotics\n", " \"\"\"\n", " xref = np.zeros((N, T + 1))\n", " dref = np.zeros((1, T + 1))\n", "\n", " # sp = np.ones((1,T +1))*target_v #speed profile\n", "\n", " ncourse = path.shape[1]\n", "\n", " ind = get_nn_idx(state, path)\n", "\n", " xref[0, 0] = path[0, ind] # X\n", " xref[1, 0] = path[1, ind] # Y\n", " xref[2, 0] = target_v # sp[ind] #V\n", " xref[3, 0] = path[2, ind] # Theta\n", " dref[0, 0] = 0.0 # steer operational point should be 0\n", "\n", " dl = 0.05 # Waypoints spacing [m]\n", " travel = 0.0\n", "\n", " for i in range(T + 1):\n", " travel += abs(target_v) * DT # current V or target V?\n", " dind = int(round(travel / dl))\n", "\n", " if (ind + dind) < ncourse:\n", " xref[0, i] = path[0, ind + dind]\n", " xref[1, i] = path[1, ind + dind]\n", " xref[2, i] = target_v # sp[ind + dind]\n", " xref[3, i] = path[2, ind + dind]\n", " dref[0, i] = 0.0\n", " else:\n", " xref[0, i] = path[0, ncourse - 1]\n", " xref[1, i] = path[1, ncourse - 1]\n", " xref[2, i] = 0.0 # stop? #sp[ncourse - 1]\n", " xref[3, i] = path[2, ncourse - 1]\n", " dref[0, i] = 0.0\n", "\n", " return xref, dref" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2024-10-23T09:10:34.071593Z", "start_time": "2024-10-23T09:09:45.254644Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_22784/1770301921.py:27: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", " A[0, 2] = np.cos(theta)\n", "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_22784/1770301921.py:28: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", " A[0, 3] = -v * np.sin(theta)\n", "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_22784/1770301921.py:29: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", " A[1, 2] = np.sin(theta)\n", "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_22784/1770301921.py:30: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", " A[1, 3] = v * np.cos(theta)\n", "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_22784/1770301921.py:31: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", " A[3, 2] = v * np.tan(delta) / L\n", "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_22784/1770301921.py:36: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", " B[3, 1] = v / (L * np.cos(delta) ** 2)\n", "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_22784/1770301921.py:137: RuntimeWarning: invalid value encountered in divide\n", " v /= np.linalg.norm(v)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "CVXPY Optimization Time: Avrg: 0.2452s Max: 0.3502s Min: 0.1029s\n" ] } ], "source": [ "track = compute_path_from_wp(\n", " [0, 3, 4, 6, 10, 12, 14, 6, 1, 0], [0, 0, 2, 4, 3, 3, -2, -6, -2, -2], 0.05\n", ")\n", "\n", "# track = compute_path_from_wp([0,10,10,0],\n", "# [0,0,1,1],0.05)\n", "\n", "sim_duration = 200 # time steps\n", "opt_time = []\n", "\n", "x_sim = np.zeros((N, sim_duration))\n", "u_sim = np.zeros((M, sim_duration - 1))\n", "\n", "MAX_SPEED = 1.5 # m/s\n", "MAX_ACC = 1.0 # m/ss\n", "MAX_D_ACC = 1.0 # m/sss\n", "MAX_STEER = np.radians(30) # rad\n", "MAX_D_STEER = np.radians(30) # rad/s\n", "\n", "REF_VEL = 1.0 # m/s\n", "\n", "# Starting Condition\n", "x0 = np.zeros(N)\n", "x0[0] = 0 # x\n", "x0[1] = -0.25 # y\n", "x0[2] = 0.0 # v\n", "x0[3] = np.radians(-0) # yaw\n", "\n", "for sim_time in range(sim_duration - 1):\n", "\n", " iter_start = time.time()\n", "\n", " # starting guess for ctrl\n", " u_bar = np.zeros((M, T))\n", " u_bar[0, :] = MAX_ACC / 2 # a\n", " u_bar[1, :] = 0.0 # delta\n", "\n", " for _ in range(5):\n", " u_prev = u_bar\n", "\n", " # dynamics starting state\n", " x_bar = np.zeros((N, T + 1))\n", " x_bar[:, 0] = x_sim[:, sim_time]\n", "\n", " # prediction for linearization of costrains\n", " for t in range(1, T + 1):\n", " xt = x_bar[:, t - 1].reshape(N, 1)\n", " ut = u_bar[:, t - 1].reshape(M, 1)\n", " A, B, C = get_linear_model(xt, ut)\n", " xt_plus_one = np.squeeze(np.dot(A, xt) + np.dot(B, ut) + C)\n", " x_bar[:, t] = xt_plus_one\n", "\n", " # CVXPY Linear MPC problem statement\n", " x = cp.Variable((N, T + 1))\n", " u = cp.Variable((M, T))\n", " cost = 0\n", " constr = []\n", "\n", " # Cost Matrices\n", " Q = np.diag([20, 20, 10, 0]) # state error cost\n", " Qf = np.diag([30, 30, 30, 0]) # state final error cost\n", " R = np.diag([10, 10]) # input cost\n", " R_ = np.diag([10, 10]) # input rate of change cost\n", "\n", " # Get Reference_traj\n", " x_ref, d_ref = get_ref_trajectory(x_bar[:, 0], track, REF_VEL)\n", "\n", " # Prediction Horizon\n", " for t in range(T):\n", "\n", " # Tracking Error\n", " cost += cp.quad_form(x[:, t] - x_ref[:, t], Q)\n", "\n", " # Actuation effort\n", " cost += cp.quad_form(u[:, t], R)\n", "\n", " # Actuation rate of change\n", " if t < (T - 1):\n", " cost += cp.quad_form(u[:, t + 1] - u[:, t], R_)\n", " constr += [\n", " cp.abs(u[0, t + 1] - u[0, t]) / DT <= MAX_D_ACC\n", " ] # max acc rate of change\n", " constr += [\n", " cp.abs(u[1, t + 1] - u[1, t]) / DT <= MAX_D_STEER\n", " ] # max steer rate of change\n", "\n", " # Kinrmatics Constrains (Linearized model)\n", " A, B, C = get_linear_model(x_bar[:, t], u_bar[:, t])\n", " constr += [x[:, t + 1] == A @ x[:, t] + B @ u[:, t] + C.flatten()]\n", "\n", " # Final Point tracking\n", " cost += cp.quad_form(x[:, T] - x_ref[:, T], Qf)\n", "\n", " # sums problem objectives and concatenates constraints.\n", " constr += [x[:, 0] == x_bar[:, 0]] # starting condition\n", " constr += [x[2, :] <= MAX_SPEED] # max speed\n", " constr += [x[2, :] >= 0.0] # min_speed (not really needed)\n", " constr += [cp.abs(u[0, :]) <= MAX_ACC] # max acc\n", " constr += [cp.abs(u[1, :]) <= MAX_STEER] # max steer\n", "\n", " # Solve\n", " prob = cp.Problem(cp.Minimize(cost), constr)\n", " solution = prob.solve(solver=cp.OSQP, verbose=False)\n", "\n", " # retrieved optimized U and assign to u_bar to linearize in next step\n", " u_bar = np.vstack(\n", " (np.array(u.value[0, :]).flatten(), (np.array(u.value[1, :]).flatten()))\n", " )\n", "\n", " # check how this solution differs from previous\n", " # if the solutions are very\n", " delta_u = np.sum(np.sum(np.abs(u_bar - u_prev), axis=0), axis=0)\n", " if delta_u < 0.05:\n", " break\n", "\n", " # select u from best iteration\n", " u_sim[:, sim_time] = u_bar[:, 0]\n", "\n", " # Measure elpased time to get results from cvxpy\n", " opt_time.append(time.time() - iter_start)\n", "\n", " # move simulation to t+1\n", " tspan = [0, DT]\n", " x_sim[:, sim_time + 1] = odeint(\n", " kinematics_model, x_sim[:, sim_time], tspan, args=(u_bar[:, 0],)\n", " )[1]\n", "\n", " # reset u_bar? -> this simulates that we don use previous solution!\n", " u_bar[0, :] = MAX_ACC / 2 # a\n", " u_bar[1, :] = 0.0 # delta\n", "\n", "\n", "print(\n", " \"CVXPY Optimization Time: Avrg: {:.4f}s Max: {:.4f}s Min: {:.4f}s\".format(\n", " np.mean(opt_time), np.max(opt_time), np.min(opt_time)\n", " )\n", ")" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2024-10-23T09:10:36.414059Z", "start_time": "2024-10-23T09:10:36.231412Z" } }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# plot trajectory\n", "grid = plt.GridSpec(4, 5)\n", "\n", "plt.figure(figsize=(15, 10))\n", "\n", "plt.subplot(grid[0:4, 0:4])\n", "plt.plot(track[0, :], track[1, :], \"b+\")\n", "plt.plot(x_sim[0, :], x_sim[1, :])\n", "plt.axis(\"equal\")\n", "plt.ylabel(\"y\")\n", "plt.xlabel(\"x\")\n", "\n", "plt.subplot(grid[0, 4])\n", "plt.plot(u_sim[0, :])\n", "plt.ylabel(\"a(t) [m/ss]\")\n", "\n", "plt.subplot(grid[1, 4])\n", "plt.plot(x_sim[2, :])\n", "plt.ylabel(\"v(t) [m/s]\")\n", "\n", "plt.subplot(grid[2, 4])\n", "plt.plot(np.degrees(u_sim[1, :]))\n", "plt.ylabel(\"delta(t) [rad]\")\n", "\n", "plt.subplot(grid[3, 4])\n", "plt.plot(x_sim[3, :])\n", "plt.ylabel(\"theta(t) [rad]\")\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "outputs": [], "source": [], "metadata": { "collapsed": false } } ], "metadata": { "kernelspec": { "name": "python3", "language": "python", "display_name": "Python 3 (ipykernel)" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.5" } }, "nbformat": 4, "nbformat_minor": 4 }