{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Optimization with numpy Arrays" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.844567Z", "start_time": "2020-03-24T21:13:38.850353Z" }, "attributes": { "classes": [], "id": "", "n": "1" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:56.491044Z", "iopub.status.busy": "2024-06-03T14:23:56.490913Z", "iopub.status.idle": "2024-06-03T14:23:57.496001Z", "shell.execute_reply": "2024-06-03T14:23:57.495645Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Python implementation: CPython\n", "Python version : 3.12.0\n", "IPython version : 8.25.0\n", "\n", "numpy : 1.26.4\n", "krotov : 1.3.0+dev\n", "matplotlib: 3.7.5\n", "scipy : 1.12.0\n", "\n" ] } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "%load_ext watermark\n", "import numpy as np\n", "import scipy\n", "import matplotlib\n", "import matplotlib.pylab as plt\n", "import krotov\n", "# note that qutip is NOT imported\n", "%watermark -v --iversions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$\\newcommand{tr}[0]{\\operatorname{tr}}\n", "\\newcommand{diag}[0]{\\operatorname{diag}}\n", "\\newcommand{abs}[0]{\\operatorname{abs}}\n", "\\newcommand{pop}[0]{\\operatorname{pop}}\n", "\\newcommand{aux}[0]{\\text{aux}}\n", "\\newcommand{opt}[0]{\\text{opt}}\n", "\\newcommand{tgt}[0]{\\text{tgt}}\n", "\\newcommand{init}[0]{\\text{init}}\n", "\\newcommand{lab}[0]{\\text{lab}}\n", "\\newcommand{rwa}[0]{\\text{rwa}}\n", "\\newcommand{bra}[1]{\\langle#1\\vert}\n", "\\newcommand{ket}[1]{\\vert#1\\rangle}\n", "\\newcommand{Bra}[1]{\\left\\langle#1\\right\\vert}\n", "\\newcommand{Ket}[1]{\\left\\vert#1\\right\\rangle}\n", "\\newcommand{Braket}[2]{\\left\\langle #1\\vphantom{#2} \\mid\n", "#2\\vphantom{#1}\\right\\rangle}\n", "\\newcommand{op}[1]{\\hat{#1}}\n", "\\newcommand{Op}[1]{\\hat{#1}}\n", "\\newcommand{dd}[0]{\\,\\text{d}}\n", "\\newcommand{Liouville}[0]{\\mathcal{L}}\n", "\\newcommand{DynMap}[0]{\\mathcal{E}}\n", "\\newcommand{identity}[0]{\\mathbf{1}}\n", "\\newcommand{Norm}[1]{\\lVert#1\\rVert}\n", "\\newcommand{Abs}[1]{\\left\\vert#1\\right\\vert}\n", "\\newcommand{avg}[1]{\\langle#1\\rangle}\n", "\\newcommand{Avg}[1]{\\left\\langle#1\\right\\rangle}\n", "\\newcommand{AbsSq}[1]{\\left\\vert#1\\right\\vert^2}\n", "\\newcommand{Re}[0]{\\operatorname{Re}}\n", "\\newcommand{Im}[0]{\\operatorname{Im}}$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `krotov` package heavily builds on QuTiP. However, in rare circumstances\n", "the overhead of `qutip.Qobj` objects might limit numerical efficiency, in\n", "particular when QuTiP's automatic sparse storage is inappropriate. If you know\n", "what you are doing, it is possible to replace `Qobj`s with low-level objects\n", "such as numpy arrays. This example revisits the [Optimization of a\n", "State-to-State Transfer in a Two-Level-System](01_example_simple_state_to_state.ipynb),\n", "but exclusively uses numpy objects for states and operators." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Two-level-Hamiltonian" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We consider again the standard Hamiltonian of a two-level system, but now we\n", "construct the drift Hamiltonian `H0` and the control Hamiltonian `H1` as numpy\n", "matrices:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.862100Z", "start_time": "2020-03-24T21:13:40.847535Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.519194Z", "iopub.status.busy": "2024-06-03T14:23:57.518953Z", "iopub.status.idle": "2024-06-03T14:23:57.522368Z", "shell.execute_reply": "2024-06-03T14:23:57.522085Z" } }, "outputs": [], "source": [ "def hamiltonian(omega=1.0, ampl0=0.2):\n", " \"\"\"Two-level-system Hamiltonian\n", "\n", " Args:\n", " omega (float): energy separation of the qubit levels\n", " ampl0 (float): constant amplitude of the driving field\n", " \"\"\"\n", " H0 = -0.5 * omega * np.array([[1, 0], [0, -1]], dtype=np.complex128)\n", " H1 = np.array([[0, 1], [1, 0]], dtype=np.complex128)\n", "\n", " def guess_control(t, args):\n", " return ampl0 * krotov.shapes.flattop(\n", " t, t_start=0, t_stop=5, t_rise=0.3, func=\"blackman\"\n", " )\n", "\n", " return [H0, [H1, guess_control]]\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.872139Z", "start_time": "2020-03-24T21:13:40.865354Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.523800Z", "iopub.status.busy": "2024-06-03T14:23:57.523713Z", "iopub.status.idle": "2024-06-03T14:23:57.525491Z", "shell.execute_reply": "2024-06-03T14:23:57.525175Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "H = hamiltonian()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optimization target\n", "\n", "By default, the `Objective` initializer checks that the objective is expressed with\n", "QuTiP objects. If we want to use low-level objects instead, we have to\n", "explicitly disable this:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.880764Z", "start_time": "2020-03-24T21:13:40.876732Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.527047Z", "iopub.status.busy": "2024-06-03T14:23:57.526938Z", "iopub.status.idle": "2024-06-03T14:23:57.528584Z", "shell.execute_reply": "2024-06-03T14:23:57.528326Z" } }, "outputs": [], "source": [ "krotov.Objective.type_checking = False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we initialize the initial and target states,\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.889029Z", "start_time": "2020-03-24T21:13:40.883324Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.530097Z", "iopub.status.busy": "2024-06-03T14:23:57.530012Z", "iopub.status.idle": "2024-06-03T14:23:57.531903Z", "shell.execute_reply": "2024-06-03T14:23:57.531594Z" } }, "outputs": [], "source": [ "ket0 = np.array([[1], [0]], dtype=np.complex128)\n", "ket1 = np.array([[0], [1]], dtype=np.complex128)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and instantiate the `Objective` for the state-to-state transfer:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.902604Z", "start_time": "2020-03-24T21:13:40.891777Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.533523Z", "iopub.status.busy": "2024-06-03T14:23:57.533391Z", "iopub.status.idle": "2024-06-03T14:23:57.536997Z", "shell.execute_reply": "2024-06-03T14:23:57.536700Z" } }, "outputs": [ { "data": { "text/plain": [ "[Objective[a₀[2,1] to a₁[2,1] via [a₂[2,2], [a₃[2,2], u₁(t)]]]]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "objectives = [\n", " krotov.Objective(initial_state=ket0, target=ket1, H=H)\n", "]\n", "\n", "objectives" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note how all objects are numpy arrays, as indicated by the symbol `a`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulate dynamics under the guess field\n", "\n", "To simulate the dynamics under the guess pulse, we can use the objective's\n", "`propagator` method. However, the propagator we use must take into account the\n", "format of the states and operators. We define a simple propagator that solve\n", "the dynamics within a single time step my matrix exponentiation of the\n", "Hamiltonian:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.913174Z", "start_time": "2020-03-24T21:13:40.905293Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.538677Z", "iopub.status.busy": "2024-06-03T14:23:57.538564Z", "iopub.status.idle": "2024-06-03T14:23:57.540781Z", "shell.execute_reply": "2024-06-03T14:23:57.540487Z" } }, "outputs": [], "source": [ "def expm(H, state, dt, c_ops=None, backwards=False, initialize=False):\n", " eqm_factor = -1j # factor in front of H on rhs of the equation of motion\n", " if backwards:\n", " eqm_factor = eqm_factor.conjugate()\n", " A = eqm_factor * H[0]\n", " for part in H[1:]:\n", " A += (eqm_factor * part[1]) * part[0]\n", " return scipy.linalg.expm(A * dt) @ state" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will want to analyze the population dynamics, and thus define the projectors\n", "on the ground and excited levels, again as numpy matrices:\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.923040Z", "start_time": "2020-03-24T21:13:40.917919Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.542211Z", "iopub.status.busy": "2024-06-03T14:23:57.542051Z", "iopub.status.idle": "2024-06-03T14:23:57.543896Z", "shell.execute_reply": "2024-06-03T14:23:57.543647Z" } }, "outputs": [], "source": [ "proj0 = np.array([[1, 0],[0, 0]], dtype=np.complex128)\n", "proj1 = np.array([[0, 0],[0, 1]], dtype=np.complex128)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will pass these as `e_ops` to the `propagate` method, but since `propagate`\n", "assumes that `e_ops` contains `Qobj` instances, we will have to teach it how to\n", "calculate expectation values:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.930798Z", "start_time": "2020-03-24T21:13:40.926588Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.545255Z", "iopub.status.busy": "2024-06-03T14:23:57.545135Z", "iopub.status.idle": "2024-06-03T14:23:57.546902Z", "shell.execute_reply": "2024-06-03T14:23:57.546662Z" } }, "outputs": [], "source": [ "def expect(proj, state):\n", " return complex(state.conj().T @ (proj @ state)).real" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can simulate the dynamics over a time grid from $t=0$ to $T=5$ and plot\n", "the resulting dynamics." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:40.937342Z", "start_time": "2020-03-24T21:13:40.933147Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.548325Z", "iopub.status.busy": "2024-06-03T14:23:57.548228Z", "iopub.status.idle": "2024-06-03T14:23:57.549880Z", "shell.execute_reply": "2024-06-03T14:23:57.549500Z" } }, "outputs": [], "source": [ "tlist = np.linspace(0, 5, 500)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:41.170271Z", "start_time": "2020-03-24T21:13:40.939839Z" }, "attributes": { "classes": [], "id": "", "n": "12" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.551258Z", "iopub.status.busy": "2024-06-03T14:23:57.551171Z", "iopub.status.idle": "2024-06-03T14:23:57.582962Z", "shell.execute_reply": "2024-06-03T14:23:57.582650Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/mm/rr6dgkzj0l5_j_ntxcg_hlth0000gn/T/ipykernel_52079/3854291581.py:2: 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", " return complex(state.conj().T @ (proj @ state)).real\n", "/var/folders/mm/rr6dgkzj0l5_j_ntxcg_hlth0000gn/T/ipykernel_52079/3854291581.py:2: 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", " return complex(state.conj().T @ (proj @ state)).real\n" ] } ], "source": [ "guess_dynamics = objectives[0].propagate(\n", " tlist, propagator=expm, e_ops=[proj0, proj1], expect=expect\n", ")" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:41.178342Z", "start_time": "2020-03-24T21:13:41.172114Z" }, "attributes": { "classes": [], "id": "", "n": "13" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.584562Z", "iopub.status.busy": "2024-06-03T14:23:57.584425Z", "iopub.status.idle": "2024-06-03T14:23:57.586642Z", "shell.execute_reply": "2024-06-03T14:23:57.586302Z" } }, "outputs": [], "source": [ "def plot_population(result):\n", " fig, ax = plt.subplots()\n", " ax.plot(result.times, result.expect[0], label='0')\n", " ax.plot(result.times, result.expect[1], label='1')\n", " ax.legend()\n", " ax.set_xlabel('time')\n", " ax.set_ylabel('population')\n", " plt.show(fig)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:41.395497Z", "start_time": "2020-03-24T21:13:41.181086Z" }, "attributes": { "classes": [], "id": "", "n": "14" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.588919Z", "iopub.status.busy": "2024-06-03T14:23:57.588769Z", "iopub.status.idle": "2024-06-03T14:23:57.788571Z", "shell.execute_reply": "2024-06-03T14:23:57.787424Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_population(guess_dynamics)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The result is the same as in the original example.\n", "\n", "## Optimize\n", "\n", "First, we define the update shape and step width as before:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:41.404539Z", "start_time": "2020-03-24T21:13:41.397827Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.796425Z", "iopub.status.busy": "2024-06-03T14:23:57.795886Z", "iopub.status.idle": "2024-06-03T14:23:57.803552Z", "shell.execute_reply": "2024-06-03T14:23:57.802616Z" } }, "outputs": [], "source": [ "def S(t):\n", " \"\"\"Shape function for the field update\"\"\"\n", " return krotov.shapes.flattop(\n", " t, t_start=0, t_stop=5, t_rise=0.3, t_fall=0.3, func='blackman'\n", " )" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:41.412374Z", "start_time": "2020-03-24T21:13:41.406924Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.811656Z", "iopub.status.busy": "2024-06-03T14:23:57.811251Z", "iopub.status.idle": "2024-06-03T14:23:57.823075Z", "shell.execute_reply": "2024-06-03T14:23:57.817756Z" } }, "outputs": [], "source": [ "pulse_options = {\n", " H[1][1]: dict(lambda_a=5, update_shape=S)\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can run the optimization with only small additional adjustments. This is\n", "because Krotov's method internally does very little with the states and\n", "operators: nearly all of the numerical effort is in the propagator, which we\n", "have already defined above for the specific use of numpy arrays.\n", "\n", "Beyond this, the optimization only needs to know three things: First, it must\n", "know how to calculate and apply the operator $\\partial H/\\partial \\epsilon$. We\n", "can easily teach it how to do this:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:41.423350Z", "start_time": "2020-03-24T21:13:41.415715Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.829078Z", "iopub.status.busy": "2024-06-03T14:23:57.828463Z", "iopub.status.idle": "2024-06-03T14:23:57.834886Z", "shell.execute_reply": "2024-06-03T14:23:57.832323Z" } }, "outputs": [], "source": [ "def mu(objectives, i_objective, pulses, pulses_mapping, i_pulse, time_index):\n", " def _mu(state):\n", " return H[1][0] @ state\n", " return _mu" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Second, the pulse updates are calculated from an overlap of states, and we\n", "define an appropriate function for numpy arrays:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:41.432372Z", "start_time": "2020-03-24T21:13:41.427434Z" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.839276Z", "iopub.status.busy": "2024-06-03T14:23:57.838954Z", "iopub.status.idle": "2024-06-03T14:23:57.848829Z", "shell.execute_reply": "2024-06-03T14:23:57.848176Z" } }, "outputs": [], "source": [ "def overlap(psi1, psi2):\n", " return complex(psi1.conj().T @ psi2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Third, it must know how to calculate the norm of states, for which we can use `np.linalg.norm`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "By passing all these routines to `optimize_pulses`, we get the exact same\n", "results as in the original example, except much faster:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:45.052773Z", "start_time": "2020-03-24T21:13:41.436123Z" }, "attributes": { "classes": [], "id": "", "n": "15" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:57.858243Z", "iopub.status.busy": "2024-06-03T14:23:57.854303Z", "iopub.status.idle": "2024-06-03T14:23:58.390263Z", "shell.execute_reply": "2024-06-03T14:23:58.389983Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter. J_T ∫gₐ(t)dt J ΔJ_T ΔJ secs\n", "0 9.51e-01 0.00e+00 9.51e-01 n/a n/a 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "1 9.24e-01 1.20e-02 9.36e-01 -2.71e-02 -1.50e-02 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2 8.83e-01 1.83e-02 9.02e-01 -4.11e-02 -2.28e-02 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "3 8.23e-01 2.71e-02 8.50e-01 -6.06e-02 -3.35e-02 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "4 7.37e-01 3.84e-02 7.76e-01 -8.52e-02 -4.68e-02 0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/mm/rr6dgkzj0l5_j_ntxcg_hlth0000gn/T/ipykernel_52079/124890641.py:2: 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", " return complex(psi1.conj().T @ psi2)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "5 6.26e-01 5.07e-02 6.77e-01 -1.11e-01 -6.05e-02 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "6 4.96e-01 6.04e-02 5.56e-01 -1.31e-01 -7.02e-02 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "7 3.62e-01 6.30e-02 4.25e-01 -1.34e-01 -7.09e-02 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "8 2.44e-01 5.65e-02 3.00e-01 -1.18e-01 -6.15e-02 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "9 1.53e-01 4.39e-02 1.97e-01 -9.03e-02 -4.64e-02 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "10 9.20e-02 3.02e-02 1.22e-01 -6.14e-02 -3.12e-02 0\n" ] } ], "source": [ "opt_result = krotov.optimize_pulses(\n", " objectives,\n", " pulse_options=pulse_options,\n", " tlist=tlist,\n", " propagator=expm,\n", " chi_constructor=krotov.functionals.chis_ss,\n", " info_hook=krotov.info_hooks.print_table(J_T=krotov.functionals.J_T_ss),\n", " check_convergence=krotov.convergence.check_monotonic_error,\n", " iter_stop=10,\n", " norm=np.linalg.norm,\n", " mu=mu,\n", " overlap=overlap,\n", ")" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "ExecuteTime": { "end_time": "2020-03-24T21:13:45.060650Z", "start_time": "2020-03-24T21:13:45.054855Z" }, "attributes": { "classes": [], "id": "", "n": "16" }, "execution": { "iopub.execute_input": "2024-06-03T14:23:58.391772Z", "iopub.status.busy": "2024-06-03T14:23:58.391640Z", "iopub.status.idle": "2024-06-03T14:23:58.393703Z", "shell.execute_reply": "2024-06-03T14:23:58.393450Z" } }, "outputs": [ { "data": { "text/plain": [ "Krotov Optimization Result\n", "--------------------------\n", "- Started at 2024-06-03 10:23:57\n", "- Number of objectives: 1\n", "- Number of iterations: 10\n", "- Reason for termination: Reached 10 iterations\n", "- Ended at 2024-06-03 10:23:58 (0:00:01)" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "opt_result" ] } ], "metadata": { "hide_input": false, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "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.12.0" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }