{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "code", "execution_count": null, "metadata": { "id": "Jo2_AFTcj6kv" }, "outputs": [], "source": [ "!pip install -q pyomo" ] }, { "cell_type": "code", "source": [ "!apt-get install -y -qq glpk-utils" ], "metadata": { "id": "09XhHawVj81s" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "!apt-get install -y -qq coinor-cbc" ], "metadata": { "id": "XV0iEmdJRrsu" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "from pyomo.environ import *\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from google.colab import files" ], "metadata": { "id": "9tiuahJPlLd3" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def cargarModelo():\n", " # max f1 = X1 \n", " # max f2 = 3 X1 + 4 X2 \n", " # st X1 <= 20 \n", " # X2 <= 40 \n", " # 5 X1 + 4 X2 <= 200 \n", "\n", " model = ConcreteModel()\n", "\n", " model.X1 = Var(within=NonNegativeReals)\n", " model.X2 = Var(within=NonNegativeReals)\n", "\n", " model.C1 = Constraint(expr = model.X1 <= 20)\n", " model.C2 = Constraint(expr = model.X2 <= 40)\n", " model.C3 = Constraint(expr = 5 * model.X1 + 4 * model.X2 <= 200)\n", "\n", " model.f1 = Var()\n", " model.f2 = Var()\n", " model.C_f1 = Constraint(expr= model.f1 == model.X1)\n", " model.C_f2 = Constraint(expr= model.f2 == 3 * model.X1 + 4 * model.X2)\n", " model.O_f1 = Objective(expr= model.f1 , sense=maximize)\n", " model.O_f2 = Objective(expr= model.f2 , sense=maximize)\n", "\n", " return model" ], "metadata": { "id": "aTRq-_LjEH81" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def encontrarExtremos(model):\n", "\n", " # Para usar glpk\n", " solver = SolverFactory('glpk')\n", " # Opciones para glpk\n", " solver.options = {'tmlim': 20, 'mipgap': 0.00}\n", "\n", " # Para usar CBC\n", " #solver = SolverFactory('cbc')\n", " # Opciones para CBC\n", " #solver.options = {'sec': 20, 'threads': 6, 'ratio': 0.00}\n", "\n", " model.O_f2.deactivate()\n", " model.O_f1.activate()\n", "\n", " solver.solve(model, tee=False)\n", "\n", " print('Extremo 1')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " f2_min = value(model.f2)\n", " f1_max = value(model.f1)\n", "\n", " # ## max f2\n", "\n", " model.O_f2.activate()\n", " model.O_f1.deactivate()\n", "\n", " solver.solve(model, tee=False);\n", "\n", " print('Extremo 2')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " f2_max = value(model.f2)\n", " f1_min = value(model.f1)\n", "\n", " model.O_f1.activate()\n", "\n", " return f2_min, f2_max, f1_min, f1_max, solver" ], "metadata": { "id": "9XfG0Kktq-QR" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "model = cargarModelo()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremos(model)" ], "metadata": { "id": "GeLLF-VAlE27" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def encontrarExtremosLexicographic(model):\n", "\n", " # Para usar glpk\n", " solver = SolverFactory('glpk')\n", " # Opciones para glpk\n", " solver.options = {'tmlim': 20, 'mipgap': 0.02}\n", "\n", " # Para usar CBC\n", " #solver = SolverFactory('cbc')\n", " # Opciones para CBC\n", " #solver.options = {'sec': 20, 'threads': 6, 'ratio': 0.02}\n", "\n", " # Maximizo f1 libremente\n", " model.O_f2.deactivate()\n", " model.O_f1.activate()\n", "\n", " solver.solve(model)\n", "\n", " print('Extremo 1')\n", " print('Primer paso')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " f1_max = value(model.f1)\n", "\n", " # max f2 subjected to f1 does not worsen\n", " model.O_f2.activate()\n", " model.O_f1.deactivate()\n", " # Agrego restricción que impide empeorar a f1\n", " model.C_epsilon = Constraint(expr = model.f1 >= f1_max)\n", "\n", " solver.solve(model)\n", "\n", " print('Segundo paso')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " # tomar el mínimo de f2 sobre el frente de Pareto\n", " f2_min = value(model.f2)\n", " # Elimino restricción que impide empeorar a f1 para volver \n", " # el modelo a su estado original\n", " model.del_component(model.C_epsilon)\n", "\n", " # Maximizo f2 libremente\n", " model.O_f1.deactivate()\n", " model.O_f2.activate()\n", "\n", " solver.solve(model)\n", "\n", " print('Extremo 2')\n", " print('Primer paso')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " f2_max = value(model.f2)\n", " #f1_min = value(model.f1)\n", "\n", " # max f1 sujeto a que f2 no empeore\n", " model.O_f1.activate()\n", " model.O_f2.deactivate()\n", " # Agrego restricción que impide empeorar a f2\n", " model.C_epsilon = Constraint(expr = model.f2 >= f2_max)\n", " \n", " solver.solve(model)\n", "\n", " print('Segundo paso')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " # tomar el mínimo de f1 sobre el frente de Pareto\n", " f1_min = value(model.f1)\n", "\n", " # Elimino restricción que impide empeorar a f2 para volver \n", " # el modelo a su estado original\n", " model.del_component(model.C_epsilon)\n", "\n", " model.O_f1.activate()\n", "\n", " return f2_min, f2_max, f1_min, f1_max, solver" ], "metadata": { "id": "q1bdkb7dOj7T" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "model = cargarModelo()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremosLexicographic(model)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "aC9uWQj9OqSO", "outputId": "57271423-d383-4322-c0c8-45c88e6ec65b" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Extremo 1\n", "Primer paso\n", "( X1 , X2 ) = ( 20.0 , 0.0 )\n", "f1 = 20.0\n", "f2 = 60.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 20.0 , 25.0 )\n", "f1 = 20.0\n", "f2 = 160.0\n", "Extremo 2\n", "Primer paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n" ] } ] }, { "cell_type": "code", "source": [ "def applyNormalizedWeightingSum(model, f2_min, f2_max, f1_min, f1_max, solver, n):\n", "\n", " # Aplicar Programación por compromiso normalizada\n", "\n", " model.O_f1.deactivate()\n", " model.O_f2.deactivate()\n", "\n", " model.w1 = Param(initialize=0, mutable=True, within = NonNegativeReals)\n", " model.w2 = Param(initialize=0, mutable=True, within = NonNegativeReals)\n", " model.O_f = Objective(expr= ( (f1_max - model.f1)/(f1_max - f1_min) ) * model.w1 + ( (f2_max - model.f2)/(f2_max - f2_min) ) * model.w2 , sense=minimize)\n", "\n", " step = 1/n\n", "\n", " x1_l = []\n", " x2_l = []\n", " f1_l = []\n", " f2_l = []\n", "\n", " for i in range(n):\n", " model.w1 = i * step\n", " cte = i * step\n", " model.w2 = 1 - cte\n", "\n", " solver.solve(model)\n", "\n", " x1_l.append(value(model.X1))\n", " x2_l.append(value(model.X2)) \n", " f1_l.append(value(model.f1))\n", " f2_l.append(value(model.f2))\n", "\n", " print(\"Sol vars - it:\" + str(i) + \" x1= \" + str(x1_l[len(x1_l)-1]) + \" x2= \" + str(x2_l[len(x2_l)-1]))\n", " print(\"Sol FO - it:\" + str(i) + \" f1= \" + str(f1_l[len(f1_l)-1]) + \" f2= \" + str(f2_l[len(f2_l)-1]))\n", "\n", " # para graficar\n", " plt.plot(x1_l,x2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Normalized Weighted Sum Pareto-front Vars')\n", " plt.xlabel(\"X1\", fontsize = 10)\n", " plt.ylabel(\"X2\", fontsize = 10) \n", " plt.grid(True)\n", " plt.savefig(\"Normalized Weighted Sum - Vars\", dpi = 600, bbox_inches=\"tight\")\n", " plt.show()\n", " plt.close()\n", "\n", " plt.plot(f1_l,f2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Normalized Weighted Sum Pareto-front FO')\n", " plt.xlabel(\"f1\", fontsize = 10)\n", " plt.ylabel(\"f2\", fontsize = 10) \n", " plt.grid(True)\n", " plt.savefig(\"Normalized Weighted Sum - FO\", dpi = 600, bbox_inches=\"tight\")\n", " plt.show()\n", " #files.download(\"Normalized Weighted Sum - FO.png\") \n", " plt.close()\n", "\n", " model.del_component(model.O_f)\n", " model.del_component(model.w1)\n", " model.del_component(model.w2)\n", " model.O_f1.activate()\n", " model.O_f2.activate()" ], "metadata": { "id": "0VzT0nzVovy6" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "model = cargarModelo()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremosLexicographic(model)\n", "n = 10\n", "applyNormalizedWeightingSum(model, f2_min, f2_max, f1_min, f1_max, solver, n)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "0eA5fV_Do9mN", "outputId": "2231018d-98b1-4076-ca41-fa37c98c1a8c" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Extremo 1\n", "Primer paso\n", "( X1 , X2 ) = ( 20.0 , 0.0 )\n", "f1 = 20.0\n", "f2 = 60.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 20.0 , 25.0 )\n", "f1 = 20.0\n", "f2 = 160.0\n", "Extremo 2\n", "Primer paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Sol vars - it:0 x1= 8.0 x2= 40.0\n", "Sol FO - it:0 f1= 8.0 f2= 184.0\n", "Sol vars - it:1 x1= 8.0 x2= 40.0\n", "Sol FO - it:1 f1= 8.0 f2= 184.0\n", "Sol vars - it:2 x1= 8.0 x2= 40.0\n", "Sol FO - it:2 f1= 8.0 f2= 184.0\n", "Sol vars - it:3 x1= 8.0 x2= 40.0\n", "Sol FO - it:3 f1= 8.0 f2= 184.0\n", "Sol vars - it:4 x1= 8.0 x2= 40.0\n", "Sol FO - it:4 f1= 8.0 f2= 184.0\n", "Sol vars - it:5 x1= 20.0 x2= 25.0\n", "Sol FO - it:5 f1= 20.0 f2= 160.0\n", "Sol vars - it:6 x1= 20.0 x2= 25.0\n", "Sol FO - it:6 f1= 20.0 f2= 160.0\n", "Sol vars - it:7 x1= 20.0 x2= 25.0\n", "Sol FO - it:7 f1= 20.0 f2= 160.0\n", "Sol vars - it:8 x1= 20.0 x2= 25.0\n", "Sol FO - it:8 f1= 20.0 f2= 160.0\n", "Sol vars - it:9 x1= 20.0 x2= 25.0\n", "Sol FO - it:9 f1= 20.0 f2= 160.0\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "code", "source": [ "def applyNormalEpsilonConstraint(model, f2_min, f2_max, solver, n):\n", "\n", " # ## apply normal $\\epsilon$-Constraint\n", "\n", " model.O_f1.activate()\n", " model.O_f2.deactivate()\n", "\n", " model.e = Param(initialize=0, mutable=True)\n", "\n", " model.C_epsilon = Constraint(expr = model.f2 >= model.e)\n", "\n", " #solver.solve(model)\n", "\n", " step = (f2_max - f2_min) / n\n", "\n", " x1_l = []\n", " x2_l = []\n", " f1_l = []\n", " f2_l = []\n", "\n", " i = 0\n", " while i < n + 1:\n", " model.e = f2_min + i * step\n", " e_ = f2_min + i * step\n", "\n", " solver.solve(model)\n", "\n", " x1_l.append(value(model.X1))\n", " x2_l.append(value(model.X2))\n", " f1_l.append(value(model.f1))\n", " f2_l.append(value(model.f2))\n", "\n", " print(\"Epsilon \" + str(e_))\n", " print(\"Sol vars - it:\" + str(i) + \" x1= \" + str(x1_l[len(x1_l)-1]) + \" x2= \" + str(x2_l[len(x2_l)-1]))\n", " print(\"Sol FO - it:\" + str(i) + \" f1= \" + str(f1_l[len(f1_l)-1]) + \" f2= \" + str(f2_l[len(f2_l)-1]))\n", "\n", " i = i + 1\n", "\n", " plt.plot(x1_l,x2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Normal epsilon-Constraint Pareto-front Vars')\n", " plt.xlabel(\"X1\", fontsize = 10)\n", " plt.ylabel(\"X2\", fontsize = 10) \n", " plt.grid(True)\n", " #plt.savefig(\"Normal epsilon-Constraint - Vars\", dpi = 600, bbox_inches=\"tight\")\n", " plt.show()\n", " plt.close()\n", "\n", " plt.plot(f1_l,f2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Normal epsilon-Constraint Pareto-front FO')\n", " plt.xlabel(\"f1\", fontsize = 10)\n", " plt.ylabel(\"f2\", fontsize = 10) \n", " plt.grid(True)\n", " #plt.savefig(\"Normal epsilon-Constraint - FO\", dpi = 600, bbox_inches=\"tight\")\n", " #files.download(\"Normal epsilon-Constraint - FO.png\") \n", " plt.show()\n", " plt.close()\n", "\n", " model.del_component(model.C_epsilon)\n", " model.del_component(model.e)" ], "metadata": { "id": "jh9GRN9Tthv0" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [], "metadata": { "id": "92mLdoUmz_xM" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "model = cargarModelo()\n", "#model = cargarModelo_int()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremosLexicographic(model)\n", "n = 20\n", "applyNormalEpsilonConstraint(model, f2_min, f2_max, solver, n)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "11iuPyC7t0wV", "outputId": "32b31bb5-ceff-4584-c521-a8a5103a8466" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Extremo 1\n", "Primer paso\n", "( X1 , X2 ) = ( 20.0 , 0.0 )\n", "f1 = 20.0\n", "f2 = 60.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 20.0 , 25.0 )\n", "f1 = 20.0\n", "f2 = 160.0\n", "Extremo 2\n", "Primer paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Epsilon 160.0\n", "Sol vars - it:0 x1= 20.0 x2= 25.0\n", "Sol FO - it:0 f1= 20.0 f2= 160.0\n", "Epsilon 161.2\n", "Sol vars - it:1 x1= 19.4 x2= 25.75\n", "Sol FO - it:1 f1= 19.4 f2= 161.2\n", "Epsilon 162.4\n", "Sol vars - it:2 x1= 18.8 x2= 26.5\n", "Sol FO - it:2 f1= 18.8 f2= 162.4\n", "Epsilon 163.6\n", "Sol vars - it:3 x1= 18.2 x2= 27.25\n", "Sol FO - it:3 f1= 18.2 f2= 163.6\n", "Epsilon 164.8\n", "Sol vars - it:4 x1= 17.6 x2= 28.0\n", "Sol FO - it:4 f1= 17.6 f2= 164.8\n", "Epsilon 166.0\n", "Sol vars - it:5 x1= 17.0 x2= 28.75\n", "Sol FO - it:5 f1= 17.0 f2= 166.0\n", "Epsilon 167.2\n", "Sol vars - it:6 x1= 16.4 x2= 29.5\n", "Sol FO - it:6 f1= 16.4 f2= 167.2\n", "Epsilon 168.4\n", "Sol vars - it:7 x1= 15.8 x2= 30.25\n", "Sol FO - it:7 f1= 15.8 f2= 168.4\n", "Epsilon 169.6\n", "Sol vars - it:8 x1= 15.2 x2= 31.0\n", "Sol FO - it:8 f1= 15.2 f2= 169.6\n", "Epsilon 170.8\n", "Sol vars - it:9 x1= 14.6 x2= 31.75\n", "Sol FO - it:9 f1= 14.6 f2= 170.8\n", "Epsilon 172.0\n", "Sol vars - it:10 x1= 14.0 x2= 32.5\n", "Sol FO - it:10 f1= 14.0 f2= 172.0\n", "Epsilon 173.2\n", "Sol vars - it:11 x1= 13.4 x2= 33.25\n", "Sol FO - it:11 f1= 13.4 f2= 173.2\n", "Epsilon 174.4\n", "Sol vars - it:12 x1= 12.8 x2= 34.0\n", "Sol FO - it:12 f1= 12.8 f2= 174.4\n", "Epsilon 175.6\n", "Sol vars - it:13 x1= 12.2 x2= 34.75\n", "Sol FO - it:13 f1= 12.2 f2= 175.6\n", "Epsilon 176.8\n", "Sol vars - it:14 x1= 11.6 x2= 35.5\n", "Sol FO - it:14 f1= 11.6 f2= 176.8\n", "Epsilon 178.0\n", "Sol vars - it:15 x1= 11.0 x2= 36.25\n", "Sol FO - it:15 f1= 11.0 f2= 178.0\n", "Epsilon 179.2\n", "Sol vars - it:16 x1= 10.4 x2= 37.0\n", "Sol FO - it:16 f1= 10.4 f2= 179.2\n", "Epsilon 180.4\n", "Sol vars - it:17 x1= 9.8 x2= 37.75\n", "Sol FO - it:17 f1= 9.8 f2= 180.4\n", "Epsilon 181.6\n", "Sol vars - it:18 x1= 9.2 x2= 38.5\n", "Sol FO - it:18 f1= 9.2 f2= 181.6\n", "Epsilon 182.8\n", "Sol vars - it:19 x1= 8.6 x2= 39.25\n", "Sol FO - it:19 f1= 8.6 f2= 182.8\n", "Epsilon 184.0\n", "Sol vars - it:20 x1= 8.0 x2= 40.0\n", "Sol FO - it:20 f1= 8.0 f2= 184.0\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "application/javascript": [ "\n", " async function download(id, filename, size) {\n", " if (!google.colab.kernel.accessAllowed) {\n", " return;\n", " }\n", " const div = document.createElement('div');\n", " const label = document.createElement('label');\n", " label.textContent = `Downloading \"${filename}\": `;\n", " div.appendChild(label);\n", " const progress = document.createElement('progress');\n", " progress.max = size;\n", " div.appendChild(progress);\n", " document.body.appendChild(div);\n", "\n", " const buffers = [];\n", " let downloaded = 0;\n", "\n", " const channel = await google.colab.kernel.comms.open(id);\n", " // Send a message to notify the kernel that we're ready.\n", " channel.send({})\n", "\n", " for await (const message of channel.messages) {\n", " // Send a message to notify the kernel that we're ready.\n", " channel.send({})\n", " if (message.buffers) {\n", " for (const buffer of message.buffers) {\n", " buffers.push(buffer);\n", " downloaded += buffer.byteLength;\n", " progress.value = downloaded;\n", " }\n", " }\n", " }\n", " const blob = new Blob(buffers, {type: 'application/binary'});\n", " const a = document.createElement('a');\n", " a.href = window.URL.createObjectURL(blob);\n", " a.download = filename;\n", " div.appendChild(a);\n", " a.click();\n", " div.remove();\n", " }\n", " " ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "application/javascript": [ "download(\"download_a4949f93-70a4-42de-b7ac-fc6a693e48e5\", \"Normal epsilon-Constraint - FO.png\", 136365)" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] } ] }