diff --git a/AutoGPT.ipynb b/AutoGPT.ipynb new file mode 100644 index 0000000..a08803e --- /dev/null +++ b/AutoGPT.ipynb @@ -0,0 +1,313 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WId1soeCTrje" + }, + "source": [ + "# AUTO GPT\n", + "Repositorio GITHUB: https://github.com/Torantulino/Auto-GPT.\n", + "\n", + "Creador de la hoja de Colab: **Álex Goia - Youtube: alexgoiadev**\n", + "\n", + "*Auto-GPT es una aplicación experimental de código abierto que muestra las capacidades del modelo de lenguaje GPT-4. Este programa, impulsado por GPT-4 , encadena los “pensamientos” de LLM para lograr de forma autónoma cualquier objetivo que te hayas fijado.*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PbQp5imIT2mf" + }, + "source": [ + "## Añade tu clave de openai\n", + "Aquí puedes ver cómo: https://www.youtube.com/watch?v=3JE6-_1wYBs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "IFbGo6miQjl-" + }, + "outputs": [], + "source": [ + "import os\n", + "api_key = \"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\" #@param {type:\"string\"}\n", + "os.environ[\"OPENAI_API_KEY\"] = api_key\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bYu5dgXCbUrj" + }, + "source": [ + "## *Instalación* 🍹\n", + "Instalamos repositorio y las dependencias necesarias" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kKycBEp5THBT", + "outputId": "805596c2-3f56-4a72-d223-334c9d6279d1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cloning into 'Auto-GPT'...\n", + "remote: Enumerating objects: 4053, done.\u001b[K\n", + "remote: Counting objects: 100% (8/8), done.\u001b[K\n", + "remote: Compressing objects: 100% (8/8), done.\u001b[K\n", + "remote: Total 4053 (delta 0), reused 5 (delta 0), pack-reused 4045\u001b[K\n", + "Receiving objects: 100% (4053/4053), 1.03 MiB | 5.16 MiB/s, done.\n", + "Resolving deltas: 100% (2694/2694), done.\n", + "/content/Auto-GPT\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 1)) (4.11.2)\n", + "Requirement already satisfied: colorama==0.4.6 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 2)) (0.4.6)\n", + "Requirement already satisfied: openai==0.27.2 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 3)) (0.27.2)\n", + "Requirement already satisfied: playsound==1.2.2 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 4)) (1.2.2)\n", + "Requirement already satisfied: python-dotenv==1.0.0 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 5)) (1.0.0)\n", + "Requirement already satisfied: pyyaml==6.0 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 6)) (6.0)\n", + "Requirement already satisfied: readability-lxml==0.8.1 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 7)) (0.8.1)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 8)) (2.28.2)\n", + "Requirement already satisfied: tiktoken==0.3.3 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 9)) (0.3.3)\n", + "Requirement already satisfied: gTTS==2.3.1 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 10)) (2.3.1)\n", + "Requirement already satisfied: docker in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 11)) (6.0.1)\n", + "Requirement already satisfied: duckduckgo-search in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 12)) (2.8.6)\n", + "Requirement already satisfied: google-api-python-client in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 13)) (2.84.0)\n", + "Requirement already satisfied: pinecone-client==2.2.1 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 14)) (2.2.1)\n", + "Requirement already satisfied: redis in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 15)) (4.5.4)\n", + "Requirement already satisfied: orjson in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 16)) (3.8.10)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 17)) (8.4.0)\n", + "Requirement already satisfied: selenium in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 18)) (4.8.3)\n", + "Requirement already satisfied: webdriver-manager in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 19)) (3.8.6)\n", + "Requirement already satisfied: coverage in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 20)) (7.2.3)\n", + "Requirement already satisfied: flake8 in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 21)) (6.0.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 22)) (1.22.4)\n", + "Requirement already satisfied: pre-commit in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 23)) (3.2.2)\n", + "Requirement already satisfied: black in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 24)) (23.3.0)\n", + "Requirement already satisfied: sourcery in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 25)) (1.2.0)\n", + "Requirement already satisfied: isort in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 26)) (5.12.0)\n", + "Requirement already satisfied: aiohttp in /usr/local/lib/python3.9/dist-packages (from openai==0.27.2->-r requirements.txt (line 3)) (3.8.4)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.9/dist-packages (from openai==0.27.2->-r requirements.txt (line 3)) (4.65.0)\n", + "Requirement already satisfied: lxml in /usr/local/lib/python3.9/dist-packages (from readability-lxml==0.8.1->-r requirements.txt (line 7)) (4.9.2)\n", + "Requirement already satisfied: chardet in /usr/local/lib/python3.9/dist-packages (from readability-lxml==0.8.1->-r requirements.txt (line 7)) (4.0.0)\n", + "Requirement already satisfied: cssselect in /usr/local/lib/python3.9/dist-packages (from readability-lxml==0.8.1->-r requirements.txt (line 7)) (1.2.0)\n", + "Requirement already satisfied: regex>=2022.1.18 in /usr/local/lib/python3.9/dist-packages (from tiktoken==0.3.3->-r requirements.txt (line 9)) (2022.10.31)\n", + "Requirement already satisfied: click<8.2,>=7.1 in /usr/local/lib/python3.9/dist-packages (from gTTS==2.3.1->-r requirements.txt (line 10)) (8.1.3)\n", + "Requirement already satisfied: urllib3>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from pinecone-client==2.2.1->-r requirements.txt (line 14)) (1.26.15)\n", + "Requirement already satisfied: typing-extensions>=3.7.4 in /usr/local/lib/python3.9/dist-packages (from pinecone-client==2.2.1->-r requirements.txt (line 14)) (4.5.0)\n", + "Requirement already satisfied: python-dateutil>=2.5.3 in /usr/local/lib/python3.9/dist-packages (from pinecone-client==2.2.1->-r requirements.txt (line 14)) (2.8.2)\n", + "Requirement already satisfied: dnspython>=2.0.0 in /usr/local/lib/python3.9/dist-packages (from pinecone-client==2.2.1->-r requirements.txt (line 14)) (2.3.0)\n", + "Requirement already satisfied: loguru>=0.5.0 in /usr/local/lib/python3.9/dist-packages (from pinecone-client==2.2.1->-r requirements.txt (line 14)) (0.7.0)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.9/dist-packages (from beautifulsoup4->-r requirements.txt (line 1)) (2.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests->-r requirements.txt (line 8)) (3.4)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/dist-packages (from requests->-r requirements.txt (line 8)) (2.0.12)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests->-r requirements.txt (line 8)) (2022.12.7)\n", + "Requirement already satisfied: packaging>=14.0 in /usr/local/lib/python3.9/dist-packages (from docker->-r requirements.txt (line 11)) (23.0)\n", + "Requirement already satisfied: websocket-client>=0.32.0 in /usr/local/lib/python3.9/dist-packages (from docker->-r requirements.txt (line 11)) (1.5.1)\n", + "Requirement already satisfied: httplib2<1dev,>=0.15.0 in /usr/local/lib/python3.9/dist-packages (from google-api-python-client->-r requirements.txt (line 13)) (0.21.0)\n", + "Requirement already satisfied: google-auth<3.0.0dev,>=1.19.0 in /usr/local/lib/python3.9/dist-packages (from google-api-python-client->-r requirements.txt (line 13)) (2.17.2)\n", + "Requirement already satisfied: uritemplate<5,>=3.0.1 in /usr/local/lib/python3.9/dist-packages (from google-api-python-client->-r requirements.txt (line 13)) (4.1.1)\n", + "Requirement already satisfied: google-auth-httplib2>=0.1.0 in /usr/local/lib/python3.9/dist-packages (from google-api-python-client->-r requirements.txt (line 13)) (0.1.0)\n", + "Requirement already satisfied: google-api-core!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0,<3.0.0dev,>=1.31.5 in /usr/local/lib/python3.9/dist-packages (from google-api-python-client->-r requirements.txt (line 13)) (2.11.0)\n", + "Requirement already satisfied: async-timeout>=4.0.2 in /usr/local/lib/python3.9/dist-packages (from redis->-r requirements.txt (line 15)) (4.0.2)\n", + "Requirement already satisfied: trio~=0.17 in /usr/local/lib/python3.9/dist-packages (from selenium->-r requirements.txt (line 18)) (0.22.0)\n", + "Requirement already satisfied: trio-websocket~=0.9 in /usr/local/lib/python3.9/dist-packages (from selenium->-r requirements.txt (line 18)) (0.10.2)\n", + "Requirement already satisfied: pycodestyle<2.11.0,>=2.10.0 in /usr/local/lib/python3.9/dist-packages (from flake8->-r requirements.txt (line 21)) (2.10.0)\n", + "Requirement already satisfied: mccabe<0.8.0,>=0.7.0 in /usr/local/lib/python3.9/dist-packages (from flake8->-r requirements.txt (line 21)) (0.7.0)\n", + "Requirement already satisfied: pyflakes<3.1.0,>=3.0.0 in /usr/local/lib/python3.9/dist-packages (from flake8->-r requirements.txt (line 21)) (3.0.1)\n", + "Requirement already satisfied: identify>=1.0.0 in /usr/local/lib/python3.9/dist-packages (from pre-commit->-r requirements.txt (line 23)) (2.5.22)\n", + "Requirement already satisfied: nodeenv>=0.11.1 in /usr/local/lib/python3.9/dist-packages (from pre-commit->-r requirements.txt (line 23)) (1.7.0)\n", + "Requirement already satisfied: virtualenv>=20.10.0 in /usr/local/lib/python3.9/dist-packages (from pre-commit->-r requirements.txt (line 23)) (20.21.0)\n", + "Requirement already satisfied: cfgv>=2.0.0 in /usr/local/lib/python3.9/dist-packages (from pre-commit->-r requirements.txt (line 23)) (3.3.1)\n", + "Requirement already satisfied: pathspec>=0.9.0 in /usr/local/lib/python3.9/dist-packages (from black->-r requirements.txt (line 24)) (0.11.1)\n", + "Requirement already satisfied: platformdirs>=2 in /usr/local/lib/python3.9/dist-packages (from black->-r requirements.txt (line 24)) (3.2.0)\n", + "Requirement already satisfied: mypy-extensions>=0.4.3 in /usr/local/lib/python3.9/dist-packages (from black->-r requirements.txt (line 24)) (1.0.0)\n", + "Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.9/dist-packages (from black->-r requirements.txt (line 24)) (2.0.1)\n", + "Requirement already satisfied: protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.19.5 in /usr/local/lib/python3.9/dist-packages (from google-api-core!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0,<3.0.0dev,>=1.31.5->google-api-python-client->-r requirements.txt (line 13)) (3.20.3)\n", + "Requirement already satisfied: googleapis-common-protos<2.0dev,>=1.56.2 in /usr/local/lib/python3.9/dist-packages (from google-api-core!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0,<3.0.0dev,>=1.31.5->google-api-python-client->-r requirements.txt (line 13)) (1.59.0)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.9/dist-packages (from google-auth<3.0.0dev,>=1.19.0->google-api-python-client->-r requirements.txt (line 13)) (4.9)\n", + "Requirement already satisfied: six>=1.9.0 in /usr/local/lib/python3.9/dist-packages (from google-auth<3.0.0dev,>=1.19.0->google-api-python-client->-r requirements.txt (line 13)) (1.16.0)\n", + "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.9/dist-packages (from google-auth<3.0.0dev,>=1.19.0->google-api-python-client->-r requirements.txt (line 13)) (5.3.0)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.9/dist-packages (from google-auth<3.0.0dev,>=1.19.0->google-api-python-client->-r requirements.txt (line 13)) (0.2.8)\n", + "Requirement already satisfied: pyparsing!=3.0.0,!=3.0.1,!=3.0.2,!=3.0.3,<4,>=2.4.2 in /usr/local/lib/python3.9/dist-packages (from httplib2<1dev,>=0.15.0->google-api-python-client->-r requirements.txt (line 13)) (3.0.9)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.9/dist-packages (from nodeenv>=0.11.1->pre-commit->-r requirements.txt (line 23)) (67.6.1)\n", + "Requirement already satisfied: outcome in /usr/local/lib/python3.9/dist-packages (from trio~=0.17->selenium->-r requirements.txt (line 18)) (1.2.0)\n", + "Requirement already satisfied: sortedcontainers in /usr/local/lib/python3.9/dist-packages (from trio~=0.17->selenium->-r requirements.txt (line 18)) (2.4.0)\n", + "Requirement already satisfied: async-generator>=1.9 in /usr/local/lib/python3.9/dist-packages (from trio~=0.17->selenium->-r requirements.txt (line 18)) (1.10)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.9/dist-packages (from trio~=0.17->selenium->-r requirements.txt (line 18)) (1.3.0)\n", + "Requirement already satisfied: exceptiongroup>=1.0.0rc9 in /usr/local/lib/python3.9/dist-packages (from trio~=0.17->selenium->-r requirements.txt (line 18)) (1.1.1)\n", + "Requirement already satisfied: attrs>=19.2.0 in /usr/local/lib/python3.9/dist-packages (from trio~=0.17->selenium->-r requirements.txt (line 18)) (22.2.0)\n", + "Requirement already satisfied: wsproto>=0.14 in /usr/local/lib/python3.9/dist-packages (from trio-websocket~=0.9->selenium->-r requirements.txt (line 18)) (1.2.0)\n", + "Requirement already satisfied: PySocks!=1.5.7,<2.0,>=1.5.6 in /usr/local/lib/python3.9/dist-packages (from urllib3>=1.21.1->pinecone-client==2.2.1->-r requirements.txt (line 14)) (1.7.1)\n", + "Requirement already satisfied: distlib<1,>=0.3.6 in /usr/local/lib/python3.9/dist-packages (from virtualenv>=20.10.0->pre-commit->-r requirements.txt (line 23)) (0.3.6)\n", + "Requirement already satisfied: filelock<4,>=3.4.1 in /usr/local/lib/python3.9/dist-packages (from virtualenv>=20.10.0->pre-commit->-r requirements.txt (line 23)) (3.11.0)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.9/dist-packages (from aiohttp->openai==0.27.2->-r requirements.txt (line 3)) (1.3.3)\n", + "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.9/dist-packages (from aiohttp->openai==0.27.2->-r requirements.txt (line 3)) (1.8.2)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.9/dist-packages (from aiohttp->openai==0.27.2->-r requirements.txt (line 3)) (6.0.4)\n", + "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.9/dist-packages (from aiohttp->openai==0.27.2->-r requirements.txt (line 3)) (1.3.1)\n", + "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.9/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3.0.0dev,>=1.19.0->google-api-python-client->-r requirements.txt (line 13)) (0.4.8)\n", + "Requirement already satisfied: h11<1,>=0.9.0 in /usr/local/lib/python3.9/dist-packages (from wsproto>=0.14->trio-websocket~=0.9->selenium->-r requirements.txt (line 18)) (0.14.0)\n" + ] + } + ], + "source": [ + "!git clone https://github.com/Torantulino/Auto-GPT \n", + "%cd /content/Auto-GPT \n", + "!pip install -r requirements.txt " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-0kby7V-UhYM" + }, + "source": [ + "## Ejecución ☝" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "background_save": true, + "base_uri": "https://localhost:8080/" + }, + "id": "WI8y8VvjUlSY", + "outputId": "02c01e85-4584-4210-eff2-b621e6ca5772" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: The file 'auto-gpt.json' does not exist. Local memory would not be saved to a file.\n", + "\u001b[32mWelcome to Auto-GPT! \u001b[0m Enter the name of your AI and its role below. Entering nothing will load defaults.\n", + "\u001b[32mName your AI: \u001b[0m For example, 'Entrepreneur-GPT'\n", + "AI Name: Twitter Trends\n", + "\u001b[94mTwitter Trends here! \u001b[0m I am at your service.\n", + "\u001b[32mDescribe your AI's role: \u001b[0m For example, 'an AI designed to autonomously develop and run businesses with the sole goal of increasing your net worth.'\n", + "Twitter Trends is: una inteligencia artificial que encuentre tweets virales sobre tecnología\n", + "\u001b[32mEnter up to 5 goals for your AI: \u001b[0m For example: Increase net worth, Grow Twitter Account, Develop and manage multiple businesses autonomously'\n", + "Enter nothing to load defaults, enter nothing when finished.\n", + "\u001b[94mGoal\u001b[0m 1: Busques 3 tendencias actuales sobre tecnología\n", + "\u001b[94mGoal\u001b[0m 2: Redactes 3 tweets \n", + "\u001b[94mGoal\u001b[0m 3: Listes por pantalla\n", + "\u001b[94mGoal\u001b[0m 4: \n", + "Using memory of type: LocalCache\n", + "\n", + "\u001b[33mTWITTER TRENDS THOUGHTS: \u001b[0m I think I should search for technology trends to find some viral tweets.\n", + "\u001b[33mREASONING: \u001b[0m Searching for the latest trends in technology can help me find viral tweets that are currently circulating on Twitter.\n", + "\u001b[33mPLAN: \u001b[0m\n", + "\u001b[32m- \u001b[0m Perform a Google search to find the latest trends in technology.\n", + "\u001b[32m- \u001b[0m Review the search results to identify viral tweets related to technology.\n", + "\u001b[32m- \u001b[0m Draft three tweets related to technology.\n", + "\u001b[32m- \u001b[0m List the tweets on the screen.\n", + "\u001b[33mCRITICISM: \u001b[0m I need to ensure that the tweets I draft are within the proper social and legal boundaries. I also need to ensure that the selected trends are recent enough to attract attention.\n", + "Attempting to fix JSON by finding outermost brackets \u001b[0m\n", + "\u001b[32mApparently json was fixed. \u001b[0m\n", + "\u001b[36mNEXT ACTION: \u001b[0m COMMAND = \u001b[36mgoogle\u001b[0m ARGUMENTS = \u001b[36m{'input': 'latest technology trends on Twitter'}\u001b[0m\n", + "Enter 'y' to authorise command, 'y -N' to run N continuous commands, 'n' to exit program, or enter feedback for Twitter Trends...\n", + "\u001b[35mInput:\u001b[0m\u001b[33mSYSTEM: \u001b[0m Human feedback:\n", + " \u001b[0m Warning: Failed to parse AI output, attempting to fix.\n", + " If you see this warning frequently, it's likely that your prompt is confusing the AI. Try changing it up slightly.\n", + "\u001b[31mFailed to fix AI output, telling the AI. \u001b[0m \n", + "\u001b[31mError: Invalid JSON\n", + " \u001b[0m Please let me know how I can assist you.\n", + "Attempting to fix JSON by finding outermost brackets \u001b[0m\n", + "\u001b[31mError: Invalid JSON, setting it to empty JSON now.\n", + " \u001b[0m \n", + "\u001b[33mTWITTER TRENDS THOUGHTS: \u001b[0m None\n", + "\u001b[33mREASONING: \u001b[0m None\n", + "\u001b[33mCRITICISM: \u001b[0m None\n", + "Attempting to fix JSON by finding outermost brackets \u001b[0m\n", + "\u001b[31mError: Invalid JSON, setting it to empty JSON now.\n", + " \u001b[0m \n", + "\u001b[36mNEXT ACTION: \u001b[0m COMMAND = \u001b[36mError:\u001b[0m ARGUMENTS = \u001b[36m'dict' object has no attribute 'replace'\u001b[0m\n", + "Enter 'y' to authorise command, 'y -N' to run N continuous commands, 'n' to exit program, or enter feedback for Twitter Trends...\n", + "\u001b[35mInput:\u001b[0my\n", + "\u001b[35m-=-=-=-=-=-=-= COMMAND AUTHORISED BY USER -=-=-=-=-=-=-= \u001b[0m\n", + "\u001b[33mSYSTEM: \u001b[0m Command Error: threw the following error: 'dict' object has no attribute 'replace'\n", + "\u001b[33mTWITTER TRENDS THOUGHTS: \u001b[0m I found an article about the latest technology trends, but it seems a bit too broad for what I'm looking for. Instead, I'll try to find technology trends for a specific industry.\n", + "\u001b[33mREASONING: \u001b[0m Finding technology trends for a specific industry can help me draft tweets on a topic that will be more likely to attract attention from a particular audience.\n", + "\u001b[33mPLAN: \u001b[0m\n", + "\u001b[32m- \u001b[0m Perform a Google search for technology trends related to a specific industry.\n", + "\u001b[32m- \u001b[0m Review the search results to identify viral tweets related to the industry.\n", + "\u001b[32m- \u001b[0m Draft three tweets related to technology and the industry.\n", + "\u001b[32m- \u001b[0m List the tweets on the screen.\n", + "\u001b[33mCRITICISM: \u001b[0m I need to ensure that the tweets I draft are within the proper social and legal boundaries. I also need to ensure that the selected trends are recent enough to attract attention. Additionally, I need to ensure that the technology trends I find are relevant to the industry.\n", + "Attempting to fix JSON by finding outermost brackets \u001b[0m\n", + "\u001b[32mApparently json was fixed. \u001b[0m\n", + "\u001b[36mNEXT ACTION: \u001b[0m COMMAND = \u001b[36mgoogle\u001b[0m ARGUMENTS = \u001b[36m{'input': 'technology trends [industry name] on Twitter'}\u001b[0m\n", + "Enter 'y' to authorise command, 'y -N' to run N continuous commands, 'n' to exit program, or enter feedback for Twitter Trends...\n", + "\u001b[35mInput:\u001b[0my\n", + "\u001b[35m-=-=-=-=-=-=-= COMMAND AUTHORISED BY USER -=-=-=-=-=-=-= \u001b[0m\n", + "\u001b[33mSYSTEM: \u001b[0m Command google returned: [ { \"title\": \"Top Industry Trends on Twitter to Watch in 2023 for Technology Sector ...\", \"href\": \"https://www.globaldata.com/reports/top-industry-trends-on-twitter-to-watch-in-2023-for-technology-sector//", \"body\": \"The \\\"Top Industry Trends on Twitter to Watch in 2023 for Technology Sector\\\" analyzed the top trends on Twitter tracked by GlobalData's Social Media Analytics platform, over the period 1st Jan 2021 - 28 Dec 2022 and identified the list of top six trends, which are shortlisted based on the total posts during the selected period. \\\"Fusion ...\" }, { \"title\": \"Twitter tech trends in 2021 - Protocol\", \"href\": \"https://www.protocol.com/biggest-tech-twitter-trends-2021/", \"body\": \"The biggest tech Twitter trends of 2021. Gary Gensler's top moments on crypto in 2021. China's nationalistic cancel culture was out of control in 2021. The best of the internet in 2021. What tech CEOs said this year (or, earnings calls crunched by AI) The year in enterprise tech. 2021 was a post-cable year. How 2021 changed the way we work forever\" }, { \"title\": \"Twitter Publishes New Industry Trend Reports Based on Rising Areas of ...\", \"href\": \"https://www.socialmediatoday.com/news/twitter-publishes-new-industry-trend-reports-based-on-rising-areas-of-tweet/617317//", \"body\": \"Twitter has published a new range of industry reports, based on rising trends, in order to provide more context as to the key elements of focus among its userbase in each sector.. The new trend reports, which Twitter's collectively calling its 'Birdseye Report', were compiled by Twitter data partners, including Hootsuite, Meltwater, Sprinklr and more.\" }, { \"title\": \"The Top 10 Tech Trends In 2023 Everyone Must Be Ready For - Forbes\", \"href\": \"https://www.forbes.com/sites/bernardmarr/2022/11/21/the-top-10-tech-trends-in-2023-everyone-must-be-ready-for//", \"body\": \"To stay on top of the latest on new and emerging business and tech trends, make sure to subscribe to my newsletter, follow me on Twitter, LinkedIn, and YouTube, and check out my books 'Tech ...\" }, { \"title\": \"Digital Trends (@DigitalTrends) / Twitter\", \"href\": \"https://twitter.com/DigitalTrends/", \"body\": \"Tech for the way we live. | TikTok & Instagram: @DigitalTrends. Portland, OR && New York, NY digitaltrends.com Joined May 2008. 1,266 Following. 1.9M Followers. Tweets. Replies. Media. Likes. Digital Trends's Tweets. ... Digital Trends. The Premier League offers some of the best soccer out there. We're here to tell you how to watch a free ...\" }, { \"title\": \"The Must-Follow Twitter Accounts For the Tech-Minded - Digital Trends\", \"href\": \"https://www.digitaltrends.com/social-media/tech-people-influencers-follow-twitter//", \"body\": \"LinkedIn. Similar to Swisher, Mims reports on and opines about the tech industry for The Wall Street Journal. His Twitter account is filled with news and his opinions about technology trends, and ...\" }, { \"title\": \"5 Twitter Trends for 2022/2023: Latest Predictions According To Experts\", \"href\": \"https://financesonline.com/twitter-trends//", \"body\": \"These are the company itself, market forces or external developments, and trends in social media and social search. It is in the context of these factors that we've identified these Twitter trends. 1. Twitter remains a dominant site for news. A 2018 Pew Research Center study revealed some interesting insights.\" }, { \"title\": \"Twitter list: top ten technology and innovation tweeters\", \"href\": \"https://www.theguardian.com/sustainable-business/twitter-list-technology-innovation-top-ten/", \"body\": \"Winner #indyvoices most influential tech tweeter ∞ UCL ∞ Founder @gotofdn @BCSWomen ∞ Trustee Bletchley Park ∞ Knitter ∞ 4 fab kids ∞ Legendary Punctuation!! Jeff McMahon @jeffmcmahon_chi\" } ]\n", + "\u001b[33mTWITTER TRENDS THOUGHTS: \u001b[0m I found a list of technology trends on Twitter. Now, I need to review the search results to identify viral tweets related to technology.\n", + "\u001b[33mREASONING: \u001b[0m Reviewing the search results to identify viral tweets related to the technology trends found can help me draft tweets that are more relevant and likely to attract attention.\n", + "\u001b[33mPLAN: \u001b[0m\n", + "\u001b[32m- \u001b[0m Browse the website to identify technology trends\\n- Perform a Google search for viral tweets related to the technology trends found.\\n- Draft three tweets inspired by the most popular tweets.\\n- List the tweets on the screen.\n", + "\u001b[33mCRITICISM: \u001b[0m I need to ensure that the selected tweets are recent enough and within the proper social and legal boundaries.\n", + "Attempting to fix JSON by finding outermost brackets \u001b[0m\n", + "\u001b[32mApparently json was fixed. \u001b[0m\n", + "\u001b[36mNEXT ACTION: \u001b[0m COMMAND = \u001b[36mbrowse_website\u001b[0m ARGUMENTS = \u001b[36m{'url': 'https://www.globaldata.com/reports/top-industry-trends-on-twitter-to-watch-in-2023-for-technology-sector/', 'question': 'What are the top technology trends found on Twitter?'}\u001b[0m\n", + "Enter 'y' to authorise command, 'y -N' to run N continuous commands, 'n' to exit program, or enter feedback for Twitter Trends...\n", + "\u001b[35mInput:\u001b[0my\n", + "\u001b[35m-=-=-=-=-=-=-= COMMAND AUTHORISED BY USER -=-=-=-=-=-=-= \u001b[0m\n", + "[WDM] - Downloading: 100% 6.75M/6.75M [00:01<00:00, 6.86MB/s]\n", + "\u001b[33mSYSTEM: \u001b[0m Command browse_website returned: Error: Message: unknown error: cannot find Chrome binary Stacktrace: #0 0x555a3a9d6fe3 #1 0x555a3a715d36 #2 0x555a3a73cf4a #3 0x555a3a73aa9b #4 0x555a3a77caf7 #5 0x555a3a77c11f #6 0x555a3a773693 #7 0x555a3a74603a #8 0x555a3a74717e #9 0x555a3a998dbd #10 0x555a3a99cc6c #11 0x555a3a9a64b0 #12 0x555a3a99dd63 #13 0x555a3a970c35 #14 0x555a3a9c1138 #15 0x555a3a9c12c7 #16 0x555a3a9cf093 #17 0x7f5ec4927609 start_thread\n", + "\u001b[33mTWITTER TRENDS THOUGHTS: \u001b[0m I think I should search for technology trends to find some viral tweets.\n", + "\u001b[33mREASONING: \u001b[0m Searching for the latest trends in technology can help me find viral tweets that are currently circulating on Twitter.\n", + "\u001b[33mPLAN: \u001b[0m\n", + "\u001b[32m- \u001b[0m Perform a Google search to find the latest trends in technology.\\n- Review the search results to identify viral tweets related to technology.\\n- Draft three tweets related to technology.\\n- List the tweets on the screen.\n", + "\u001b[33mCRITICISM: \u001b[0m I need to ensure that the tweets I draft are within the proper social and legal boundaries. I also need to ensure that the selected trends are recent enough to attract attention.\n", + "Attempting to fix JSON by finding outermost brackets \u001b[0m\n", + "\u001b[32mApparently json was fixed. \u001b[0m\n", + "\u001b[36mNEXT ACTION: \u001b[0m COMMAND = \u001b[36mgoogle\u001b[0m ARGUMENTS = \u001b[36m{'input': 'latest technology trends on Twitter'}\u001b[0m\n", + "Enter 'y' to authorise command, 'y -N' to run N continuous commands, 'n' to exit program, or enter feedback for Twitter Trends...\n", + "\u001b[35mInput:\u001b[0m" + ] + } + ], + "source": [ + "!python -m autogpt" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/PREDICCIONAICNN.ipynb b/PREDICCIONAICNN.ipynb new file mode 100644 index 0000000..be74d48 --- /dev/null +++ b/PREDICCIONAICNN.ipynb @@ -0,0 +1,684 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from keras.models import Sequential\n", + "from keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout\n", + "from keras.regularizers import l1_l2\n", + "from keras.callbacks import EarlyStopping" + ], + "metadata": { + "id": "H7kZjC_GUZZd" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "9_FId2wvQAgd" + }, + "outputs": [], + "source": [ + "# Cargar el archivo de estadísticas de electricidad\n", + "file_path = 'Global_Electricity_Statistics.csv' # Asegúrate de cambiar esto a tu ruta de archivo\n", + "electricity_data = pd.read_csv(file_path)\n" + ] + }, + { + "cell_type": "code", + "source": [ + "# Convertir todos los valores a números, tratando los valores no numéricos como nulos\n", + "years_columns = electricity_data.columns[3:] # Columnas de años\n", + "electricity_data[years_columns] = electricity_data[years_columns].apply(pd.to_numeric, errors='coerce')\n" + ], + "metadata": { + "id": "dM7ktPDSOl8N" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Reemplazar valores 0 con NaN utilizando una máscara booleana\n", + "for column in years_columns:\n", + " mask = electricity_data[column] == 0\n", + " electricity_data.loc[mask, column] = pd.NA\n", + "\n", + "# Calcular la media de cada fila excluyendo NaN\n", + "row_means = electricity_data[years_columns].mean(axis=1)\n", + "\n", + "# Usar `fillna` en cada columna para reemplazar NaN con la media correspondiente de cada fila\n", + "for year in years_columns:\n", + " electricity_data[year] = electricity_data[year].fillna(row_means)\n", + "\n", + "# Verificar si hay valores nulos después de la normalización\n", + "null_values_after_normalization = electricity_data[years_columns].isna().sum().sum()\n" + ], + "metadata": { + "id": "374vEgbTOw3P" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Asegúrate de que los datos están agrupados por región y año como se hizo anteriormente\n", + "grouped_data = electricity_data.groupby('Region')[years_columns].sum().transpose()\n", + "\n", + "# Crear un gráfico de líneas\n", + "plt.figure(figsize=(15, 8)) # Ajusta el tamaño del gráfico según tus necesidades\n", + "\n", + "for region in grouped_data.columns:\n", + " plt.plot(grouped_data.index, grouped_data[region], label=region)\n", + "\n", + "# Agregar títulos y etiquetas\n", + "plt.title('Consumo de Electricidad por Región a lo Largo del Tiempo')\n", + "plt.xlabel('Año')\n", + "plt.ylabel('Consumo de Electricidad (Unidades)')\n", + "plt.xticks(rotation=45) # Rota las etiquetas del eje X para mejor legibilidad\n", + "plt.legend() # Añade una leyenda para identificar cada línea/región\n", + "\n", + "# Mostrar el gráfico\n", + "plt.show()" + ], + "metadata": { + "id": "lWY6qwmkQ2PL", + "outputId": "78b64a25-44f8-4243-e027-e22241dfe43b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 379 + } + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABOcAAALTCAYAAABdWWYwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gUVdvH8e+mh1QCgYBA6L33IlUgVOmC1CBNijwICKJ0UBGliqBgIIgiilSp0pXepPeYEB/pLSG0tHn/2Cf7siRAAoEN8Ptc117unDlz5p7J7EbunGIyDMNAREREREREREREnjs7WwcgIiIiIiIiIiLyqlJyTkRERERERERExEaUnBMREREREREREbERJedERERERERERERsRMk5ERERERERERERG1FyTkRERERERERExEaUnBMREREREREREbERJedERERERERERERsRMk5EREREXmlbdy4kbFjx3Lr1i1bhyIiIiKvICXnREREXkEjR47EZDLZ5Nwmk4mRI0fa5NwPExgYSM6cOVN8XM6cOQkMDHxsveDgYEwmE2FhYSk+x8PUqFGDGjVqpFp7L6vHPeshISE0a9aMTJky4ebm9hwje7QnfSZfdcn9TCYlNb+bnsVnXkREXl5KzomISJoVEhJCjx49yJ07Ny4uLnh6elKlShWmTJnCnTt3bB2e3CfhH6IPe+3cufO5xHH79m1GjhzJ5s2bn8v55PHCwsKsngU7Ozt8fHyoX78+O3bssGls9+7do1WrVvTp04fu3bvbNJZnLTAwEHd3d1uH8UKrUaPGI7/nEl5p7Y8PIiKS9jnYOgAREZGkrFy5klatWuHs7EzHjh0pWrQo0dHRbN26lQ8++ICjR48yc+ZMW4cpDxg9ejS5cuVKVJ43b97ncv7bt28zatQogBT1Kps1axbx8fEpPt/Jkyexs9PfOpPj7bffpkGDBsTFxXHq1CmmT59OzZo12bNnD8WKFXtm5x06dCgffvhhkvsOHz5M586dee+9957Z+eXl8fHHH9O1a1fL9p49e5g6dSofffQRhQoVspQXL16cIkWK0KZNG5ydnW0RqoiIvGCUnBMRkTQnNDSUNm3a4O/vz8aNG8mSJYtlX+/evTlz5gwrV660YYTyMPXr16ds2bK2DiPZbt26hZubG46Ojk90vP7hbZZwHx+ldOnStG/f3rJdtWpV6tevz4wZM5g+ffozi83BwQEHh6T/l7ds2bIv1POaliXnGXjR1alTx2rbxcWFqVOnUqdOnST/GGBvb/+cIhMRkRed/tQrIiJpzvjx44mKiiIoKMgqMZcgb968/Oc//7Fsx8bGMmbMGPLkyYOzszM5c+bko48+4t69e1bH5cyZk0aNGrF161bKly+Pi4sLuXPn5vvvv7eqFxMTw6hRo8iXLx8uLi5kyJCB119/nXXr1lnqPGy+rwfniUoY0vfll1/y9ddfkzt3btKlS0fdunX5559/MAyDMWPGkC1bNlxdXWnSpAnXrl1L1O706dMpUqQIzs7OZM2ald69e3Pjxo1k3c+tW7dSrlw5XFxcyJMnD99+++1D6/7www+UKVMGV1dXfHx8aNOmDf/880+yzvM0/v33X9555x0yZ86Ms7MzRYoUYfbs2Ynq3b17l5EjR5I/f35cXFzIkiULzZs3JyQkhLCwMHx9fQEYNWpUoiFmCcP6QkJCaNCgAR4eHrRr186y78H5veLj45kyZQrFihXDxcUFX19f6tWrx969ey11kprf6ujRo9SqVQtXV1eyZcvG2LFjk+yVt2zZMho2bEjWrFlxdnYmT548jBkzhri4uER1Z86cSZ48eXB1daV8+fL8+eefyb63JpOJPn368OOPP1KgQAFcXFwoU6YMf/zxR6K6f/31F/Xr18fT0xN3d3feeOONREOSE4Ywb9myhV69epEpUyayZcuW7HgSVK1aFTAPX7/fjRs36NevH9mzZ8fZ2Zm8efPy+eefJ7qHV69epUOHDnh6euLt7U2nTp04ePAgJpOJ4OBgS72k5pxL7e+Mh/nyyy+pXLkyGTJkwNXVlTJlyvDrr78m9xYlcuvWLQYMGGC5NwUKFODLL7/EMIwnbvN+Z8+epVevXhQoUABXV1cyZMhAq1atEs2b9rhnIOG77v7nNanvzEuXLtGlSxcyZ86Mi4sLJUqUYO7cucmK1TAMxo4dS7Zs2UiXLh01a9bk6NGjSdZN7jOVmh4259zq1aupWrUqbm5ueHh40LBhw0RxJ3xXhYeH06hRI9zd3Xnttdf4+uuvAXOPz1q1auHm5oa/vz/z589P8tx//PEHPXr0IEOGDHh6etKxY0euX7+eKNan+f0iIiKpQz3nREQkzfntt9/InTs3lStXTlb9rl27MnfuXFq2bMmAAQPYtWsXn332GcePH2fJkiVWdc+cOUPLli3p0qULnTp1Yvbs2QQGBlKmTBmKFCkCmP8x/9lnn9G1a1fKly9PZGQke/fuZf/+/Yl6TiTXjz/+SHR0NO+99x7Xrl1j/PjxvPXWW9SqVYvNmzczePBgzpw5w1dffcXAgQOtElMjR45k1KhR1K5dm549e3Ly5ElmzJjBnj172LZt2yN7fR0+fJi6devi6+vLyJEjiY2NZcSIEWTOnDlR3U8++YRhw4bx1ltv0bVrVy5fvsxXX31FtWrV+Ouvv/D29n7sdUZERHDlyhWrMpPJRIYMGR56zMWLF6lYsaIlieTr68vq1avp0qULkZGR9OvXD4C4uDgaNWrEhg0baNOmDf/5z3+4efMm69at48iRI9SuXZsZM2bQs2dPmjVrRvPmzQHzELMEsbGxBAQE8Prrr/Pll1+SLl26h8bVpUsXgoODqV+/Pl27diU2NpY///yTnTt3PrS31YULF6hZsyaxsbF8+OGHuLm5MXPmTFxdXRPVDQ4Oxt3dnf79++Pu7s7GjRsZPnw4kZGRfPHFF5Z6QUFB9OjRg8qVK9OvXz/+/vtv3nzzTXx8fMiePftD47/fli1b+Pnnn+nbty/Ozs5Mnz6devXqsXv3booWLQqYk4pVq1bF09OTQYMG4ejoyLfffkuNGjXYsmULFSpUsGqzV69e+Pr6Mnz48Cda5TQhaZE+fXpL2e3bt6levTr//vsvPXr0IEeOHGzfvp0hQ4Zw/vx5Jk+eDJgTp40bN2b37t307NmTggULsmzZMjp16pSsc6f2d8bDTJkyhTfffJN27doRHR3NggULaNWqFStWrKBhw4bJv1mYk1FvvvkmmzZtokuXLpQsWZK1a9fywQcf8O+//zJp0qQUtZeUPXv2sH37dtq0aUO2bNkICwtjxowZ1KhRg2PHjiX6vCT1DMyYMYM+ffpQtWpV3n//fcLCwmjatCnp06e3SuDduXOHGjVqcObMGfr06UOuXLlYuHAhgYGB3Lhxw+oPMEkZPnw4Y8eOpUGDBjRo0ID9+/dTt25doqOjreol95l6HubNm0enTp0ICAjg888/5/bt28yYMYPXX3+dv/76y+oPBHFxcdSvX59q1aoxfvx4fvzxR/r06YObmxsff/wx7dq1o3nz5nzzzTd07NiRSpUqJZpSoE+fPnh7ezNy5EjL742zZ8+yefNmS8L6aX6/iIhIKjJERETSkIiICAMwmjRpkqz6Bw4cMACja9euVuUDBw40AGPjxo2WMn9/fwMw/vjjD0vZpUuXDGdnZ2PAgAGWshIlShgNGzZ85HmrV69uVK9ePVF5p06dDH9/f8t2aGioARi+vr7GjRs3LOVDhgwxAKNEiRJGTEyMpfztt982nJycjLt371ric3JyMurWrWvExcVZ6k2bNs0AjNmzZz8yzqZNmxouLi7G2bNnLWXHjh0z7O3tjfv/NyAsLMywt7c3PvnkE6vjDx8+bDg4OCQqf9CcOXMMIMmXs7OzVV3AGDFihGW7S5cuRpYsWYwrV65Y1WvTpo3h5eVl3L592zAMw5g9e7YBGBMnTkx0/vj4eMMwDOPy5cuJ2k/QqVMnAzA+/PDDJPfd/3PbuHGjARh9+/Z96LkMw/xMderUybLdr18/AzB27dplKbt06ZLh5eVlAEZoaKilPOG67tejRw8jXbp0lp9/dHS0kSlTJqNkyZLGvXv3LPVmzpxpAEk+gw9K+Dns3bvXUnb27FnDxcXFaNasmaWsadOmhpOTkxESEmIpO3funOHh4WFUq1bNUpbws3799deN2NjYx54/4TMwatQo4/Lly8aFCxeMP//80yhXrpwBGAsXLrTUHTNmjOHm5macOnXKqo0PP/zQsLe3N8LDww3DMIxFixYZgDF58mRLnbi4OKNWrVoGYMyZM8dSPmLECKtn/Vl8ZzzMgz/j6Ohoo2jRokatWrUee+yDz+TSpUsNwBg7dqxVvZYtWxomk8k4c+bMY9tzc3NLUbyGYRg7duwwAOP777+3lD3sGbh3756RIUMGo1y5clbfa8HBwYme18mTJxuA8cMPP1jKoqOjjUqVKhnu7u5GZGTkQ+NM+F5s2LCh1efxo48+MgCrz2RynynDSPzd9DgLFy40AGPTpk2J9iXco4TP/M2bNw1vb2+jW7duVvUuXLhgeHl5WZUnfFd9+umnlrLr168brq6uhslkMhYsWGApP3HiRKK4E85dpkwZIzo62lI+fvx4AzCWLVtmGMbT/34REZHUo2GtIiKSpkRGRgLg4eGRrPqrVq0CoH///lblAwYMAEg0N13hwoUtw+kAfH19KVCgAH///belzNvbm6NHj3L69OmUX8BDtGrVCi8vL8t2Qi+k9u3bW82HVaFCBaKjo/n3338BWL9+PdHR0fTr189q4YFu3brh6en5yLn34uLiWLt2LU2bNiVHjhyW8kKFChEQEGBVd/HixcTHx/PWW29x5coVy8vPz498+fKxadOmZF3n119/zbp166xeq1evfmh9wzBYtGgRjRs3xjAMq3MHBAQQERHB/v37AVi0aBEZM2ZMcvL+B4ctPkrPnj0fW2fRokWYTCZGjBiRonOtWrWKihUrUr58eUuZr6+vZfjs/e7vTXfz5k2uXLlC1apVuX37NidOnABg7969XLp0iXfffRcnJydL/cDAQKvn6XEqVapEmTJlLNs5cuSgSZMmrF27lri4OOLi4vj9999p2rQpuXPnttTLkiULbdu2ZevWrZbPZoJu3bqlaE6tESNG4Ovri5+fH1WrVuX48eNMmDCBli1bWuosXLiQqlWrkj59eqtnoXbt2sTFxVmG4q5ZswZHR0e6detmOdbOzo7evXs/No5n8Z3xMPf/jK9fv05ERARVq1a1PNMpsWrVKuzt7enbt2+iuA3DeOTnLLnujzcmJoarV6+SN29evL29k4z5wWdg7969XL16lW7dull9r7Vr186qh2TC9fj5+fH2229byhwdHenbty9RUVFs2bLloXEmfC++9957Vp/HhF6290vuM/WsrVu3jhs3bvD2229bxWFvb0+FChWS/I69f/EJb29vChQogJubG2+99ZalvECBAnh7eyf5PHbv3t2q51vPnj1xcHCwfAae5veLiIikLg1rFRGRNMXT0xMwJyuS4+zZs9jZ2SVaDdTPzw9vb2/Onj1rVX5/kipB+vTprebhGT16NE2aNCF//vwULVqUevXq0aFDB6vhkSn14HkTEisPDktMKE+IJyH+AgUKWNVzcnIid+7cia7vfpcvX+bOnTvky5cv0b4CBQpY/oEGcPr0aQzDSLIukOyhTeXLl0/RBPuXL1/mxo0bzJw586Gr7166dAkwz01WoECBh07unxwODg7Jmh8tJCSErFmz4uPjk6L2z549m2j4JyT++YF5GOnQoUPZuHFjosRXRESEpT0g0c/F0dHRKon2OEn9XPPnz8/t27e5fPkyYB7+l1SchQoVIj4+nn/++cdqGGdSq/I+Svfu3WnVqhV3795l48aNTJ06NdH8eqdPn+bQoUOWuQMflPAsnD17lixZsiQaZpmcVYGfxXfGw6xYsYKxY8dy4MABq/nsUpJMvj/urFmzJvrDRcIqoY/6LkiuO3fu8NlnnzFnzhz+/fdfq7nsEp7J+z34DCTE8OC9dXBwSDSn49mzZ8mXL1+i1Y6Tcz0P+1z4+vomSgIm95l61hL+2FOrVq0k9yf87kuQMM/l/by8vMiWLVui58fLyyvJ5/HB++Pu7k6WLFksQ8qf5veLiIikLiXnREQkTfH09CRr1qwcOXIkRccl9x+7D+vpc/8/QqtVq0ZISAjLli3j999/57vvvmPSpEl88803lp4MJpMpyUnYk5rM/1HnTU48z0N8fDwmk4nVq1cnGZO7u/szOy+YexA+bL6wp0mKPsjZ2TlRMsAWbty4QfXq1fH09GT06NHkyZMHFxcX9u/fz+DBg5/pRPWpJal59B4lX7581K5dG4BGjRphb2/Phx9+SM2aNS0J3fj4eOrUqcOgQYOSbCN//vxPF/R9UvM7Iyl//vknb775JtWqVWP69OlkyZIFR0dH5syZk2gC/7TivffeY86cOfTr149KlSrh5eWFyWSiTZs2ST6TKX0GbOF5PlOPiwPM8875+fkl2v/gHx3S+u8MERFJXUrOiYhImtOoUSNmzpzJjh07qFSp0iPr+vv7Ex8fz+nTpy09LsC8yMCNGzfw9/d/ohh8fHzo3LkznTt3JioqimrVqjFy5EhLci59+vRJDiNK7Z4GCfGfPHnSqqdUdHQ0oaGhlmRHUnx9fXF1dU1yeO7JkyettvPkyYNhGOTKleu5/WMVzDF6eHgQFxf3yGsBc4y7du0iJibmoT35nqRH0sPOtXbtWq5du5ai3nP+/v7Jut+bN2/m6tWrLF68mGrVqlnKQ0NDE7UH5l439/e4iYmJITQ0lBIlSiQrrqRiOnXqFOnSpbP0zkmXLl2iOAFOnDiBnZ1dshefSK6PP/6YWbNmMXToUNasWQOY73tUVNRjnwV/f382bdrE7du3rXrPnTlz5rHnfVbfGQ9atGgRLi4urF27FmdnZ0v5nDlznqg9f39/1q9fz82bN616zyUMgU6NuH/99Vc6derEhAkTLGV3795N9sqdCTGcOXOGmjVrWspjY2MJCwuzSrT7+/tz6NAh4uPjrRLmybme+z8X938vXr58OVEPsuQ+U89anjx5AMiUKdNzi+X06dNWP4eoqCjOnz9PgwYNgKf7/SIiIqnL9n86FhERecCgQYNwc3Oja9euXLx4MdH+kJAQpkyZAmD5R8aDK+5NnDgRIMUrIgJcvXrVatvd3Z28efNaDUvLkycPJ06csAwJBDh48CDbtm1L8fkepXbt2jg5OTF16lSrnhFBQUFEREQ88vrs7e0JCAhg6dKlhIeHW8qPHz/O2rVrreo2b94ce3t7Ro0alagHhmEYie5JarG3t6dFixYsWrQoyd6S99/fFi1acOXKFaZNm5aoXkLMCYma5CYTHqZFixYYhsGoUaMeeq6kNGjQgJ07d7J7925L2eXLl/nxxx+t6iX0frm/rejoaKZPn25Vr2zZsvj6+vLNN99YrUIZHBycomvcsWOH1Zxh//zzD8uWLaNu3brY29tjb29P3bp1WbZsmWXIG5gTVvPnz+f1119PNOzuaXl7e9OjRw/Wrl3LgQMHAHjrrbfYsWNHoucTzD/T2NhYAAICAoiJiWHWrFmW/fHx8Xz99dePPe+z+M5Iir29PSaTyao3bVhYGEuXLn2i9ho0aEBcXFyi53/SpEmYTCbq16//NOEC5pgffL6/+uqrh/YIflDZsmXJkCEDs2bNsvyswLxa9YNJswYNGnDhwgV+/vlnS1lsbCxfffUV7u7uVK9e/aHnqV27No6Ojnz11VdW8Sa18mpyn6lnLSAgAE9PTz799FNiYmIS7b//uy61zJw50+pcM2bMIDY21vKsPM3vFxERSV3qOSciImlOnjx5mD9/Pq1bt6ZQoUJ07NiRokWLEh0dzfbt21m4cCGBgYEAlChRgk6dOjFz5kzLUMHdu3czd+5cmjZtatVrILkKFy5MjRo1KFOmDD4+Puzdu5dff/2VPn36WOq88847TJw4kYCAALp06cKlS5f45ptvKFKkSKL5w56Gr68vQ4YMYdSoUdSrV48333yTkydPMn36dMqVK0f79u0fefyoUaNYs2YNVatWpVevXpZ//BYpUoRDhw5Z6uXJk4exY8cyZMgQwsLCaNq0KR4eHoSGhrJkyRK6d+/OwIEDHxvv6tWrLT1f7le5cuWHzpE2btw4Nm3aRIUKFejWrRuFCxfm2rVr7N+/n/Xr13Pt2jUAOnbsyPfff0///v3ZvXs3VatW5datW6xfv55evXrRpEkTXF1dKVy4MD///DP58+fHx8eHokWLUrRo0cfGfr+aNWvSoUMHpk6dyunTp6lXrx7x8fH8+eef1KxZ0+pZuN+gQYOYN28e9erV4z//+Q9ubm7MnDnT0kvo/vuRPn16OnXqRN++fTGZTMybNy9RYsTR0ZGxY8fSo0cPatWqRevWrQkNDWXOnDkpmnOuaNGiBAQE0LdvX5ydnS1JwPuTj2PHjmXdunW8/vrr9OrVCwcHB7799lvu3bvH+PHjU3L7ku0///kPkydPZty4cSxYsIAPPviA5cuX06hRIwIDAylTpgy3bt3i8OHD/Prrr4SFhZExY0aaNm1K+fLlGTBgAGfOnKFgwYIsX77c8qw8qgfls/jOSErDhg2ZOHEi9erVo23btly6dImvv/6avHnzWj0LydW4cWNq1qzJxx9/TFhYGCVKlOD3339n2bJl9OvXz9Iz61FiYmIYO3ZsonIfHx969epFo0aNmDdvHl5eXhQuXJgdO3awfv16MmTIkKwYnZycGDlyJO+99x61atXirbfeIiwsjODgYPLkyWP1c+nevTvffvstgYGB7Nu3j5w5c/Lrr7+ybds2Jk+e/MhFgXx9fRk4cCCfffYZjRo1okGDBvz111+sXr2ajBkzWtVN7jP1rHl6ejJjxgw6dOhA6dKladOmDb6+voSHh7Ny5UqqVKmS5B8enkZ0dDRvvPEGb731luX3xuuvv86bb74JPP3vFxERSUXPc2lYERGRlDh16pTRrVs3I2fOnIaTk5Ph4eFhVKlSxfjqq6+Mu3fvWurFxMQYo0aNMnLlymU4Ojoa2bNnN4YMGWJVxzAMw9/f32jYsGGi81SvXt2oXr26ZXvs2LFG+fLlDW9vb8PV1dUoWLCg8cknnxjR0dFWx/3www9G7ty5DScnJ6NkyZLG2rVrjU6dOhn+/v6WOqGhoQZgfPHFF1bHbtq0yQCMhQsXWpXPmTPHAIw9e/ZYlU+bNs0oWLCg4ejoaGTOnNno2bOncf369eTcRmPLli1GmTJlDCcnJyN37tzGN998Y4wYMcJI6n8DFi1aZLz++uuGm5ub4ebmZhQsWNDo3bu3cfLkyUeeIyHuh73mzJljqQsYI0aMsDr+4sWLRu/evY3s2bMbjo6Ohp+fn/HGG28YM2fOtKp3+/Zt4+OPP7b8rP38/IyWLVsaISEhljrbt2+3XO/95+rUqZPh5uaWZPwP/twMwzBiY2ONL774wihYsKDh5ORk+Pr6GvXr1zf27dtnqePv72906tTJ6rhDhw4Z1atXN1xcXIzXXnvNGDNmjBEUFGQARmhoqKXetm3bjIoVKxqurq5G1qxZjUGDBhlr1641AGPTpk1WbU6fPt3IlSuX4ezsbJQtW9b4448/Ej23DwMYvXv3Nn744QcjX758hrOzs1GqVKlE5zAMw9i/f78REBBguLu7G+nSpTNq1qxpbN++3arOw57Rh3nYZyBBYGCgYW9vb5w5c8YwDMO4efOmMWTIECNv3ryGk5OTkTFjRqNy5crGl19+afUZvHz5stG2bVvDw8PD8PLyMgIDA41t27YZgLFgwQJLvaSe9dT+zniYoKAgyz0vWLCgMWfOnId+9h6U1DN58+ZN4/333zeyZs1qODo6Gvny5TO++OILIz4+PlntPezzmSdPHsMwDOP69etG586djYwZMxru7u5GQECAceLEiUTP+eOegalTpxr+/v6Gs7OzUb58eWPbtm1GmTJljHr16lnVu3jxouV8Tk5ORrFixay+Kx4lLi7OGDVqlJElSxbD1dXVqFGjhnHkyJEkP5PJfaaS+m56lIULFyb5eTWM/79H93/mDcP83R8QEGB4eXkZLi4uRp48eYzAwEBj7969ljoP+66qXr26UaRIkUTlDz6nCefesmWL0b17dyN9+vSGu7u70a5dO+Pq1auJjn+a3y8iIpI6TIah2UNFREREXlYmk4nevXuneq+ctGjp0qU0a9aMrVu3UqVKFVuHI/8THx+Pr68vzZs3txqKLM9GcHAwnTt3Zs+ePSlaPVtERGxHc86JiIiIyAvnzp07VttxcXF89dVXeHp6Urp0aRtFJXfv3k00PPv777/n2rVr1KhRwzZBiYiIpHGac05EREREXjjvvfced+7coVKlSty7d4/Fixezfft2Pv30U1xdXW0d3itr586dvP/++7Rq1YoMGTKwf/9+goKCKFq0KK1atbJ1eCIiImmSknMiIiIi8sKpVasWEyZMYMWKFdy9e5e8efPy1VdfPXSxDnk+cubMSfbs2Zk6dSrXrl3Dx8eHjh07Mm7cOJycnGwdnoiISJqkOedERERERERERERsRHPOiYiIiIiIiIiI2IiScyIiIiIiIiIiIjai5JyIiIiIiIiIiIiNaEGIVBIfH8+5c+fw8PDAZDLZOhwREREREREREbEhwzC4efMmWbNmxc7u4f3jlJxLJefOnSN79uy2DkNERERERERERNKQf/75h2zZsj10v5JzqcTDwwMw33BPT08bRyMiIiIiIiIiIrYUGRlJ9uzZLTmjh1FyLpUkDGX19PRUck5ERERERERERAAeO/2ZFoQQERERERERERGxESXnREREREREREREbETJORERERERERERERvRnHPPkWEYxMbGEhcXZ+tQRF56jo6O2Nvb2zoMERERERERkUdScu45iY6O5vz589y+fdvWoYi8EkwmE9myZcPd3d3WoYiIiIiIiIg8lJJzz0F8fDyhoaHY29uTNWtWnJycHrtSh4g8OcMwuHz5Mv/973/Jly+fetCJiIiIiIhImqXk3HMQHR1NfHw82bNnJ126dLYOR+SV4OvrS1hYGDExMUrOiYiIiIiISJqlBSGeIzs73W6R50W9U0VERERERORFoGyRiIiIiIiIiIiIjSg5J0/FMAy6d++Oj48PJpOJAwcOPLSuyWRi6dKlzy02EREREREREZG0Tsk5SZYdO3Zgb29Pw4YNrcrXrFlDcHAwK1as4Pz58xQtWvShbZw/f5769es/61BFRERERERERF4YSs5JsgQFBfHee+/xxx9/cO7cOUt5SEgIWbJkoXLlyvj5+eHgkHiNkejoaAD8/PxwdnZ+bjGLiIiIiIiIiKR1Ss7JY0VFRfHzzz/Ts2dPGjZsSHBwMACBgYG89957hIeHYzKZyJkzJwA1atSgT58+9OvXj4wZMxIQEAAkHtb63//+l7fffhsfHx/c3NwoW7Ysu3btAsxJvyZNmpA5c2bc3d0pV64c69evf56XLSIiIiIiIiLyzCXu5iTPhWEY3ImJe+7ndXW0T/Eqlr/88gsFCxakQIECtG/fnn79+jFkyBCmTJlCnjx5mDlzJnv27MHe3t5yzNy5c+nZsyfbtm1Lss2oqCiqV6/Oa6+9xvLly/Hz82P//v3Ex8db9jdo0IBPPvkEZ2dnvv/+exo3bszJkyfJkSPHk98AEREREREREZE0RMk5G7kTE0fh4Wuf+3mPjQ4gnVPKfuxBQUG0b98egHr16hEREcGWLVuoUaMGHh4e2Nvb4+fnZ3VMvnz5GD9+/EPbnD9/PpcvX2bPnj34+PgAkDdvXsv+EiVKUKJECcv2mDFjWLJkCcuXL6dPnz4pil9EREREREREJK3SsFZ5pJMnT7J7927efvttABwcHGjdujVBQUGPPK5MmTKP3H/gwAFKlSplScw9KCoqioEDB1KoUCG8vb1xd3fn+PHjhIeHP9mFiIiIiIiIiIikQeo5ZyOujvYcGx1gk/OmRFBQELGxsWTNmtVSZhgGzs7OTJs27aHHubm5PToOV9dH7h84cCDr1q3jyy+/JG/evLi6utKyZUvL4hIiIiIiIiIiIi8DJedsxGQypXh46fMWGxvL999/z4QJE6hbt67VvqZNm/LTTz89cdvFixfnu+++49q1a0n2ntu2bRuBgYE0a9YMMPekCwsLe+LziYiIiIiIiIikRRrWKg+1YsUKrl+/TpcuXShatKjVq0WLFo8d2voob7/9Nn5+fjRt2pRt27bx999/s2jRInbs2AGY56xbvHgxBw4c4ODBg7Rt29ayWISIiIiIiIiIyMtCyTl5qKCgIGrXro2Xl1eifS1atGDv3r1ERkY+UdtOTk78/vvvZMqUiQYNGlCsWDHGjRtnWfF14sSJpE+fnsqVK9O4cWMCAgIoXbr0U12PiIiIiIiIiEhaYzIMw7B1EC+DyMhIvLy8iIiIwNPT02rf3bt3CQ0NJVeuXLi4uNgoQpFXiz53IiIiIiIiYkuPyhXdTz3nREREREREREREbETJORERERERERERERtRck5ERERERERERGxr+zS4ftbWUdiEknMiIiIiIiIiImI7x1fA7x/DN1Xh9jVbR/PcKTknIiIiIiIiIiK2EXUJfutrfl+mE6TzsW08NqDknIiIiIiIiIiIPH+GAcvfg9tXIXNRqDXU1hHZhJJzIiIiIiIiIiLy/O2fC6fWgL0TNJ8JDs62jsgmlJwTEREREREREZHn62oIrPnI/P6N4ZC5iG3jsSEl50RERERERERE5PmJi4Ul70LMLchZFSr2tnVENqXknDxTYWFhmEwmDhw4YOtQXhg1atSgX79+tg5DRERERERE5NnYNgn+uxucPaHpdLB7tdNTr/bVS7Lt2LEDe3t7GjZsmKLjsmfPzvnz5ylatOhTnT8+Pp7BgweTNWtWXF1dKV68OMuWLUv28StWrKB69ep4eHiQLl06ypUrR3Bw8FPF9KwsXryYMWPG2DoMERERERERkdR37i/YPM78vsEX4J3DtvGkAUrOSbIEBQXx3nvv8ccff3Du3LlkH2dvb4+fnx8ODg5Pdf4ffviBSZMmMXHiRI4fP87EiRNxc3NL1rFfffUVTZo0oUqVKuzatYtDhw7Rpk0b3n33XQYOHPhUcT0LPj4+eHh42DoMERERERERkdQVcwcWd4f4WCjcBIq3tnVEaYKSc/JYUVFR/Pzzz/Ts2ZOGDRsm6nF2/fp12rVrh6+vL66uruTLl485c+YAiYe1xsXF0aVLF3LlyoWrqysFChRgypQpj43Bzs4OX19f2rRpQ86cOalduza1a9d+7HH//PMPAwYMoF+/fnz66acULlyYvHnzMmDAAL744gsmTJjArl27LPWPHj1Ko0aN8PT0xMPDg6pVqxISEmLZ/91331GoUCFcXFwoWLAg06dPtzrf4MGDyZ8/P+nSpSN37twMGzaMmJgYy/6RI0dSsmRJ5s2bR86cOfHy8qJNmzbcvHnTUufBYa3z5s2jbNmyeHh44OfnR9u2bbl06dJjr11EREREREQkTVk/Eq6cAnc/aDQZTCZbR5QmKDlnK4YB0bee/8swUhzqL7/8QsGCBSlQoADt27dn9uzZGPe1M2zYMI4dO8bq1as5fvw4M2bMIGPGjEm2FR8fT7Zs2Vi4cCHHjh1j+PDhfPTRR/zyyy+PjOGNN94gIiKCYcOGpSj2X3/9lZiYmCR7yPXo0QN3d3d++uknAP7991+qVauGs7MzGzduZN++fbzzzjvExsYC8OOPPzJ8+HA++eQTjh8/zqeffsqwYcOYO3eupU0PDw+Cg4M5duwYU6ZMYdasWUyaNMnqvCEhISxdupQVK1awYsUKtmzZwrhx4x56DTExMYwZM4aDBw+ydOlSwsLCCAwMTNF9EBEREREREbGpkI2w6xvz+yZfQzof28aThjzdWEN5cjG34dOsz/+8H50Dp+QNB00QFBRE+/btAahXrx4RERFs2bKFGjVqABAeHk6pUqUoW7YsADlz5nxoW46OjowaNcqynStXLnbs2MEvv/zCW2+9leQxt2/fpk6dOrRt25Z169Zx584dvvjiC0z/y7B7enoye/ZsWrZsmejYU6dO4eXlRZYsWRLtc3JyInfu3Jw6dQqAr7/+Gi8vLxYsWICjoyMA+fPnt9QfMWIEEyZMoHnz5pbYjx07xrfffkunTp0AGDp0qKV+zpw5GThwIAsWLGDQoEGW8vj4eIKDgy1DVzt06MCGDRv45JNPkrz+d955x/I+d+7cTJ06lXLlyhEVFYW7u3uSx4iIiIiIiIikGbevwdJe5vflukK+x4+Ee5UoOSePdPLkSXbv3s2SJUsAcHBwoHXr1gQFBVmScz179qRFixbs37+funXr0rRpUypXrvzQNr/++mtmz55NeHg4d+7cITo6mpIlSz60fnBwMDdu3ODrr78mKiqKGjVq0LlzZ7777jv++9//EhUVRZUqVZ76Wg8cOEDVqlUtibn73bp1i5CQELp06UK3bt0s5bGxsXh5eVm2f/75Z6ZOnUpISAhRUVHExsbi6elp1VbOnDmt5pTLkiXLI4ep7tu3j5EjR3Lw4EGuX79OfHw8YE6KFi5c+ImvV0REREREROS5WDUQbp6HDHmhzmhbR5Pm2DQ5N2PGDGbMmEFYWBgARYoUYfjw4dSvXx+Au3fvMmDAABYsWMC9e/cICAhg+vTpZM6c2dJGeHg4PXv2ZNOmTbi7u9OpUyc+++wzqwUINm/eTP/+/Tl69CjZs2dn6NChiYYFfv3113zxxRdcuHCBEiVK8NVXX1G+fPlnd/GO6cy92J43x3Qpqh4UFERsbCxZs/5/Lz/DMHB2dmbatGl4eXlRv359zp49y6pVq1i3bh1vvPEGvXv35ssvv0zU3oIFCxg4cCATJkygUqVKeHh48MUXX1jN+/agQ4cOUaRIERwdHUmfPj3r1q2jatWqNGvWjHz58lGvXr0ke8aBuedbREQE586ds7oGgOjoaEJCQqhZsyYArq6uD40hKioKgFmzZlGhQgWrffb29oB5Rdt27doxatQoAgICLL3wJkyYYFX/weSfyWSyJNwedOvWLQICAggICODHH3/E19eX8PBwAgICiI6Ofmi8IiIiIiIiImnC4V/hyCIw2UOzmSkezfcqsOmcc9myZWPcuHHs27ePvXv3UqtWLZo0acLRo0cBeP/99/ntt99YuHAhW7Zs4dy5c5YhhWBeXKBhw4ZER0ezfft25s6dS3BwMMOHD7fUCQ0NpWHDhtSsWZMDBw7Qr18/unbtytq1ay11fv75Z/r378+IESPYv38/JUqUICAg4NlOum8ymR/I5/1KwWSLsbGxfP/990yYMIEDBw5YXgcPHiRr1qyWudoAfH196dSpEz/88AOTJ09m5syZSba5bds2KleuTK9evShVqhR58+a1WnAhKa+99hoHDhywLJqQKVMm1q9fz+HDh5k0aRJjx4596LEtWrTA0dExUYIM4JtvvuHWrVu8/fbbABQvXpw///zTagGHBJkzZyZr1qz8/fff5M2b1+qVK1cuALZv346/vz8ff/wxZcuWJV++fJw9e/aR1/Y4J06c4OrVq4wbN46qVatSsGBBLQYhIiIiIiIiL4aI/8LK/ub31QdBtjK2jSetMtKY9OnTG999951x48YNw9HR0Vi4cKFl3/Hjxw3A2LFjh2EYhrFq1SrDzs7OuHDhgqXOjBkzDE9PT+PevXuGYRjGoEGDjCJFilido3Xr1kZAQIBlu3z58kbv3r0t23FxcUbWrFmNzz77LNlxR0REGIARERGRaN+dO3eMY8eOGXfu3El2e2nBkiVLDCcnJ+PGjRuJ9g0aNMgoW7asYRiGMWzYMGPp0qXG6dOnjSNHjhiNGjUyypcvbxiGYYSGhhqA8ddffxmGYRhTpkwxPD09jTVr1hgnT540hg4danh6eholSpR4aBz//vuvkSFDBqNGjRrGtm3bjBMnThizZs0yMmTIYKRLl87o1avXI69j0qRJhp2dnfHRRx8Zx48fN86cOWNMmDDBcHZ2NgYMGGCpd+XKFSNDhgxG8+bNjT179hinTp0yvv/+e+PEiROGYRjGrFmzDFdXV2PKlCnGyZMnjUOHDhmzZ882JkyYYBiGYSxbtsxwcHAwfvrpJ+PMmTPGlClTDB8fH8PLy8tyjhEjRiS61kmTJhn+/v6W7erVqxv/+c9/DMMwjEuXLhlOTk7GBx98YISEhBjLli0z8ufPb3VPJWkv6udORERERETkpRAXZxjBjQ1jhKdhzKxpGLHRto7ouXtUruh+aWa11ri4OBYsWMCtW7eoVKkS+/btIyYmhtq1/3+SwIIFC5IjRw527NgBmIcRFitWzGqYa0BAAJGRkZbedzt27LBqI6FOQhvR0dHs27fPqo6dnR21a9e21HlVBQUFUbt2bas51RK0aNGCvXv3cujQIZycnBgyZAjFixenWrVq2Nvbs2DBgiTb7NGjB82bN6d169ZUqFCBq1ev0qtXr0fGkTVrVnbv3k3GjBlp3rw5pUqV4vvvv+f7779n5cqVzJw5k4kTJz70+H79+rFkyRL+/PNPypYtS9GiRZk/fz4zZsywGnqbIUMGNm7cSFRUFNWrV6dMmTLMmjXLMgy1a9eufPfdd8yZM4dixYpRvXp1goODLT3n3nzzTd5//3369OlDyZIl2b59e4pXl32Qr68vwcHBLFy4kMKFCzNu3LgkhwuLiIiIiIiIpCm7v4XQLeDgah7Oap94fncxMxmGYdgygMOHD1OpUiXu3r2Lu7s78+fPp0GDBsyfP5/OnTtz7949q/rly5enZs2afP7553Tv3p2zZ89aDVG9ffs2bm5urFq1ivr165M/f346d+7MkCFDLHVWrVpFw4YNuX37NtevX+e1115j+/btVKpUyVJn0KBBbNmy5aFzod27d88qtsjISLJnz05ERESiBQDu3r1LaGgouXLlwsXF5anul4gkjz53IiIiIiIiNnLpBHxbDeLuQcMJ5hVaX0GRkZF4eXklmSu6n817zhUoUIADBw6wa9cuevbsSadOnTh27Jitw3qszz77DC8vL8sre/bstg5JRERERERERMS2YqNhcTdzYi5vbSjbxdYRpXk2T845OTmRN29eypQpw2effUaJEiWYMmUKfn5+REdHc+PGDav6Fy9exM/PDwA/Pz8uXryYaH/CvkfV8fT0xNXVlYwZM2Jvb59knYQ2kjJkyBAiIiIsr3/++eeJrl9ERERERERE5KWxZRxcOASu6aHJ1ylamPJVZfPk3IPi4+O5d+8eZcqUwdHRkQ0bNlj2nTx5kvDwcMvw00qVKnH48GGr1SvXrVuHp6cnhQsXttS5v42EOgltODk5UaZMGas68fHxbNiwwWqY64OcnZ3x9PS0eomIiIiIiIiIvLLCd8LWSeb3jaeAx8M7Pcn/c7DlyYcMGUL9+vXJkSMHN2/eZP78+WzevJm1a9fi5eVFly5d6N+/Pz4+Pnh6evLee+9RqVIlKlasCEDdunUpXLgwHTp0YPz48Vy4cIGhQ4fSu3dvnJ2dAXj33XeZNm0agwYN4p133mHjxo388ssvrFy50hJH//796dSpE2XLlqV8+fJMnjyZW7du0blzZ5vcFxERERERERGRF8q9m7CkBxjxUOJtKNzE1hG9MGyanLt06RIdO3bk/PnzeHl5Ubx4cdauXUudOnUAmDRpEnZ2drRo0YJ79+4REBDA9OnTLcfb29uzYsUKevbsSaVKlXBzc6NTp06MHj3aUidXrlysXLmS999/nylTppAtWza+++47AgICLHVat27N5cuXGT58OBcuXKBkyZKsWbPGahVYERERERERERF5iLUfwfUw8MoO9T+3dTQvFJuv1vqyeNQKHFo1UuT50+dORERERETkOTmxCha8DZggcAXkfN3WEaUJL8xqrSIiIiIiIiIi8oKKugzL3zO/r9xHibknoOSciIiIiIiIiIiknGHAb33h9hXIVARqDbN1RC8kJedERERERERERCTl/poHJ1eBvRM0nwkOzraO6IWk5Jy8tHLmzMnkyZNtHcYzYTKZWLp0qa3DeGqBgYE0bdrU1mGIiIiIiIhISl37G1Z/aH5fayj4FbVtPC8wJefksS5cuMB7771H7ty5cXZ2Jnv27DRu3JgNGzak6nlq1KhBv379UrXNxzlz5gwBAQF4enri4+ND/fr1uXz58mOPi4uLY9y4cRQsWBBXV1d8fHyoUKEC3333XarGN3LkSEqWLJmqbf7000/Y29vTu3fvVG33SUyZMoXg4GBbhyEiIiIiIiIpER8HS96FmFvgXwUq9bF1RC80B1sHIGlbWFgYVapUwdvbmy+++IJixYoRExPD2rVr6d27NydOnHiu8RiGQVxcHA4OqfPodu/enYiICLZs2UK6dOnYsWMHyVnAeNSoUXz77bdMmzaNsmXLEhkZyd69e7l+/XqqxPUsBQUFMWjQIL799lsmTJhgk5VM4+LiMJlMeHl5Pfdzi4iIiIiIyFPaNhn+2QVOHtB0BtjZ2zqiF5p6zskj9erVC5PJxO7du2nRogX58+enSJEi9O/fn507d1rq3bhxg65du+Lr64unpye1atXi4MGDlv0JPcDmzZtHzpw58fLyok2bNty8eRMwD2/csmULU6ZMwWQyYTKZCAsLY/PmzZhMJlavXk2ZMmVwdnZm69athISE0KRJEzJnzoy7uzvlypVj/fr1Kb4+Ozs7AgICKFWqFAUKFCAwMJBMmTI99rjly5fTq1cvWrVqRa5cuShRogRdunRh4MCBljr37t2jb9++ZMqUCRcXF15//XX27Nlj2R8cHIy3t7dVu0uXLsVkMln2jxo1ioMHD1ruyf29zK5cuUKzZs1Ily4d+fLlY/ny5Y+NOzQ0lO3bt/Phhx+SP39+Fi9ebLU/IaYVK1ZQoEAB0qVLR8uWLbl9+zZz584lZ86cpE+fnr59+xIXF2d1rQMHDuS1117Dzc2NChUqsHnz5kTtLl++nMKFC+Ps7Ex4eHiiYa3x8fGMHz+evHnz4uzsTI4cOfjkk08s+wcPHkz+/PlJly4duXPnZtiwYcTExDz2ukVERERERCSVnD8Imz41v28wHtL72zael4CSczZiGAa3Y24/91dyeoUluHbtGmvWrKF37964ubkl2n9/YqlVq1ZcunSJ1atXs2/fPkqXLs0bb7zBtWvXLHVCQkJYunQpK1asYMWKFWzZsoVx48YB5uGNlSpVolu3bpw/f57z58+TPXt2y7Effvgh48aN4/jx4xQvXpyoqCgaNGjAhg0b+Ouvv6hXrx6NGzcmPDw8RT+HJk2aMH36dPbv35+i4/z8/Ni4ceMjh8AOGjSIRYsWMXfuXPbv30/evHkJCAiwuieP0rp1awYMGECRIkUs96R169aW/aNGjeKtt97i0KFDNGjQgHbt2j227Tlz5tCwYUO8vLxo3749QUFBiercvn2bqVOnsmDBAtasWcPmzZtp1qwZq1atYtWqVcybN49vv/2WX3/91XJMnz592LFjBwsWLODQoUO0atWKevXqcfr0aat2P//8c7777juOHj2aZBJ0yJAhjBs3jmHDhnHs2DHmz59P5syZLfs9PDwIDg7m2LFjTJkyhVmzZjFp0qRk3U8RERERERF5SjF3YHF3iI+FQo2hxNu2juiloGGtNnIn9g4V5ld47ufd1XYX6RzTJavumTNnMAyDggULPrLe1q1b2b17N5cuXcLZ2bwyy5dffsnSpUv59ddf6d69O2DuFRUcHIyHhwcAHTp0YMOGDXzyySd4eXnh5OREunTp8PPzS3SO0aNHU6dOHcu2j48PJUqUsGyPGTOGJUuWsHz5cvr0Sd5Y940bN/Lhhx8yatQoGjVqxM8//0zVqlUBWLRoEYGBgZaefQ+aOHEiLVu2xM/PjyJFilC5cmWaNGlC/fr1Abh16xYzZswgODjYUjZr1izWrVtHUFAQH3zwwWPjc3V1xd3dHQcHhyTvSWBgIG+/bf4i/PTTT5k6dSq7d++mXr16SbaXcP+/+uorANq0acOAAQMIDQ0lV65clnoxMTHMmDGDPHnyANCyZUvmzZvHxYsXcXd3p3DhwtSsWZNNmzbRunVrwsPDmTNnDuHh4WTNmhWAgQMHsmbNGubMmcOnn35qaXf69OlWP7f73bx5kylTpjBt2jQ6deoEQJ48eXj99dctdYYOHWp5nzNnTgYOHMiCBQsYNGjQY++niIiIiIiIPKUNo+HyCXDLBI2mwP9GfsnTUc85eajk9rI7ePAgUVFRZMiQAXd3d8srNDSUkJAQS72cOXNaEnMAWbJk4dKlS8k6R9myZa22o6KiGDhwIIUKFcLb2xt3d3eOHz+eop5zH374Ib1792bgwIEEBQXRuHFjfvvtNwAOHz5slRR6UOHChTly5Ag7d+7knXfe4dKlSzRu3JiuXbsC5l6CMTExVKlSxXKMo6Mj5cuX5/jx48mO8VGKFy9uee/m5oanp+cj7+e6deu4desWDRo0ACBjxozUqVOH2bNnW9VLly6dJTEHkDlzZnLmzIm7u7tVWcK5Dh8+TFxcHPnz57f6+W/ZssXq5+/k5GQV84OOHz/OvXv3eOONNx5a5+eff6ZKlSr4+fnh7u7O0KFDU9xbUkRERERERJ7A35th53Tz+yZfg1sGm4bzMlHPORtxdXBlV9tdNjlvcuXLlw+TyfTYRR+ioqLIkiWL1RxjCe4f+uro6Gi1z2QyER8fn6xYHhxWO3DgQNatW8eXX35J3rx5cXV1pWXLlkRHRyerPYBDhw7x/vvvA1C/fn2CgoJo1aoV06ZNIzg4mPHjxz/yeDs7O8qVK0e5cuXo168fP/zwAx06dODjjz9O1vnt7OwSJUBTMn9aSu9nUFAQ165dw9X1/5+B+Ph4Dh06xKhRo7Czs3tou486V1RUFPb29uzbtw97e+tJQO9P6Lm6ulrm00vK/XElZceOHbRr145Ro0YREBCAl5cXCxYsYMKECY88TkRERERERJ7SneuwtJf5fdl3IH9d28bzklFyzkZMJlOyh5faio+PDwEBAXz99df07ds3UYLsxo0beHt7U7p0aS5cuICDgwM5c+Z84vM5OTlZLTLwKNu2bSMwMJBmzZoB5gRRWFhYis732muv8ccff1iGhrZo0YKoqCg6d+5M8eLFadWqVYraK1y4MGAe0ponTx6cnJzYtm0b/v7myTFjYmLYs2cP/fr1A8DX15ebN29y69Yty709cOCAVZspuSePcvXqVZYtW8aCBQsoUqSIpTwuLo7XX3+d33///aHDYR+nVKlSxMXFcenSJcuw4CeRL18+XF1d2bBhg6UH4v22b9+Ov7+/VfLz7NmzT3w+ERERERERSaZVH0Dkv+CTG+qOtXU0Lx0l5+SRvv76a6pUqUL58uUZPXo0xYsXJzY2lnXr1jFjxgyOHz9O7dq1qVSpEk2bNmX8+PHkz5+fc+fOsXLlSpo1a5ZoSOrD5MyZk127dhEWFoa7uzs+Pj4PrZsvXz4WL15M48aNMZlMDBs2LNm98BIMGjSIXr164efnR+vWrYmIiGDHjh2kS5eOEydOsG3btocObW3ZsiVVqlShcuXK+Pn5ERoaypAhQ8ifPz8FCxbEwcGBnj178sEHH+Dj40OOHDkYP348t2/fpkuXLgBUqFCBdOnS8dFHH9G3b1927dpltRprwj0JDQ3lwIEDZMuWDQ8PD8u8fikxb948MmTIwFtvvZWo91qDBg0ICgp64uRc/vz5adeuHR07dmTChAmUKlWKy5cvs2HDBooXL07Dhg2T1Y6LiwuDBw9m0KBBODk5UaVKFS5fvszRo0fp0qUL+fLlIzw8nAULFlCuXDlWrlzJkiVLnihmERERERERSaYji+DwQjDZQ/NZ4JR4wUh5OppzTh4pd+7c7N+/n5o1azJgwACKFi1KnTp12LBhAzNmzADMvQBXrVpFtWrV6Ny5M/nz56dNmzacPXvWaqXNxxk4cCD29vYULlwYX1/fR84lNnHiRNKnT0/lypVp3LgxAQEBlC5dOkXX1qNHD37++Wd+++03ypQpw5tvvkl0dDQnTpygQ4cONG3a1Gq10fsFBATw22+/0bhxY/Lnz0+nTp0oWLAgv//+Ow4O5pz3uHHjaNGiBR06dKB06dKcOXOGtWvXkj59esDcM/GHH35g1apVFCtWjJ9++omRI0danadFixbUq1ePmjVr4uvry08//ZSia0wwe/ZsmjVrluSw0hYtWrB8+XKuXLnyRG2DeRXYjh07MmDAAAoUKEDTpk3Zs2cPOXLkSFE7w4YNY8CAAQwfPpxChQrRunVry9x2b775Ju+//z59+vShZMmSbN++nWHDhj1xzCIiIiIiIvIIUZdg5UBY3MO8XW0gZEte5xtJGZOR3Fn/5ZEiIyPx8vIiIiICT09Pq3137961rIjp4uJiowhFXi363ImIiIiIiDyBuxGw/SvYMR1ibpnLCjaCVsFg7/jIQ8Xao3JF99OwVhERERERERGRV13MXdjzHfw5Ae5cM5e9VgZqj4Rc1Wwa2stOyTkRERERERERkVdVXCwcWgCbPoPI/5rLMuaHN4abe8wlMT2SpC4l50REREREREREXjWGASdWwobRcOWkuczzNagxBEq8DfZKGT0vutMiIiIiIiIiIq+SsK2wfiT8d4952zU9VB0A5bqCo6tNQ3sVKTknIiIiIiIiIvIqOH/Q3FPuzHrztmM6qNgLqvQFFy/bxvYKU3JORERERERERORldjUENn0KR341b9s5QJlAqDYIPDLbNDRRck5ERERERERE5OV08yJs+Rz2z4X4WHNZ0ZZQ62PwyW3b2MRCyTkRERERERERkZfJ3QjYNhV2ToeY2+ayvHXMK7BmKW7b2CQRJedERERERERERF4GMXdg9yzYOhHuXDeXZSsHtUdCztdtGpo8nJJz8kKqUaMGJUuWZPLkybYORURERERERMS24mLh4HzYPA4i/zWXZSxg7ilXsCGYTLaNTx5JyTl5pMDAQObOnZuoPCAggDVr1tggIrPFixfj6Ohos/OLiIiIiIiI2JxhwPHfYOMYuHLKXOaZDWp+BCXagJ29beOTZFFyTh6rXr16zJkzx6rM2dn5idoyDIO4uDgcHJ7u0fPx8Xmq40VEREREREReaOG7YO0Q+HefedvVB6oNhLJdwNHFtrFJitjZOgBJ+5ydnfHz87N6pU+fnrCwMEwmEwcOHLDUvXHjBiaTic2bNwOwefNmTCYTq1evpkyZMjg7O7N161ZCQkJo0qQJmTNnxt3dnXLlyrF+/Xqr806fPp18+fLh4uJC5syZadmypWVfjRo16Nevn2V73rx5lC1bFg8PD/z8/Gjbti2XLl16lrdFRERERERE5PmLjYb1I2F2gDkx5+gG1QbBfw5Apd5KzL2A1HPORgzDwLhz57mf1+TqiskGY80//PBDvvzyS3Lnzk369On5559/aNCgAZ988gnOzs58//33NG7cmJMnT5IjRw727t1L3759mTdvHpUrV+batWv8+eefD20/JiaGMWPGUKBAAS5dukT//v0JDAxk1apVz/EqRURERERERJ6hS8dhcTe4cNi8XeJtqDMa3DPZNi55KkrO2Yhx5w4nS5d57uctsH8fpnTpUnTMihUrcHd3tyr76KOPaNu2bbLbGD16NHXq1LFs+/j4UKJECcv2mDFjWLJkCcuXL6dPnz6Eh4fj5uZGo0aN8PDwwN/fn1KlSj20/XfeecfyPnfu3EydOpVy5coRFRWVKHYRERERERGRF0p8POz6xtxjLu6eeQhr48lQuImtI5NUoOScPFbNmjWZMWOGVZmPjw+RkZHJbqNs2bJW21FRUYwcOZKVK1dy/vx5YmNjuXPnDuHh4QDUqVMHf39/cufOTb169ahXrx7NmjUj3UMSi/v27WPkyJEcPHiQ69evEx8fD0B4eDiFCxdOyeWKiIiIiIiIpB0R/4WlPSH0D/N23jrQZBp4+Nk2Lkk1Ss7ZiMnVlQL799nkvCnl5uZG3rx5E5VHRUUB5iG6CWJiYh7axv0GDhzIunXr+PLLL8mbNy+urq60bNmS6OhoADw8PNi/fz+bN2/m999/Z/jw4YwcOZI9e/bg7e1t1datW7cICAggICCAH3/8EV9fX8LDwwkICLC0JyIiIiIiIvLCObQQVg6AexHgmA7qjoWy74ANpquSZ0fJORsxmUwpHl6a1vj6+gJw/vx5y5DT+xeHeJRt27YRGBhIs2bNAHOiLywszKqOg4MDtWvXpnbt2owYMQJvb282btxI8+bNreqdOHGCq1evMm7cOLJnzw7A3r17n+LKRERERERERGzo9jVYNRCOLDJvv1YGms2EjIk7zsiLT8k5eax79+5x4cIFqzIHBwcyZsxIxYoVGTduHLly5eLSpUsMHTo0WW3my5ePxYsX07hxY0wmE8OGDbMMRQXzPHd///031apVI3369KxatYr4+HgKFCiQqK0cOXLg5OTEV199xbvvvsuRI0cYM2bM0120iIiIiIiIiC2EbIKlveDmOTDZQ/VBUHUg2CuF87Kys3UAkvatWbOGLFmyWL1ef/11AGbPnk1sbCxlypShX79+jB07NlltTpw4kfTp01O5cmUaN25MQEAApUuXtuz39vZm8eLF1KpVi0KFCvHNN9/w008/UaRIkURt+fr6EhwczMKFCylcuDDjxo3jyy+/TJ2LFxEREREREXkeYu7A6sEwr6k5MeeTB7qsgxofKjH3kjMZ908YJk8sMjISLy8vIiIi8PT0tNp39+5dQkNDyZUrFy4uLjaKUOTVos+diIiIiIi8MM4dgMXd4cpJ83a5rlBnNDi5PfIwSdselSu6n1KvIiIiIiIiIiK2EBcL2ybD5s8gPhbcM0OTryFfHVtHJs+RknMiIiIiIiIiIs/btb9hybvwzy7zdqE3odFkcMtg07Dk+VNyTkRERERERETkeTEM2P89rBkCMbfA2RMafAHFW4PJZOvoxAaUnBMREREREREReR6iLsNvfeHkKvO2fxVo9g1457BtXGJTSs6JiIiIiIiIiDxrJ1bB8vfg9hWwd4Jaw6BSb7Czt3VkYmNKzomIiIiIiIiIPCv3bsLaj8xDWQEyFYHmM8GvqG3jkjRDyTkRERERERERkWchfBcs6Q7XwwATVO4DNYeCo4utI5M0RMk5EREREREREZHUFBsNW8bB1klgxINXdmg6A3JVtXVkkgYpOSciIiIiIiIiklqu/Q0LA+H8QfN2ibeh/ufg4mXTsCTtUnJORERERERERCQ1XA2B4IZw8zy4podGk6FIU1tHJWmcna0DkLQtMDAQk8mU6FWvXj1bhyYiIiIiIiKSdtyfmPMtCD23KzEnyaKec/JY9erVY86cOVZlzs7OT9SWYRjExcXh4KBHT0RERERERF4SV87A3Eb/S8wVgk6/gbuvraOSF4R6zsljOTs74+fnZ/VKnz49YWFhmEwmDhw4YKl748YNTCYTmzdvBmDz5s2YTCZWr15NmTJlcHZ2ZuvWrdy7d4++ffuSKVMmXFxceP3119mzZ4+lnYTjVq5cSfHixXFxcaFixYocOXLEKratW7dStWpVXF1dyZ49O3379uXWrVvP47aIiIiIiIiImBNzCT3mMhVWYk5STMk5GzEMg5h7cc/9ZRiGTa73ww8/ZNy4cRw/fpzixYszaNAgFi1axNy5c9m/fz958+YlICCAa9euWR33wQcfMGHCBPbs2YOvry+NGzcmJiYGgJCQEOrVq0eLFi04dOgQP//8M1u3bqVPnz62uEQRERERERF51Vw5bU7MRV1QYk6emMYW2khsdDwz/7PluZ+3+5TqODrbp+iYFStW4O7ublX20Ucf0bZt22S3MXr0aOrUqQPArVu3mDFjBsHBwdSvXx+AWbNmsW7dOoKCgvjggw8sx40YMcJy3Ny5c8mWLRtLlizhrbfe4rPPPqNdu3b069cPgHz58jF16lSqV6/OjBkzcHFxSdF1ioiIiIiIiCTbldMQ3Mg6MeeW0dZRyQtIyTl5rJo1azJjxgyrMh8fHyIjI5PdRtmyZS3vQ0JCiImJoUqVKpYyR0dHypcvz/Hjx62Oq1SpktU5CxQoYKlz8OBBDh06xI8//mipYxgG8fHxhIaGUqhQoWTHJyIiIiIiIpJslh5zFyFTEei0XIk5eWJKztmIg5Md3adUt8l5U8rNzY28efMmKo+KigKwGiqbMOQ0qTZSW1RUFD169KBv376J9uXIkSPVzyciIiIiIiLC5VPmxR+UmJNUouScjZhMphQPL01rfH3N4+jPnz9PqVKlAKwWh3iYPHny4OTkxLZt2/D39wfMSb09e/ZYhqgm2LlzpyXRdv36dU6dOmXpEVe6dGmOHTuWZOJQREREREREJNXdn5jLXBQ6Lge3DLaOSl5wSs7JY927d48LFy5YlTk4OJAxY0YqVqzIuHHjyJUrF5cuXWLo0KGPbc/NzY2ePXvywQcf4OPjQ44cORg/fjy3b9+mS5cuVnVHjx5NhgwZyJw5Mx9//DEZM2akadOmAAwePJiKFSvSp08funbtipubG8eOHWPdunVMmzYt1a5fREREREREhMsnzXPM3boEmYtBx2VKzEmqUHJOHmvNmjVkyZLFqqxAgQKcOHGC2bNn06VLF8qUKUOBAgUYP348devWfWyb48aNIz4+ng4dOnDz5k3Kli3L2rVrSZ8+faJ6//nPfzh9+jQlS5bkt99+w8nJCYDixYuzZcsWPv74Y6pWrYphGOTJk4fWrVun3sWLiIiIiIiIXDoBcxsrMSfPhMm4f8IweWKRkZF4eXkRERGBp6en1b67d+8SGhpKrly5tIJoMm3evJmaNWty/fp1vL29bR2OvID0uRMRERERkVRx6YR5KOuty+bEXKflkM7H1lHJC+BRuaL7qeeciIiIiIiIiEhS7k/M+RUzzzGnxJykspQv3SkiIiIiIiIi8rK7dPy+xFxxJebkmVHPOUmTatSogUZci4iIiIiIiE1cOm5e/OH2lf8l5pYpMSfPjHrOiYiIiIiIiIgkuHjs/xNzWUooMSfPnJJzIiIiIiIiIiJgTszNbfz/ibkOS5WYk2dOw1pFRERERERERC4eM88xd/uqEnPyXKnnnIiIiIiIiIi82i4evS8xV1JDWeW5UnJORERERERERF5dF478byjrVchaCjouBdf0to5KXiEa1ioiIiIiIiIir6aExNyda+bEXIel4Opt66jkFaOec5KqatSoQb9+/R5ZJ2fOnEyePPmRdUwmE0uXLgUgLCwMk8nEgQMHUiVGERERERERES4cVmJO0gQl5+SRAgMDMZlMvPvuu4n29e7dG5PJRGBgoKVs8eLFjBkz5jlGmDybN2/GZDIl+bpw4UKqnCM5SUcRERERERFJAy4chrlv/i8xV1qJObEpJefksbJnz86CBQu4c+eOpezu3bvMnz+fHDlyWNX18fHBw8PjeYeYbCdPnuT8+fNWr0yZMtk6LBEREREREXle7u8x91oZ6LBEiTmxKSXn5LFKly5N9uzZWbx4saVs8eLF5MiRg1KlSlnVfXBY66VLl2jcuDGurq7kypWLH3/8MVH7p0+fplq1ari4uFC4cGHWrVv32JiOHDlC/fr1cXd3J3PmzHTo0IErV6489rhMmTLh5+dn9bKzM38M9uzZQ506dciYMSNeXl5Ur16d/fv3W441DIORI0eSI0cOnJ2dyZo1K3379rVc99mzZ3n//fctPfJEREREREQkjTl/6H+JuetKzEmaoeScjRiGQczdu8/9ZRjGE8X7zjvvMGfOHMv27Nmz6dy582OPCwwM5J9//mHTpk38+uuvTJ8+nUuXLln2x8fH07x5c5ycnNi1axfffPMNgwcPfmSbN27coFatWpQqVYq9e/eyZs0aLl68yFtvvfVE15bg5s2bdOrUia1bt7Jz507y5ctHgwYNuHnzJgCLFi1i0qRJfPvtt5w+fZqlS5dSrFgxwJyszJYtG6NHj7b0yBMREREREZE05MIR+P7N/yXmypoTcy5eto5KRKu12krsvXtM7dTyuZ+379xfcXRxSfFx7du3Z8iQIZw9exaAbdu2sWDBAjZv3vzQY06dOsXq1avZvXs35cqVAyAoKIhChQpZ6qxfv54TJ06wdu1asmbNCsCnn35K/fr1H9rutGnTKFWqFJ9++qmlbPbs2WTPnp1Tp06RP3/+hx6bLVs2q21/f3+OHj0KQK1ataz2zZw5E29vb7Zs2UKjRo0IDw/Hz8+P2rVr4+joSI4cOShfvjxgHs5rb2+Ph4cHfn5+Dz2/iIiIiIiI2MCV0zCv6X2JucVKzEmaoeScJIuvry8NGzYkODgYwzBo2LAhGTNmfOQxx48fx8HBgTJlyljKChYsiLe3t1Wd7NmzWxJzAJUqVXpkuwcPHmTTpk24u7sn2hcSEvLI5Nyff/5pNSeeo6Oj5f3FixcZOnQomzdv5tKlS8TFxXH79m3Cw8MBaNWqFZMnTyZ37tzUq1ePBg0a0LhxYxwc9DESERERERFJs66fhe+bwK3L4Fcc2i9SYk7SFGUVbMTB2Zm+c3+1yXmf1DvvvEOfPn0A+Prrr1MrpBSLioqicePGfP7554n2ZcmS5ZHH5sqVyyo5eL9OnTpx9epVpkyZgr+/P87OzlSqVIno6GjAvDDGyZMnWb9+PevWraNXr1588cUXbNmyxSrJJyIiIiIiImlE5HnzUNbIfyFjAc0xJ2mSknM2YjKZnmh4qS3Vq1eP6OhoTCYTAQEBj61fsGBBYmNj2bdvn2VY68mTJ7lx44alTqFChfjnn384f/68JbG2c+fOR7ZbunRpFi1aRM6cOVO119q2bduYPn06DRo0AOCff/5JtMiEq6srjRs3pnHjxvTu3ZuCBQty+PBhSpcujZOTE3FxcakWj4iIiIiIiDyFW1fMPeauh0H6nNBxGbg9egSYiC1oQQhJNnt7e44fP86xY8ewt7d/bP0CBQpQr149evTowa5du9i3bx9du3bF1dXVUqd27drkz5+fTp06cfDgQf78808+/vjjR7bbu3dvrl27xttvv82ePXsICQlh7dq1dO7c+bHJsUuXLnHhwgWrV0xMDAD58uVj3rx5HD9+nF27dtGuXTurWIODgwkKCuLIkSP8/fff/PDDD7i6uuLv7w9Azpw5+eOPP/j333+TtXKsiIiIiIiIPCN3bsC8ZnDlJHi+Bh2Xg+ejR1qJ2IqSc5Iinp6eeHp6Jrv+nDlzyJo1K9WrV6d58+Z0796dTJkyWfbb2dmxZMkS7ty5Q/ny5enatSuffPLJI9vMmjUr27ZtIy4ujrp161KsWDH69euHt7c3dnaPfqQLFChAlixZrF779u0DzItVXL9+ndKlS9OhQwf69u1rFau3tzezZs2iSpUqFC9enPXr1/Pbb7+RIUMGAEaPHk1YWBh58uTB19c32fdIREREREREUtG9KPixFVw4BG6+5h5z6f1tHZXIQ5kMwzBsHcTLIDIyEi8vLyIiIhIlr+7evUtoaCi5cuXC5QUbyiryotLnTkRERETkFRRzF+a3gtA/zIs+BK4Ev2K2jkpeUY/KFd1PPedERERERERE5MUXFwMLO5kTc07u0H6xEnPyQlByTkRERERERERebPFxsLg7nFoDDi7Q9mfIVtbWUYkki5JzIiIiIiIiIvLiio+H5X3h6GKwc4TWP0DO120dlUiy2TQ599lnn1GuXDk8PDzIlCkTTZs25eTJk1Z1atSogclksnq9++67VnXCw8Np2LAh6dKlI1OmTHzwwQfExsZa1dm8eTOlS5fG2dmZvHnzEhwcnCier7/+mpw5c+Li4kKFChXYvXt3ql+ziIiIiIiIiKQSw4A1H8KBH8BkBy2DIF8dW0clkiI2Tc5t2bKF3r17s3PnTtatW0dMTAx169bl1q1bVvW6devG+fPnLa/x48db9sXFxdGwYUOio6PZvn07c+fOJTg4mOHDh1vqhIaG0rBhQ2rWrMmBAwfo168fXbt2Ze3atZY6P//8M/3792fEiBHs37+fEiVKEBAQwKVLl579jRARERERERGRlNs4BnZ/a37fZDoUbmLbeESeQJparfXy5ctkypSJLVu2UK1aNcDcc65kyZJMnjw5yWNWr15No0aNOHfuHJkzZwbgm2++YfDgwVy+fBknJycGDx7MypUrOXLkiOW4Nm3acOPGDdasWQNAhQoVKFeuHNOmTQMgPj6e7Nmz89577/Hhhx8+Nnat1iqStuhzJyIiIiLykvtzAmwYbX7fcAKU62rbeEQe8EKu1hoREQGAj4+PVfmPP/5IxowZKVq0KEOGDOH27duWfTt27KBYsWKWxBxAQEAAkZGRHD161FKndu3aVm0GBASwY8cOAKKjo9m3b59VHTs7O2rXrm2p86B79+4RGRlp9RIRERERERGR52DXt/+fmKszWok5eaE52DqABPHx8fTr148qVapQtGhRS3nbtm3x9/cna9asHDp0iMGDB3Py5EkWL14MwIULF6wSc4Bl+8KFC4+sExkZyZ07d7h+/TpxcXFJ1jlx4kSS8X722WeMGjXq6S5aRERERERERFJm/zxYPcj8vvpgqPIf28Yj8pTSTHKud+/eHDlyhK1bt1qVd+/e3fK+WLFiZMmShTfeeIOQkBDy5MnzvMO0GDJkCP3797dsR0ZGkj17dpvFIyIiIiIiIvLSO7IYfutrfl+xN9QYYtt4RFJBmhjW2qdPH1asWMGmTZvIli3bI+tWqFABgDNnzgDg5+fHxYsXreokbPv5+T2yjqenJ66urmTMmBF7e/sk6yS08SBnZ2c8PT2tXpJ6AgMDadq0qa3DeGqbN2/GZDJx48YNW4ciIiIiIiLyYju5BhZ3AyMeSneCgE/AZLJ1VCJPzabJOcMw6NOnD0uWLGHjxo3kypXrscccOHAAgCxZsgBQqVIlDh8+bLWq6rp16/D09KRw4cKWOhs2bLBqZ926dVSqVAkAJycnypQpY1UnPj6eDRs2WOq8qgIDAzGZTIwbN86qfOnSpZhS4UswLCwMk8lk+bmmhjt37uDj40PGjBm5d+9eqrX7JCpXrsz58+fx8vKyaRwiIiIiIiIvtL83wy8dIT4WirWCRpOUmJOXhk2Tc7179+aHH35g/vz5eHh4cOHCBS5cuMCdO3cACAkJYcyYMezbt4+wsDCWL19Ox44dqVatGsWLFwegbt26FC5cmA4dOnDw4EHWrl3L0KFD6d27N87OzgC8++67/P333wwaNIgTJ04wffp0fvnlF95//31LLP3792fWrFnMnTuX48eP07NnT27dukXnzp2f/41JY1xcXPj888+5fv16qrYbHR2dqu0lWLRoEUWKFKFgwYIsXbr0mZwjOWJiYnBycsLPzy9VEpkiIiIiIiKvpPBd8FNbiLsHBRpC0xlgZ2/rqERSjU2TczNmzCAiIoIaNWqQJUsWy+vnn38GzD3a1q9fT926dSlYsCADBgygRYsW/Pbbb5Y27O3tWbFiBfb29lSqVIn27dvTsWNHRo8ebamTK1cuVq5cybp16yhRogQTJkzgu+++IyAgwFKndevWfPnllwwfPpySJUty4MAB1qxZk2iRiFdR7dq18fPz47PPPntkvYSkmLOzMzlz5mTChAlW+3PmzMmYMWPo2LEjnp6edO/e3dJbslSpUphMJmrUqGF1zJdffkmWLFnIkCEDvXv3JiYm5rHxBgUF0b59e9q3b09QUFCi/SaTiW+//ZZGjRqRLl06ChUqxI4dOzhz5gw1atTAzc2NypUrExISYnXcsmXLKF26NC4uLuTOnZtRo0YRGxtr1e6MGTN48803cXNz45NPPklyWOu2bduoUaMG6dKlI3369AQEBFgSn2vWrOH111/H29ubDBky0KhRo0RxiIiIiIiIvDLOHYAfW0HMLchdE1rNAXtHW0clkqpMhmEYtg7iZRAZGYmXlxcRERGJ5p+7e/cuoaGh5MqVCxcXF8A8pNeIiX/ucZoc7VLUiyswMJAbN27QqVMn2rZty+nTp8mWLRtLly6lWbNmJDw++/bto3z58owcOZLWrVuzfft2evXqxfTp0wkMDATMybnr168zfPhwy3xy165do3z58qxfv54iRYrg5OSEj48PgYGBLFmyhLZt2/Kf//yHM2fO0Lp1ayZPnky3bt0eGm9ISAhFihTh/PnzGIbBa6+9xokTJ/D39///e2Ay8dprrzFx4kRKlizJ4MGDOXDgALlz52bQoEHkyJGDd955B29vb1avXg3An3/+SaNGjZg6dSpVq1YlJCSE7t27ExgYyIgRIyztZsqUiXHjxlG9enUcHBz4+++/qVmzJtevX8fb25sDBw5QsWJF3nnnHXr06IGDgwObNm2iTZs2ZMyYkUWLFmEymShevDhRUVEMHz6csLAwDhw4gJ1dmpgi8oWR1OdOREREREReIJdOQHADuH0VclSC9ovAyc3WUYkk26NyRfdTci6VpDQ5Fx8dx7nh2597nFlHV8bOKfndfxOSc0uXLqVSpUoULlyYoKCgRMm5du3acfnyZX7//XfLsYMGDWLlypUcPXoUMCfnSpUqxZIlSyx1wsLCyJUrF3/99RclS5a0Ou/mzZsJCQnB3t4c71tvvYWdnR0LFix4aLwff/wxx44ds5yjadOmlCxZkpEjR1rqmEwmhg4dypgxYwDYuXMnlSpVIigoiHfeeQeABQsW0LlzZ8sQ69q1a/PGG28wZMj/rwT0ww8/MGjQIM6dO2dpt1+/fkyaNMlSZ/PmzVbJubZt2xIeHp5oVeKHuXLlCr6+vhw+fJiiRYsm6xgxU3JOREREROQFdu1vmF0foi5AlpLQaTm4aC5vebEkNzmnrjiSbJ9//rllTr4HHT9+nCpVqliVValShdOnTxMXF2cpK1u2bLLPV6RIEUtiDsyLgNy/8MeD4uLimDt3Lu3bt7eUtW/fnuDgYOLjrXspJsxZCFiGLhcrVsyq7O7du0RGRgJw8OBBRo8ejbu7u+XVrVs3zp8/z+3bt5N9fQcOHOCNN9546P7Tp0/z9ttvkzt3bjw9PcmZMycA4eHhj2xXRERERETkpRHxX5jbxJyYy1QYOixRYk5eag62DuBVZXK0I+voyjY575OqVq0aAQEBDBkyxDJUNaXc3JLfBdnR0XoeAZPJlCjJdr+1a9fy77//0rp1a6vyuLg4NmzYQJ06dZJsO2GYb1JlCeeLiopi1KhRNG/ePNF57++V9bjrc3V1feT+xo0b4+/vz6xZs8iaNSvx8fEULVr0mS2eISIiIiIikqZEXYLvm0BEOPjkhg5LIZ2PraMSeaaUnLMRk8mEKQXDS9OKcePGUbJkSQoUKGBVXqhQIbZt22ZVtm3bNvLnz2/V++1BTk5OAFa9655UUFAQbdq04eOPP7Yq/+STTwgKCrJKzqVU6dKlOXnyJHnz5n2qGIsXL86GDRsYNWpUon1Xr17l5MmTzJo1i6pVqwIke/iriIiIiIjIC+/2NZjXDK6eAc9s0HEZeGiRRnn5KTknKVKsWDHatWvH1KlTrcoHDBhAuXLlGDNmDK1bt2bHjh1MmzaN6dOnP7K9TJky4erqypo1a8iWLRsuLi54eaW8u/Lly5f57bffWL58eaK52Tp27EizZs24du0aPj5P9heX4cOH06hRI3LkyEHLli2xs7Pj4MGDHDlyhLFjxya7nSFDhlCsWDF69erFu+++i5OTE5s2baJVq1b4+PiQIUMGZs6cSZYsWQgPD+fDDz98onhFREREREReKPduwo8t4eIRcMtknmPOO4etoxJ5LjTnnKTY6NGjEw0vLV26NL/88gsLFiygaNGiDB8+nNGjRz92+KuDgwNTp07l22+/JWvWrDRp0uSJYvr+++9xc3NLcj63N954A1dXV3744YcnahsgICCAFStW8Pvvv1OuXDkqVqzIpEmTrFaBTY78+fPz+++/c/DgQcqXL0+lSpVYtmwZDg4OlsUu9u3bR9GiRXn//ff54osvnjhmERERERGRF8LdSJjfGv7dB67pzT3mMuSxdVQiz41Wa00lKV2tVUSeLX3uREREREReAFGX4IcWcOEQOHmYe8y9VtrWUYmkiuSu1qphrSIiIiIiIiLy/F0NgR+aw/UwSJcR2v2ixJy8kpScExEREREREZHn69wB8xxzty6Dtz90WKKhrPLKUnJORERERERERJ6fkE3wc3uIjgK/YtBukVZllVeaknMiIiIiIiIi8nwc/hWWvAvxMZCzKrSZDy4Pn4tL5FWg1VpFRERERERE5NnbMR0WdTEn5oo0g/aLlJgTQT3nnqv4+HhbhyDyytBC1CIiIiIiaYRhwPqRsG2yebt8d6j3Odipv5AIKDn3XDg5OWFnZ8e5c+fw9fXFyckJk8lk67BEXlqGYXD58mVMJhOOjo62DkdERERE5NUVFwPL+8LB+ebtWsOg6gDQv4lFLJScew7s7OzIlSsX58+f59y5c7YOR+SVYDKZyJYtG/b29rYORURERETk1RR9CxYGwunfwWQPjadA6Q62jkokzVFy7jlxcnIiR44cxMbGEhcXZ+twRF56jo6OSsyJiIiIiNjKrasw/y34dy84uEKrYChQz9ZRiaRJSs49RwlD7DTMTkRERERERF5aN8JhXnO4ehpcvKHdQshe3tZRiaRZSs6JiIiIiIiISOq4eBR+aAE3z4NnNuiwGHwL2DoqkTRNyTkREREREREReXph2+Cnt+FeBPgWgvaLwOs1W0clkuYpOSciIiIiIiIiT+fYcljUFeLuQY5K8PZP4Jre1lGJvBDsbB2AiIiIiIiIiLzA9gTBwk7mxFyBhtBhiRJzIimgnnMiIiIiIiIiknKGAZvHwZZx5u3SnaDhRLBXqkEkJfSJEREREREREZGUiY+Dlf1hX7B5u/pgqDEETCabhiXyIlJyTkRERERERESSL+aOeX65EysAEzT8Esp1tXVUIi8sJedEREREREREJHnu3DCvyBq+HeydoMV3ULiJraMSeaEpOSciIiIiIiIijxd5Dn5oAZeOgbOneUXWnK/bOiqRF56ScyIiIiIiIiLyaJdPwQ/NIeIfcPeD9ovAr6itoxJ5KSg5JyIiIiIiIiIP988emN8K7lyHDHmh/WJI72/rqEReGkrOiYiIiIiIiEhihgHHlsKSnhB7B14rA20XglsGW0cm8lJRck5ERERERERErJ3dDutHwT87zdt568Bbc8HJzbZxibyElJwTEREREREREbPzh2DDaDizzrzt4AIVe0HNj8De0baxibyklJwTERERERERedVdDYFNn8CRReZtOwco3RGqDQLPLLaNTeQlp+SciIiIiIiIyKsq8jxs+Rz+mgfxseayoi3NPeUy5LFtbCKvCCXnRERERERERF41t6/Btsmw61uIvWsuy1cXag2DLMVtGprIq0bJOREREREREZFXRfQt2DkDtk2FexHmsuwVofYI8K9s29hEXlFKzomIiIiIiIi87GKjYV8w/PEF3LpkLstcFN4Ybu4xZzLZNDyRV5mScyIiIiIiIiIvq/g4OLzQvNjDjXBzWfqcUHMoFG0BdnY2DU9ElJwTERERERERefkYBpxcBRvGwOXj5jL3zFB9EJTqCA5Oto1PRCyUnBMRERERERF5mYT+CRtGwX/3mLddvOD196F8D3BKZ9vYRCQRJedEREREREREXgbnDsCG0RCywbzt4AoVe0KVvuCa3qahicjDpTg5Fxoayp9//snZs2e5ffs2vr6+lCpVikqVKuHi4vIsYhQRERERERGRh7lyGjaOhWNLzdt2DlAmEKp9AB5+toxMRJIh2cm5H3/8kSlTprB3714yZ85M1qxZcXV15dq1a4SEhODi4kK7du0YPHgw/v7+zzJmEREREREREYn4F7aMg79+BCMOMEGxVlBzCPjktnV0IpJMyUrOlSpVCicnJwIDA1m0aBHZs2e32n/v3j127NjBggULKFu2LNOnT6dVq1bPJGARERERERGRV1psNGydCH9OhLh75rL89aDWMPAratvYRCTFTIZhGI+rtHbtWgICApLV4NWrVwkLC6NMmTJPHdyLJDIyEi8vLyIiIvD09LR1OCIiIiIiIvIyOn8IlvaCi4fN2zkqQ+0RkKOibeMSkUSSmytKVs+55CbmADJkyECGDBmSXV9EREREREREHiOht9wfX0B8LLj6QIMvoGgLMJlsHZ2IPAW7lB6wf/9+Dh8+bNletmwZTZs25aOPPiI6OjpVgxMRERERERF55V04DLNqwebPzIm5Qo2h9y4o1lKJOZGXQIqTcz169ODUqVMA/P3337Rp04Z06dKxcOFCBg0alOoBioiIiIiIiLyS4mJg8ziYWcM8jNXVB1oEwVvzwD2TraMTkVSS4uTcqVOnKFmyJAALFy6kWrVqzJ8/n+DgYBYtWpTa8YmIiIiIiIi8ei4chlk1/7+3XMFG6i0n8pJK1pxz9zMMg/j4eADWr19Po0aNAMiePTtXrlxJ3ehEREREREREXiVxMfDnBM0tJ/IKSXFyrmzZsowdO5batWuzZcsWZsyYAUBoaCiZM2dO9QBFREREREREXgkXDsPSnub/grm3XKNJGsIq8pJLcXJu8uTJtGvXjqVLl/Lxxx+TN29eAH799VcqV66c6gGKiIiIiIiIvNTiYuDPifDH+P/1lksPDb5UbzmRV4TJMAwjNRq6e/cu9vb2ODo6pkZzL5zIyEi8vLyIiIjA09PT1uGIiIiIiIjIi0C95UReWsnNFaW45xzAjRs3+PXXXwkJCeGDDz7Ax8eHY8eOkTlzZl577bUnDlpERERERETklaDeciLyPylOzh06dIg33ngDb29vwsLC6NatGz4+PixevJjw8HC+//77ZxGniIiIiIiIyMvhwpH/9ZY7ZN5WbzmRV5pdSg/o378/nTt35vTp07i4uFjKGzRowB9//JGqwYmIiIiIiIi8NOJiYMt4mFnDnJhzTQ8tgqD1D0rMibzCUtxzbs+ePXz77beJyl977TUuXLiQKkGJiIiIiIiIvFSS6i3XcCJ4ZLZtXCJicylOzjk7OxMZGZmo/NSpU/j6+qZKUCIiIiIiIiIvhbgY2DrJ3GMuPkZzy4lIIike1vrmm28yevRoYmJiADCZTISHhzN48GBatGiR6gGKiIiIiIiIvJAuHIHv3oBNn5gTcwUbQa9dUKylEnMiYpHi5NyECROIiooiU6ZM3Llzh+rVq5M3b148PDz45JNPnkWMIiIiIiIiIi+O++eWO3/Q3Fuu+XfmueU0jFVEHpDiYa1eXl6sW7eOrVu3cujQIaKioihdujS1a9d+FvGJiIiIiIiIvDiuhsCvnc1JOYACDc0rsSopJyIPYTIMw7B1EC+DyMhIvLy8iIiIwNPT09bhiIiIiIiIyPP2z274qQ3cvmruLVf/Cw1hFXmFJTdXlKyec1OnTk32ifv27ZvsuiIiIiIiIiIvhWPLYXE3iL0LWUrC2wvAM4utoxKRF0Cyes7lypXLavvy5cvcvn0bb29vAG7cuEG6dOnIlCkTf//99zMJNK1TzzkREREREZFX1M4ZsGYIYED+etAiCJzdbR2ViNhYcnNFyVoQIjQ01PL65JNPKFmyJMePH+fatWtcu3aN48ePU7p0acaMGZNqFyAiIiIiIiKSpsXHmZNyaz4EDCjbBVr/qMSciKRIiuecy5MnD7/++iulSpWyKt+3bx8tW7YkNDQ0VQN8UajnnIiIiIiIyCsk5o55GOvx38zbtUdBlf9ofjkRsUjVOefud/78eWJjYxOVx8XFcfHixZQ2JyIiIiIiIvJiuXXFvPDDf/eAvRM0+waKtrB1VCLygkrWsNb7vfHGG/To0YP9+/dbyvbt20fPnj2pXbt2qgYnIiIiIiIikqZcDYHvapsTcy7e0HGZEnMi8lRSnJybPXs2fn5+lC1bFmdnZ5ydnSlfvjyZM2fmu+++exYxioiIiIiIiNhe+C5zYu56KHjngC7rwL+yraMSkRdcioe1+vr6smrVKk6dOsWJEycAKFiwIPnz50/14ERERERERETShGPLYFE3iLsHWUtB21/APZOtoxKRl0CKk3MJ8ufPr4SciIiIiIiIvNwMA3ZOh7UfAwbkrw8tg8DJzdaRichL4omSc//9739Zvnw54eHhREdHW+2bOHFiqgQmIiIiIiIiYlPxcbD2I9j1jXm7XFeoPx7s7G0bl4i8VFKcnNuwYQNvvvkmuXPn5sSJExQtWpSwsDAMw6B06dLPIkYRERERERGR5yv6NizuBidWmLfrjIHK74HJZNu4ROSlk+IFIYYMGcLAgQM5fPgwLi4uLFq0iH/++Yfq1avTqlWrZxGjiIiIiIiIyPMTdRnmNjYn5uydoeUcqNJXiTkReSZSnJw7fvw4HTt2BMDBwYE7d+7g7u7O6NGj+fzzz1M9QBEREREREZHn5soZCKoN/+4F1/TQcRkUbW7rqETkJZbi5Jybm5tlnrksWbIQEhJi2XflypXUi0xERERERETkeQrfaU7MXQ8Db3/osg78K9k6KhF5yaV4zrmKFSuydetWChUqRIMGDRgwYACHDx9m8eLFVKxY8VnEKCIiIiIiIvJsHV0Ci3tA3D3IWhra/gzumWwdlYi8AlKcnJs4cSJRUVEAjBo1iqioKH7++Wfy5cunlVpFRERERETkxWIYsGMa/D7UvF2gAbT4DpzcbBuXiLwyTIZhGLYO4mUQGRmJl5cXEREReHp62jocEREREREReZz4OFjzIeyead4u3x3qjQM7e9vGJSIvheTmilLcc05ERERERETkhRd9GxZ1hZMrzdt1P4FKvbUiq4g8d8lKzqVPnx5TMr+grl279lQBiYiIiIiIiDxTUZfhp9bw7z6wd4bmM6FIU1tHJSKvqGSt1jp58mQmTZrEpEmTGDrUPA4/ICCAkSNHMnLkSAICAgAYNmxYik7+2WefUa5cOTw8PMiUKRNNmzbl5MmTVnXu3r1L7969yZAhA+7u7rRo0YKLFy9a1QkPD6dhw4akS5eOTJky8cEHHxAbG2tVZ/PmzZQuXRpnZ2fy5s1LcHBwoni+/vprcubMiYuLCxUqVGD37t0puh4RERERERFJ466chu/eMCfmXH2g03Il5kTEplI851yLFi2oWbMmffr0sSqfNm0a69evZ+nSpcluq169erRp04Zy5coRGxvLRx99xJEjRzh27BhububJN3v27MnKlSsJDg7Gy8uLPn36YGdnx7Zt2wCIi4ujZMmS+Pn58cUXX3D+/Hk6duxIt27d+PTTTwEIDQ2laNGivPvuu3Tt2pUNGzbQr18/Vq5caUks/vzzz3Ts2JFvvvmGChUqMHnyZBYuXMjJkyfJlOnxK/RozjkREREREZE07uwOWPA23LkO6XNCu0WQMa+toxKRl1Ryc0UpTs65u7tz4MAB8ua1/gI7c+YMJUuWtKzk+iQuX75MpkyZ2LJlC9WqVSMiIgJfX1/mz59Py5YtAThx4gSFChVix44dVKxYkdWrV9OoUSPOnTtH5syZAfjmm28YPHgwly9fxsnJicGDB7Ny5UqOHDliOVebNm24ceMGa9asAaBChQqUK1eOadOmARAfH0/27Nl57733+PDDDx8bu5JzIiIiIiIiaVRcLGyfApvHQVw0vFYW3l4A7r62jkxEXmLJzRUla1jr/TJkyMCyZcsSlS9btowMGTKktDkrERERAPj4+ACwb98+YmJiqF27tqVOwYIFyZEjBzt27ABgx44dFCtWzJKYA/OQ28jISI4ePWqpc38bCXUS2oiOjmbfvn1Wdezs7Khdu7alzoPu3btHZGSk1UtERERERETSmIvHIKg2bBhtTswVehM6/abEnIikGSlerXXUqFF07dqVzZs3U6FCBQB27drFmjVrmDVr1hMHEh8fT79+/ahSpQpFixYF4MKFCzg5OeHt7W1VN3PmzFy4cMFS5/7EXML+hH2PqhMZGcmdO3e4fv06cXFxSdY5ceJEkvF+9tlnjBo16skuVkRERERERJ6tuFjYNhm2fG5Oyrl4Qb3PoUQbrcgqImlKipNzgYGBFCpUiKlTp7J48WIAChUqxNatWy3JuifRu3dvjhw5wtatW5+4jedpyJAh9O/f37IdGRlJ9uzZbRiRiIiIiIiIAObeckt7wvkD5u389aDRZPDMYsuoRESSlOLkHJjnZ/vxxx9TLYg+ffqwYsUK/vjjD7Jly2Yp9/PzIzo6mhs3blj1nrt48SJ+fn6WOg+uqpqwmuv9dR5c4fXixYt4enri6uqKvb099vb2SdZJaONBzs7OODs7P9kFi4iIiIiISOqLizH3ltv8OcTHmHvL1R8PxVurt5yIpFnJmnPu/vnUHpxn7WnmXTMMgz59+rBkyRI2btxIrly5rPaXKVMGR0dHNmzYYCk7efIk4eHhVKpUCYBKlSpx+PBhLl26ZKmzbt06PD09KVy4sKXO/W0k1Elow8nJiTJlyljViY+PZ8OGDZY6IiIiIiIikoZdPArfvQEbx5oTc/nrQa9dGsYqImlesnrOpU+fnvPnz5MpUya8vb0xJfHFZhgGJpOJuLi4ZJ+8d+/ezJ8/n2XLluHh4WGZI87LywtXV1e8vLzo0qUL/fv3x8fHB09PT9577z0qVapExYoVAahbty6FCxemQ4cOjB8/ngsXLjB06FB69+5t6dn27rvvMm3aNAYNGsQ777zDxo0b+eWXX1i5cqUllv79+9OpUyfKli1L+fLlmTx5Mrdu3aJz587Jvh4RERERERF5zuJiYOtk89xy8THg4v2/3nJvKSknIi+EZCXnNm7caFlBddOmTal28hkzZgBQo0YNq/I5c+YQGBgIwKRJk7Czs6NFixbcu3ePgIAApk+fbqlrb2/PihUr6NmzJ5UqVcLNzY1OnToxevRoS51cuXKxcuVK3n//faZMmUK2bNn47rvvCAgIsNRp3bo1ly9fZvjw4Vy4cIGSJUuyZs2aRItEiIiIiIiISBpx4Qgs6wXnD5q389eHxpPBI+npiURE0iKTYRiGrYN4GURGRuLl5UVERASenp62DkdEREREROTlFRcDWyfBlvH/31uuwRdQrJV6y4lImpHcXNETLQhx48YNdu/ezaVLl4iPj7fa17FjxydpUkREREREROTxLhwxr8R64ZB5u0ADaDRJveVE5IWV4uTcb7/9Rrt27YiKisLT09Nq/jmTyaTknIiIiIiIiKS+uBj4cyL88YV6y4nISyXFybkBAwbwzjvv8Omnn5IuXbpnEZOIiIiIiIjI/7tw+H+95Q6btws0/F9vOc0RLiIvvhQn5/7991/69u2rxJyIiIiIiIg8W5becuMhPhZc00P9L6BYS/WWE5GXRoqTcwEBAezdu5fcuXM/i3hEREREREREEveWK9gIGk5UbzkReemkODnXsGFDPvjgA44dO0axYsVwdHS02v/mm2+mWnAiIiIiIiLyiomNhq0Jc8v9r7dcgy+haAv1lhORl5LJMAwjJQfY2dk9vDGTibi4uKcO6kWU3OVxRURERERE5CHOH4KlveDifb3lGk0C90y2jUtE5AkkN1eU4p5z8fHxTxWYiIiIiIiIiJXYaPhzAvz55f96y/mYV2JVbzkReQWkODknIiIiIiIikmruXIcfWsC/+8zb6i0nIq+YZCfn+vfvn2S5l5cX+fPnp3nz5jg7O6daYCIiIiIiIvKSuxsB85rDuf3g4g0NJ6i3nIi8cpKdnPvrr7+SLL9x4wZnzpxh2LBhbNy4kRw5cqRacCIiIiIiIvKSuhtp7jF3br95GGvgSshc2NZRiYg8dyleECIpkZGRtGvXDg8PD+bPn58acb1wtCCEiIiIiIhIMt2LMifm/tlp7jHX6TfIUtzWUYmIpKrk5ooevvRqCnh6ejJs2DC2bduWGs2JiIiIiIjIyyr6FsxvbU7MOXtBx6VKzInIKy1VknMAGTNm5Nq1a6nVnIiIiIiIiLxsYu7AT23g7FZw9oQOSyBrKVtHJSJiU6mWnNu5cyd58uRJreZERERERETkZRJzFxa0hdA/wMkd2i+CbGVsHZWIiM0le0GIQ4cOJVkeERHBvn37+PTTTxkxYkSqBSYiIiIiIiIvidh78EsHCNkIjumg3ULIXt7WUYmIpAnJTs6VLFkSk8lEUutHZMyYkf79+9OrV69UDU5ERERERERecLHRsDAQTv8ODq7Q9hfwr2zrqERE0oxkJ+dCQ0OTLPf09CR9+vSpFpCIiIiIiIi8JOJiYNE7cHIVOLjA2z9Brqq2jkpEJE1JdnLO39//WcYhIiIiIiIiL5O4WFjcDY7/BvZO0OZHyFPT1lGJiKQ5yVoQYufOnclu8Pbt2xw9evSJAxIREREREZEXXHwcLH0Xji4BO0do/QPkrW3rqERE0qRkJec6dOhAQEAACxcu5NatW0nWOXbsGB999BF58uRh3759qRqkiIiIiIiIvCDi42FZHzi8EOwc4K25kD/A1lGJiKRZyRrWeuzYMWbMmMHQoUNp27Yt+fPnJ2vWrLi4uHD9+nVOnDhBVFQUzZo14/fff6dYsWLPOm4RERERERFJa+Lj4be+cHA+mOyh5Wwo2NDWUYmIpGkmI6nlVx9h7969bN26lbNnz3Lnzh0yZsxIqVKlqFmzJj4+Ps8qzjQvMjISLy8vIiIi8PT0tHU4IiIiIiIiz5dhwMr+sHc2mOygxXdQtIWtoxIRsZnk5oqSvSBEgrJly1K2bNmnCk5EREREREReIoYBqweZE3OYoOk3SsyJiCRTsuacExEREREREUmSYcDaj2H3TMAETb6GEq1tHZWIyAtDyTkRERERERF5MoYB60fAzq/N242nQKl2to1JROQFo+SciIiIiIiIpJxhwMaxsG2KebvhBCjTybYxiYi8gJScExERERERkZTb8jn8+aX5ff3xUK6rbeMREXlBKTkn/8fefcdZUtX5/39V1c33dp7p6cmZnCVjQlhAdBVBVzChrOvKiondNSeWVdTdxbAGvj9dw6oY0BVdURBB1sBIGkmSJsfu6Z7ON99bVb8/qm7qMNM90923e/r9fFiPqjpVt/rcZpA77/s554iIiIiIiEzO7/4d7rvJO77ok3DW39e3PyIic9iEVmv94he/OOEHvutd7zrkzoiIiIiIiMgs98cvwL03escXfgLOva6u3RERmesM13Xdg920evXqmvOenh7S6TTNzc0ADAwMEIvFaG9vZ+vWrdPS0dluaGiIpqYmBgcHaWxsrHd3REREREREpt6GL8NdH/KOz/8IvOif69sfEZFZbKJZ0YSGtW7btq28ffKTn+SUU07h6aefpq+vj76+Pp5++mlOO+00brzxxil7AyIiIiIiIjKLPPD/VYK5F71fwZyIyBSZUOVctbVr1/LjH/+YU089tab9kUce4dWvfjXbtm2b0g7OFaqcExERERGRI9bD34BfvNc7fv71cMHHwDDq2ycRkVluSivnqnV2dlIsFke127bNvn37Jvs4ERERERERmc02/nclmDv3nQrmRESm2KTDuQsuuIC///u/Z+PGjeW2Rx55hGuvvZYLL7xwSjsnIiIiIiIidfTYD+Hn/qJ/Z10Lf3WjgjkRkSk26XDuG9/4Bh0dHZx++umEw2HC4TBnnnkmixYt4utf//p09FFERERERERm2tb/g5/9A+DCGX8Hl9ykYE5EZBoEJvuChQsX8stf/pLnnnuOZ555BoBjjjmGo446aso7JyIiIiIiInXQ8yz86I3gFOGEK+Cln1UwJyIyTSYdzpUcddRRCuRERERERESONMke+N5rIDsIy8+CV34FzEkPuhIRkQk6pHBu9+7d/PznP2fnzp3k8/maazfffPOUdExERERERERmWCEDP3gdDOyAllVw5a0QjNS7VyIiR7RJh3P33HMPr3jFK1izZg3PPPMMJ5xwAtu3b8d1XU477bTp6KOIiIiIiIhMN8eB26+F3Q9CpBle/2OIL6h3r0REjniTrk3+4Ac/yD/90z/xxBNPEIlE+MlPfsKuXbt40YtexGte85rp6KOIiIiIiIhMt9/+K/zlp2AG4bXfhQXr690jEZF5YdLh3NNPP82b3vQmAAKBAJlMhkQiwb/8y7/wmc98Zso7KCIiIiIiItNs43fg9//hHb/ii7D6BfXtj4jIPDLpcC4ej5fnmVu8eDFbtmwpX9u/f//U9UxERERERESm39b74Bfv8Y5f+D445XX17I2IyLwz6Tnnzj77bP7whz9w7LHHcumll/KP//iPPPHEE/zP//wPZ5999nT0UURERERERKZDz7PwwzeBU4QTXg3nf6jePRIRmXcmHc7dfPPNJJNJAG644QaSySQ//OEPWb9+vVZqFRERERERmSuS3fC9V0NuEJafDa/8MhhGvXslIjLvGK7ruvXuxJFgaGiIpqYmBgcHaWxsrHd3RERERERExlfIwLdeDnsehpbV8NZ7IN5W716JiBxRJpoVTXrOOREREREREZnDHAd++nYvmIs0w+tvUzAnIlJHExrW2tLSgjHB8ua+vr7D6pCIiIiIiIhMo3v/BZ66HcwgXPk9WLC+3j0SEZnXJhTOff7zny8f9/b28q//+q9cfPHFnHPOOQBs2LCBu+66i49+9KPT0kkRERERERGZAhv/G/7wOe/4Ff8Jq55f3/6IiMjk55y74oorOP/887nuuutq2r/0pS/xm9/8httvv30q+zdnaM45ERERERGZ1bb81lsAwinCi96vlVlFRKbZtM05d9ddd3HJJZeMar/kkkv4zW9+M9nHiYiIiIiIyHTrfgZ+dLUXzJ34GnjxB+vdIxER8U06nGtra+NnP/vZqPaf/exntLVpElEREREREZFZJdkNt74GcoOw4hx4xZdggnOKi4jI9JvQnHPVbrjhBt761rdy3333cdZZZwHwwAMPcOedd/K1r31tyjsoIiIiIiIih6iQge9fBQM7oWU1vPZ7EIzUu1ciIlJl0uHcm9/8Zo499li++MUv8j//8z8AHHvssfzhD38oh3UiIiIiIiJSZ44DP/172PMwRJrh9T+GuEY7iYjMNpNeEELGpgUhRERERERkVrn74/DHz4MZhDf9DFadV+8eiYjMKxPNiiZUOTc0NFR+yNDQ0AHvVTAlIiIiIiJSZ498ywvmAF75ZQVzIiKz2ITCuZaWFjo7O2lvb6e5uRljjMlDXdfFMAxs257yToqIiIiIiMgEbbkXfnG9d/yiD8DJr61vf0RE5IAmFM7de++9tLa2AvDb3/52WjskIiIiIiIih6j7afjR1eDacOLfwIs/UO8eiYjIQWjOuSmiOedERERERKSukt3wtQtgcCesOMebZy4QrnevRETmrYlmReZkH/zNb36T2267bVT7bbfdxre//e3JPk5EREREREQOVz4N37/SC+Za18KVtyqYExGZIyYdzt10000sWLBgVHt7ezuf+tSnpqRTIiIiIiIiMkGOAz/9e9jzCERb4PW3Qay13r0SEZEJmnQ4t3PnTlavXj2qfeXKlezcuXNKOiUiIiIiIiITdM8n4OmfgxXyKuba1ta7RyIiMgmTDufa29t5/PHHR7U/9thjtLW1TUmnREREREREZAIe/ib88Qve8Su+BCvPrW9/RERk0iYdzl111VW8613v4re//S22bWPbNvfeey/vfve7ufLKK6ejjyIiIiIiIjLS5nvgjn/0jl/8QTj5tfXtj4iIHJLAZF9w4403sn37di644AICAe/ljuPwpje9SXPOiYiIiIiIzIQt98JtbwbXhpNeCy96f717JCIih8hwXdc9lBc+99xzPPbYY0SjUU488URWrlw51X2bUya6PK6IiIiIiMgh2/MI/OYG2PZ/3vnK8+CNP9XKrCIis9BEs6JJV86VHHXUURx11FGH+nIRERERERGZqO5n4N4b4ZlfeOdmEE6/Bl7yYQVzIiJz3ITCueuvv54bb7yReDzO9ddff8B7b7755inpmIiIiIiIyLw3sBPu+zQ89n1wHcCAk6+CF38AWub36CURkSPFhMK5P//5zxQKBQA2btyIYRhj3jdeu4iIiIiIiExCsgd+/+/w8DfAznttx7wcXvIRaD+2vn0TEZEpdchzzkktzTknIiIiIiKHLTsI9/8nbPgKFFJe2+oXwgUfh2Wn17dvIiIyKdMy51yhUCAajfLoo49ywgknHHYnRUREREREBChk4MH/D/7wOcj0e21LTvVCubXn17dvIiIyrSYVzgWDQVasWIFt29PVHxERERERkfnDLsCfvwv/91kY3uu1LTjaG7567F+Dpg4SETniTXq11g9/+MN86EMf4jvf+Q6tra3T0ScREREREZEjm+PAX/4HfvtJ6NvqtTUt9xZ6OOlKsCb9VzUREZmjJv3/+F/60pfYvHkzS5YsYeXKlcTj8ZrrGzdunLLOiYiIiIiIHFFcFzbdDff+C3Q94bXFFsAL/wlOvwYC4fr2T0REZtykw7lXvvKVWpVVRERERERksnZsgHtugJ0bvPNwI5z7Tjj7Wgg31LdvIiJSN1qtdYpotVYRERERERlT1xNwz42w6S7vPBCBM/8Onn89xDRVkIjIkWqiWZE52QevWbOG3t7eUe0DAwOsWbNmso8TERERERE5MvVugR//LdzyfC+YMyw47Wp450a46F8VzImICHAIw1q3b98+5mqtuVyO3bt3T0mnRERERERE5qyhTvi/z8CfvwNO0Ws7/nI4/8OwYF19+yYiIrPOhMO5n//85+Xju+66i6ampvK5bdvcc889rF69emp7JyIiIiIiMhcUMrDp1/DEbfDcXWDnvfZ1F8IFH4PFJ9e3fyIiMmtNOJy77LLLADAMg6uvvrrmWjAYZNWqVfzHf/zHlHZORERERERk1rKLsP138MSP4en/hdxQ5drys+CCj8Oq8+rXPxERmRMmPOec4zg4jsOKFSvo7u4unzuOQy6X49lnn+XlL3/5pH747373O/76r/+aJUuWYBgGt99+e831N7/5zRiGUbNdcsklNff09fXx+te/nsbGRpqbm/nbv/1bkslkzT2PP/44L3jBC4hEIixfvpzPfvazo/py2223ccwxxxCJRDjxxBP55S9/Oan3IiIiIiIi84Drwq6H4Jfvg5uPhe+8Ch79nhfMNS6D894Nb/8DXHOXgjkREZmQSc85t23btin74alUipNPPplrrrmGyy+/fMx7LrnkEr75zW+Wz8PhcM3117/+9XR2dnL33XdTKBR4y1vewtve9jZuvfVWwFsZ46KLLuLCCy/klltu4YknnuCaa66hubmZt73tbQDcf//9XHXVVdx00028/OUv59Zbb+Wyyy5j48aNnHDCCVP2fkVEREREZI7qfsYbsvrkj6F/e6U92grHvwpOfI1XLWdOes09ERGZ5wzXdd3JvOBd73oX69at413veldN+5e+9CU2b97M5z//+UPriGHw05/+tDx8FrzKuYGBgVEVdSVPP/00xx13HA899BCnn346AHfeeSeXXnopu3fvZsmSJXz1q1/lwx/+MF1dXYRCIQA+8IEPcPvtt/PMM88A8NrXvpZUKsUvfvGL8rPPPvtsTjnlFG655ZYJ9X+iy+OKiIiIiMgcMbALnvyJN2x13xOV9mAcjnmZF8itPR+sYP36KCIis9ZEs6JJf63zk5/8hPPOG12efe655/LjH/94so87qPvuu4/29naOPvporr32Wnp7e8vXNmzYQHNzczmYA7jwwgsxTZMHHnigfM8LX/jCcjAHcPHFF/Pss8/S399fvufCCy+s+bkXX3wxGzZsmPL3IyIiIiIis1iqFx76L/jGS+HzJ8BvPu4Fc2YAjnopXPFf8M+b4IqvwVEXKZgTEZHDNulhrb29vTUrtZY0Njayf//+KelUySWXXMLll1/O6tWr2bJlCx/60Id46UtfyoYNG7Asi66uLtrb22teEwgEaG1tpaurC4Curq5Rq8guWrSofK2lpYWurq5yW/U9pWeMJZfLkcvlyudDQ0Pj3isiIiIiIrNYLgnP/sobtrrlHnCK/gUDVp4HJ74ajnslxFrr2k0RETkyTTqcW7duHXfeeSfXXXddTfuvfvUr1qxZM2UdA7jyyivLxyeeeCInnXQSa9eu5b777uOCCy6Y0p81WTfddBM33HBDXfsgIiIiIiKHqJiHLfd6gdyzv4RCunKt4yRvyOoJl0PTsvr1UURE5oVJh3PXX3891113HT09PbzkJS8B4J577uE//uM/Dnm+uYlas2YNCxYsYPPmzVxwwQV0dHTQ3d1dc0+xWKSvr4+Ojg4AOjo62LdvX809pfOD3VO6PpYPfvCDXH/99eXzoaEhli9ffuhvTkREREREppfjwM4NXiD31O2Q6a9ca1kNJ/0NnPBqWHhU3booIiLzz6TDuWuuuYZcLscnP/lJbrzxRgBWrVrFV7/6Vd70pjdNeQer7d69m97eXhYvXgzAOeecw8DAAI888gjPe97zALj33ntxHIezzjqrfM+HP/xhCoUCwaA3H8Tdd9/N0UcfTUtLS/mee+65h/e85z3ln3X33XdzzjnnjNuXcDg8auVYERERERGZpfZvgh+8HvY/W2lLLIITrvCGrS45DQyjfv0TEZF5a9KrtVbr6ekhGo2SSCQO6fXJZJLNmzcDcOqpp3LzzTdz/vnn09raSmtrKzfccANXXHEFHR0dbNmyhfe9730MDw/zxBNPlIOxl770pezbt49bbrmFQqHAW97yFk4//XRuvfVWAAYHBzn66KO56KKLeP/738+TTz7JNddcw+c+9zne9ra3AXD//ffzohe9iE9/+tO87GUv4wc/+AGf+tSn2LhxIyeccMKE3otWaxURERERmaW2/Q5++AbIDkK4EY57hTdsddULwLTq3TsRETlCTTQrOqRwrlgsct9997FlyxZe97rX0dDQwN69e2lsbJxUUHffffdx/vnnj2q/+uqr+epXv8pll13Gn//8ZwYGBliyZAkXXXQRN954Y83iDX19fVx33XX87//+L6ZpcsUVV/DFL36xph+PP/4473jHO3jooYdYsGAB73znO3n/+99f8zNvu+02PvKRj7B9+3bWr1/PZz/7WS699NIJvxeFcyIiIiIis9DG/4ZfvNdb5GHZmXDlrZBYWO9eiYjIPDBt4dyOHTu45JJL2LlzJ7lcjueee441a9bw7ne/m1wuxy233HLYnZ+LFM6JiIiIiMwijgO/+Tjc/0Xv/IRXwyu/DMFIffslIiLzxkSzInOyD373u9/N6aefTn9/P9FotNz+qle9invuuefQeisiIiIiIjJV8in40RsrwdyLPwhXfF3BnIiIzEqTXhDi97//Pffffz+hUKimfdWqVezZs2fKOiYiIiIiIjJpQ3vh+1dC52NgheGyr3gLPoiIiMxSkw7nHMfBtu1R7bt376ahoWFKOiUiIiIiIjJpex/1grnhTogt8OaXW3FWvXslIiJyQJMe1nrRRRfx+c9/vnxuGAbJZJKPf/zjk1pAQUREREREZMo8cwd886VeMLfwGPi7exTMiYjInDDpBSF2797NxRdfjOu6bNq0idNPP51NmzaxYMECfve739He3j5dfZ3VtCCEiIiIiEgduC7c/59w98cAF9a+BF7zLYg01btnIiIyz03baq0AxWKRH/zgBzz++OMkk0lOO+00Xv/619csEDHfKJwTEREREZlhdgHuuB42/rd3fvrfwks/C9akZ+8RERGZchPNig7pv1qBQIA3vOENh9w5ERERERGRw5Lphx9dDdv+DwwTLv4UnPV2MIx690xERGRSJhTO/fznP5/wA1/xilcccmdEREREREQOqm8rfO9voHcThBLw6m/AURfXu1ciIiKHZELh3GWXXTahhxmGMeZKriIiIiIiIlNix/3wg9dDpg8al8HrfggdJ9S7VyIiIodsQuGc4zjT3Q8REREREZEDe/T78PN3glOAJafBVd+Hho5690pEROSwaKZUERERERGZ3RwHfvtJ+P2/e+fHvRIuuwVCsfr2S0REZAqYE73x0ksvZXBwsHz+6U9/moGBgfJ5b28vxx133JR2TkRERERE5rlCBn78lkow9/zr4dXfUjAnIiJHjAmHc3fddRe5XK58/qlPfYq+vr7yebFY5Nlnn53a3omIiIiIyPw1vA++9TJ46nYwg/DKr8CFHwdzwn+NERERmfUmPKzVdd0DnouIiIiIiEyZrifh+1fC4C6ItsBrvwurnl/vXomIiEw5zTknIiIiIiKzy3O/9oay5pPQtg5e9yNoW1vvXomIiEyLCYdzhmFgGMaoNhERERERkSnhuvDA/4O7PgiuA6teAH/z3xBrrXfPREREps2khrW++c1vJhwOA5DNZnn7299OPB4HqJmPTkREREREZFLsItz5fnjo6975qW+El90MgVB9+yUiIjLNJhzOXX311TXnb3jDG0bd86Y3venweyQiIiIiIvNLdhBuewtsuQcw4K9ugHPfBRqpIyIi88CEw7lvfvOb09kPERERERGZj3qehR++AfY/B4EoXPE1OPav690rERGRGaMFIUREREREpD7+cjv87B3ewg8Ni+Gq78OSU+vdKxERkRmlcE5ERERERGaWXYTffBw2fMk7X/l8eM03IdFe336JiIjUgcI5ERERERGZOclub365HX/wzs99J1zwCbD0VxMREZmf9F9AERERERGZGTsfgNuuhuFOCCXglV+G4y+rd69ERETqSuGciIiIiIhML9eFB78Gd30QnCIsOBpe+11YeFS9eyYiIlJ35qG86Dvf+Q7nnXceS5YsYceOHQB8/vOf52c/+9mUdk5EREREROa4fAr+523wq3/2grnjXwV/d6+COREREd+kw7mvfvWrXH/99Vx66aUMDAxg2zYAzc3NfP7zn5/q/omIiIiIyFzVuwW+fiE88SMwLLj4U/Dqb0I4Ue+eiYiIzBqTDuf+8z//k6997Wt8+MMfxrKscvvpp5/OE088MaWdExERERGROeqZO+D/ezF0PwXxdrj6f+Gcd4Bh1LtnIiIis8qk55zbtm0bp5566qj2cDhMKpWakk6JiIiIiMgc5djw20/C7//DO19+NrzmW9C4uK7dEhERma0mXTm3evVqHn300VHtd955J8cee+xU9ElEREREROaiVC989/JKMHfWtfDmXyiYExEROYBJV85df/31vOMd7yCbzeK6Lg8++CDf//73uemmm/j6178+HX0UEREREZHZbvcj8KM3wdBuCMbgFf8JJ7663r0SERGZ9SYdzr31rW8lGo3ykY98hHQ6zete9zqWLFnCF77wBa688srp6KOIiIiIiMxWrguPfAt+9T6w89C6Fl77XVh0XL17JiIiMicYruu6h/ridDpNMpmkvb19Kvs0Jw0NDdHU1MTg4CCNjY317o6IiIiIyPQrZOCOf4JHv+udH/NyuOwrEGmqb79ERERmgYlmRZOunKsWi8WIxWKH8wgREREREZmL+rfDD98IXY+DYcIFH4Pz3qPVWEVERCZpQuHcqaeeijHB/8hu3LjxsDokIiIiIiKz3Ka74SdvhewAxBbAq78Ba15U716JiIjMSRMK5y677LLycTab5Stf+QrHHXcc55xzDgB/+tOf+Mtf/sI//MM/TEsnRURERERkFnAc+L/PeBsuLD0d/ubb0LSs3j0TERGZsyYUzn384x8vH7/1rW/lXe96FzfeeOOoe3bt2jW1vRMRERERkdkh3Qf/8zbYfLd3fsZb4eJPQSBc336JiIjMcZNeEKKpqYmHH36Y9evX17Rv2rSJ008/ncHBwSnt4FyhBSFERERE5IjV+Rj88A0wsBMCEXj55+GUq+rdKxERkVltolmROdkHR6NR/vjHP45q/+Mf/0gkEpns40REREREZDb783fhvy7ygrmWVfC3dyuYExERmUKTXq31Pe95D9deey0bN27kzDPPBOCBBx7gG9/4Bh/96EenvIMiIiIiIlIHAzvh1x+Fp273ztdfDJf/P4i21LVbIiIiR5pJh3Mf+MAHWLNmDV/4whf47ne/C8Cxxx7LN7/5Tf7mb/5myjsoIiIiIiIzKJ+CP3we7v8iFLNgmPDiD8IL/gnMSQ+8ERERkYOY9JxzMjbNOSciIiIic5rjwBO3wW8+AcN7vbZVL4BLboKOE+vaNRERkbloolnRpCvnRERERETkCLP7Ebjz/bD7Ie+8eSVc9K9w7F+DYdS3byIiIkc4hXMiIiIiIvPV0F74zQ3w+A+882AcXviPcPY7IKjF3kRERGaCwjkRERERkfmmkIENX4Lf3wyFtNd28uvggo9B4+L69k1ERGSeUTgnIiIiIjJfuC489TNvFdbBnV7bsjPhpZ+Gpc+rb99ERETmqcMK50prSRiah0JEREREZHbrfBzu/ADs+KN33rgULrwBTny15pUTERGpo0NaC/2///u/OfHEE4lGo0SjUU466SS+853vTHXfRERERETkcCV74Ofvgv/3Qi+YC0TgRR+A6x6Ck16jYE5ERKTOJl05d/PNN/PRj36U6667jvPOOw+AP/zhD7z97W9n//79vPe9753yToqIiIiIyCQV8/DALfC7f4PckNd2whVetVzz8vr2TURERMoMtzQ2dYJWr17NDTfcwJve9Kaa9m9/+9t84hOfYNu2bVPawbliaGiIpqYmBgcHaWxsrHd3RERERGS+cl147k6460PQt9VrW3wKXPJpWHlOXbsmIiIyn0w0K5p05VxnZyfnnnvuqPZzzz2Xzs7OyT5ORERERESmSvfTcOcHYetvvfN4O1z4cW8lVvOQZrQREZFD4OSKGEELw9TUAXJwkw7n1q1bx49+9CM+9KEP1bT/8Ic/ZP369VPWMRERERERmaB0H9x3Ezz0X+DaYIXg7H+AF/wjRDSqQ0RkuhUHsuS2DJLbOkhu2yB2XxYMMONBrEQQMxHCTASx4t6x1xbEKrUnghhBq95vY8a5ros9mKewZ5j8niRG0KTx/BX17taMm3Q4d8MNN/Da176W3/3ud+U55/74xz9yzz338KMf/WjKOygiIiIiIuOwi/DwN+C3n4TsgNd2zMvhohuhdU1duyYiciQrDuTIbR3wwritfhg3kgtOsoCTLADpgz7TCFmYDeMHeGY8iNUQwowHMaOBOVeVVw7idntBXH5PksKeJE6qUL7Hag4rnJuIK664ggceeIDPfe5z3H777QAce+yxPPjgg5x66qlT3T8RERERERnL5nu8eeV6nvHO24+HS26CNS+qb79ERI5ABw3jTAgtbSC8ponwmiZCyxtwiy52Mo+TKmAnCzjJPE6ycmz7wZ2dzIPt4uZt7F4bu3eMoG8k0/DDuiCB1ghWa5RAa6S8Wc1hjED9pjPwgrgchd3JcYO4MhOC7XGCSxOEliVwXRdjnq0kPukFIWRsWhBCRERERGZEug9+9X54wh+1Em2Fl3wYTnszWJP+7l1ERMZQHMx5QdyWAW+Y6sjAbGQYt6oRM3xo/x/sui5uzh4/wEt5AV6p3c0UD/5QA6ymsB/cRQi0lYK7KFZrBDMWmLIAbOwgbhgnNUY/TQgu8oO4pQlvvzh+xA7pnbYFIUq6u7vp7u7GcZya9pNOOulQHykiIiIiIgfy7J3wv++C5D4wTDjz7+HF74doS717JiIyp00kjAv6YVzkMMO4kQzDwIgEMCMBWBA96P1u0SlX49mDOYr9Wey+LEV/s/uyuAUHeyCHPZCDrYOjf2bYqgR31RV3rRECLZFxq+5c18UeyFHYM5EgziC4KFYO4kLLGgh2xDGCWqBopEn/SXrkkUe4+uqrefrppxlZdGcYBrZtT1nnREREREQEyAx4q7A+dqt33rYeXnULLDu9rt0SkSOH67jguuB4AQyOt7mlfdHFLTrljaLjtRUcXNsp7yk4tff61xjx+spzKu2YBmbIwghb3vxrYQsjZGKErTHardHt/r2GdfDwxy6FcVsHyW0doHiAMC68ponwykYvPJsFjICJ1RTGagrD0sSo667r4iQLlbCuN1MT3NlDedycTaEzRaEzNcYPAKsxXBPcuUWH/O5hCnuTBw/iliUILVUQNxmT/pN1zTXXcNRRR/Ff//VfLFq0aN6NAxYRERERmVGbfgM/fycM7wUMOPc6OP/DEDx4dYWIzB1uwcHJFnFyNm62iJMt4mZtnKztH5eu2ZX7cnY5PMMP11wHf19qHxm24Ydwrt+Od+1IEvBDvlKAVwrzQhZGwKCwJzk6jDMguGx2hnGTZRgGVkMIqyFEeOXooZRuwaHYXwnrKsGdF+K5eQd7MIc9mCO/bXTVnYK4qTfpP2lbt27lJz/5CevWrZuO/oiIiIiICEB2CH79Ydj439556xq47Kuw4uz69ktExuQWbOyUN8G/ky7iZKoCtlyxEqpl7XLQVgngimDP4oDM8Kq1jKAJlrc3AgaGNaLNMvxrlY2A4R2XX1fVVrMZuI6Lm3Nw8zZO3g8f87YXRPrnTt6pHJfa/XvKv8Oii1MsQvoAc7MZEFyaILymmfDauR3GTZYRNAm2xwi2x0Zdc10XJ1WoBHe9XnBnmEZlnjgFcVNu0n/yLrjgAh577DGFcyIiIiIi02XLb71qucFd3vlZ18IFH4PQ6L9Iicwlru3g5p0xgxdcKsMUq4cyhiywjBkftVUdtpVDt1TtcfW5m5+aKZ6MsIUZsTDCAW8f8fZmJIARsTDD/j4S8CrBLANMA8MATAMMA8M0wMRv965jGhgmYJSOvXtqrpeeUfM65syIObc4MthzRgV4bt4hsDBKeNX8CeMmwzAMrEQIKxGCFVrscqZM+k/i17/+da6++mqefPJJTjjhBILBYM31V7ziFVPWORERERGReSWXhLs/Bg//l3fevBIu+wqsen59+zVHObkiha40hc4khb0pCl0pnGzRCyUs098bI/amF2CUrpuGF37U3GeO8TqjEpJYpjfka0nCuzaHuba3CmN15VI5/MjbuLkRQVvNsTPqNRQPsTrMNGrnFAtZo84rwxjNEecWRtAsD2108/a4YZvtB26HHLZZBmY8iBUPjg7V/PNxQ7dS2DbH/8zUU6kKz4wFD36zyCwy6XBuw4YN/PGPf+RXv/rVqGtaEEJERERE5BBt+z387B0wsMM7P+OtcOENEB492bfUKq8e6E9uXuhMku9MjV5tcYaZsQDhdc2E1zUTWddCoDVS1/5MhOu4FPalvRUrtwyQ2zqIm5uGv+OZYIQCmH6QZoQt7+fnvcqmUcMUHRc3W8Se6X+kVWGbmQiOcRyqHCeCXhA4R6rMRGYL23bo25uie/sQhmFw3POX1LtLM27S4dw73/lO3vCGN/DRj36URYsWTUefRERERETmj3wKfnMDPPj/vPOm5fDKL8GaF9e1W7OVW3AodFeq4fJ+IOdmx55bymwMEVocJ7g4QXBxHDMR9IIe263aOyPOR+xtp7Jipe2C7Y4496/77W7eJr87iZMuknl8P5nH9wMQaIsQXt9CZF0z4bXNmNH6D6lzXZdib7YSxm0ZxEkVam8KGOWqrsrKmGbNKpmjqtiq26tW3DSC3vlEh6nWDIMdqypv5DxkpaGLBWfcKj8zaGL6AZsVD1Ydh8rHCttEpofjuPR3pejZMUz39iG6dw6zf1cSu+gA0LQwqnBuInp7e3nve9+rYE5ERERE5HDt2AA/+wfo2+qdP+/N8Fc3QkTz/ADYw/lR1XDFnrS3uuRIpuFNcL447m1LvEDOitdneJtrO+R3DZPdNEBu8wD5XUPexOq9naT+1AkGhJY1EF7fTGRdM6EVjd5E+TOgOJgjt7kSxtmDuZrrRtAktLqJyNomwmub6zo817BMjKg5K4JMEZkc13EZ7MnQvWOI7h3DdO8YomdXkuIY1bjhWICFKxpoX9WI67jzbnj3pP8f7vLLL+e3v/0ta9eunY7+iIiIiIgc+QoZuPdfYcOXARcalsAr/xPWXVjvnk0713HB9avOHPy9i5P0grh8VRjnDBfGfIYZCxDsiBNckqiEce2xGQu3JsKwTMKrmgivaoK/WomTLZLbOkh2Uz+5zQMUezLkdw2T3zXM8L27MEIm4dVN5cq6wKLYlFVs2alCTWVccX+m9gbLILSigchabwhuaFnDrPpdikyGYzsU8w6FvE0hZ1PM2xRyjr+3KRZsXAeMqoUuDMNbDMMwDG9lWgNvYQ3/X0HDNDAY+3r52L+v/Dxz5N7ANMc6r7TVnJsGZmlxjznAdV2Ge7N07ximZ+cQ+7YP07NzmHxmdFVzIGzRvqKBhSsbWLSykYUrG2haGJ3XVaqTDueOOuooPvjBD/KHP/yBE088cdSCEO9617umrHMiIiIiIkecXQ/B7ddC7ybv/JQ3wMWfhGhzXbtV4toOhe4Mhb1JCnuSFHszlSGeTu1+ZMBG9XXXxbW9a7hV1yezHoABgbZoJYBb7AVyVmNozv0lzowEiB7XRvS4NgCKAzlym/vLlXVOqkD22X6yz/YzCJgNIW/463pvvjqrMTThn+Vki+S2D5Wr4wqdqdobDAguTXhh3NpmQqsaMUPWFL5bkQNzXZdi3iGfLVLI2uSzRfLZ6jCteu8FbcWc7e/9oK3qeuneQt7GOdRFR2axUmBXCuvK56aBFTAJRQOEYwHCsSCRuLcf+zxAJB4kFAtgWYcXwKcGcjUVcd07hskmR3+hYgVNFixL0L6ykfZVDbSvaKS5I4Y5R0LHmWK4rjupP7mrV68e/2GGwdatWw+7U3PR0NAQTU1NDA4O0tioYQgiIiIiMkIhC/fdBPd/EVwHEh3wii/CURfXrUtO3qbQlfKDuBT5vUkK+1KHvqLmYTBCplcNt7iqIq4jPi9CI9dxKXSlyG0eILt5gPy2QdxC7djdwKKYH9a1EF7d5M3bVnp9wSa3Y7hcHZffPTxq6G9gUawcxoXXNGmYqEya67heIFYdpo3YV8I2vy1nk88UKVTv/WuTSyIOgQHBkEUgbBEMmQRCFsGwRSBkYhiG9/NdF9f1wkLvPVYf+3v/unf/wa7X3uc6rvedhP+lxVjn0/57GEcwbBH2g7uIH+SFq4K8SCxAOF4J+bLJQk0Ylx7Mj3qmaRq0LUvQvrKBdr8irnVJ/LCDwLlsolnRpMM5GZvCOREREREZ156NXrVczzPe+UmvhZd+BqItM9YFJ10gv9cP4vYmye9NUuzJjFnJZoQtgksShJbECS6KY4RMML3xW4Zp+JP547X5VRzVe/yqjtFt/t4ArKrnmXNn6NZMcAsOuR1D5cq6wt5k7T8nfxhqaGkDhb1JcjuHRgWqVlvED+OaCK9pxmqYeOWdzF+u4zLUm6V3T5K+vUl696bo3ZMi2Z+lkLMnV/k6EQaEwhbBSIBQpBSeVe9NL2Arh2xeWyBUuW/UecgL4KygOScqbN2qgND1q5Fdx8VxXL+t6ryqrXRuFx1y6SK5dJFsqkAuXSif51IFsumi15by9vns1Ky+bBjQuiTOwpWNtPtzxbUtjRMIHvlfqEzGRLMifV0iIiIiIjJdinn43Wfh9zeDa0N8Ibz883Dsy6ftR7quizOU96rg9vrVcHuS2AO5Me83E0FCSxNetdqSOKElCayWiMKyOjKCJpF13kIRTZdUzRm3eYDspn7s/hz5bUPktw2VX2M2hiqVcWubCLRE6vgOZLZzXZfMcMEP4VL07vGCuL7O1JiT9VczDAhFAwTDVmUfsQhFAgQjlaAtVArcIpV7a+4Le9tcCNCmk1Ge286AGci1HNshn7H9IM8L7LLl8K507gV7pfNcukggZJUr4tpXNrBgeQPBsIK4qTLpcO6aa6454PVvfOMbh9wZEREREZEjRudjcPs/wL4nvfMTroCX/hvE26bsR7iOS7EvW1UNl6KwJ4mTGnshBas14lXDLUn4lXGJSc1lJvVhxYPETlpI7KSFABR7M15FXWeSYEec8LpmAgvm92Tq1Qp5m2yyQDZZIJPM+/tCua1YdGoqkEZWI+G6OE5VJdOI+5wRr6ncV6lmwoVIIkisMVTZmsL+3juPN4VnJNzIZ4u1AdzeJL17UmPODwZgBgxaOuK0LY3TtiRB65I4TQujhGNBghGLwBypSJOxmZZJJGESSdRnJWsZ26TDuf7+/przQqHAk08+ycDAAC95yUumrGMiIiIiInOSXYDf/wf87t/AKUKsDV52Mxx/2WE91snZFPb5K5l2lVY0TeGOVeViQmBhjNCS2oo4zTN2ZAi0RUm0RevdjRlRLNhkk0WyqXxNwFY59ttTVeHbiPn66mW4L3vQe4JhqyawKwd4jZUAL9YUIpoIYh5k3i676DCwL10J4fz9cO84/TCgaUGUtqVeAFfaN7dHD/qzRGRqTfq/zj/96U9HtTmOw7XXXsvatWunpFMiIiIiInOO48Czv4T7Pg37nvDajv1reNnnILFwwo9xHRe7L0uhK0W+FMR1pbDH+wt2wCS4OF6uiAstSRDsiGFo3h+ZAtlUgb69SWzbxbWr5r2qmvNq1N4e3eYdV82dZbs4rrcvtdVWvHn7wkGGWI7HtAwiiSDRRJBIIkgkHioflxYEMAxvbkTDNDD9uRDLK2GWrhn+NbNybvj3mmbtM6pfB5BNFkgP5UkP5v19jvRQnpR/XMw7FHI2gz0ZBnsyB35DBkQTQWKNYeLlIC+EFbQY6ErRuzfFQFfaq/wbQ6wpRNuSOK1LE7QtSdC2NE7L4jjBebDgishcMGULQjz77LO8+MUvprOzcyoeN+doQQgRERGRecouwpM/gT/cXFnwIdoCl/67N5T1AMO/nHSBQle6HMAVOlMU9qVw82NX/pgNofIqpsEOrzIusDCGYWmImUydof0Ztj22n22P97B302B5Vcp6McyqoC3uh22JIFH/2AvdQjVh3FyYyyyfLVaCu6E8KT+8qwR6OdKDeTLD+Qmv6BmKWLT64Vtp37YkoSGMInUy4wtCbNmyhWKxOFWPExERERGZ3QpZePR78McvwMAOry3cCGe8Fc55B8QXlG91bZdib4ZCZ5JCZ7ocxNmDYy/SQMAkuCjmhXBVYZyV0PxwM81xXIp5G7vgUPD3xbxDMW97+8KIfd7BLto0tcdYsr6ZeFO43m/hoFzXZf/uJNse7WHrY/vp3Z2sud7QFiEYtjAtrzKsZm9Sriyr2dfcM+Ka/5rScwzLaw8ErdpqN/84FA3M+qDtUHgLJgRoXhQ74H2O45JNFirhXVVwV8jZNC+KlYelJlrCR+TvSuRIN+lw7vrrr685d12Xzs5O7rjjDq6++uop65iIiIiIyKyUG4aHvwEbvgzJfV5bbAHu2f+Ae9JbcIhR7MxQ6NxTqYjbl4Li2KUvVnO4EsD5+0BbVNVwh6mQt8mMqEJKDeXJZ4oUC164ZucdCnkHu2DX7vM2RT+Mc8b55zZRTe1RlqxvZun6Zhavb6ZxlswV59gOezcPsu3RHrY9tr9mfjTDgMXrmll98gJWn7yQpoWzo8/zlWka5TnoROTINOlhreeff37NuWmaLFy4kJe85CVcc801BALzc5JZDWsVERERmZvcooOTs3GzRX9v4+SKuDm79jyZwtn9FG7PThw7iOPGcM1GnOACXCc87lDUEiNk1lbCLY4TXBTXIg2TYBcdMsOVYYA183kN+dVE/nEhe2hzlR2IFTAJhEwCQZNAyPKOQ1bl3N8blsH+XcPs352EEX/bSrSGWbK+mSXrmll6VAtN7TO3ymo+W2TX031se3Q/25/YTy5dGfkUCJosP66V1ScvZNVJbURVpSkictgmmhVN2Zxz853COREREZHZx3Vdivsz5LcPkds+RLEvi5urDeHGq2g7ZKaB1RImNCKIs1oiGKaq4Uayiw7ZVIHMcMGvdPMq3ErBWzmMG8yTTRUm9WwraJYnz482eCthhqOB0aHamCFb1bWg1zbZf365dIHOLYPs3TTA3k0DdO8YHjV/W7QxxJJ1zV513VHNtC6OT+mfk/RQnu2P72fbYz3serofu1gJkSPxIKtOXsDqkxaw/LhWLQ4gIjLFpi2cy2QyuK5LLOaNi9+xYwc//elPOe6447jooosOr9dzmMI5ERERkfpzbYfC3hS57YPktg+R3z6EM8FAxwiZGOEAZsTCCFuYZh4juQ1z6DkMN4lJGqOxCXP98zFXnYoRCXr3RQKYYQsjYmGGAxAw5uWcT67rUsjaZFMFb0sWRhwXa8/965NdjdM0DaKNldUqYw1Vx43h8vC/WGOIYGR2LQqQzxbZt22oHNbt2zZUE5YBhGMBFleFdQuWJTAtc1I/Z2Bfmq2P9bD9sf10bh2sqd5rXBBh9SkLWXPyAjrWNE362SIiMnHTFs5ddNFFXH755bz97W9nYGCAo48+mlAoxP79+7n55pu59tprD7vzc5HCOREREZGZ5+SK5HcO+0HcIPmdw7iFEcNLAwah5Q2EVzUR7Ih74duIQM3whyIC0PUk/OFz8Jf/Add/1srz4AXXw9oLDrj66pHEdVxSgzmGe7NkqoK2XFXYlknmy6FbLlXAsQ+tCtEwIJIIVgVr4UoAVw7evC0SCx4xFYjFgk339mH2bupn76YBOrcOURwRVgbDFovXNrHkKG8obPvKRqxgbaDmOi7dO4bZ+lgP2x7tob8rXXN94YoG1pzizR/XuiQ+qwJLEZEj2bSt1rpx40Y+97nPAfDjH/+Yjo4O/vznP/OTn/yEj33sY/M2nBMRERGR6WcP58ltHywPUy3sHT2nlxkLEFrZSHhVI6FVTYSWJjACE6gO2vUg/P4/4Lk7K23rL4LnXw8rz5naNzJLOLbDcF+Wwe4Mgz2129D+DPbIoHMCrKBJJB70tkT1PlDbVnVPOBo4YgK3yQgELW/+ufXNANi2w/6dSfZs6qdz0wB7Nw+SzxTZ+VQfO5/qA7zfb8fqRhav94bA7nlugG2P9ZAezJefa5oGS45qZs0pC1l10gIaWiP1eHsiIjJBkw7n0uk0DQ0NAPz617/m8ssvxzRNzj77bHbs2DHlHRQRERGRmeM6LoXOFLltg+S2DVLoTGGGLMxEECsRxEyEvON40G8Lla8Zwamdr6pmvrhtg+R2DGH3ZkfdZ7WECa9qIrTKC+QCC2MTD3pcF7b+Fn5/M2z/vd9owPGXeaHc4pOm7P3USzFvM7Q/y2BPelQAN9ybHTUHWjXDNGhoDRNJhPwgLVAO1aKJIOGRYVsiqHnLDoNlmSxa3cii1Y1w0Uocx6Vvb5I9zw34Yd0AmeECe54bYM9zAzWvDYYtVhzfxppTFrDyhDbCsWB93oSIiEzapMO5devWcfvtt/OqV72Ku+66i/e+970AdHd3aziniIiIyBzj2g75PUny2wbJbRsit30Qd8QqlxOdEcwYEeJZiSBmOcQb0TbG0MSa+eK2DZHfMYiTKo74IRDsiPtBnBfIBZrCk3/jjgPP3uFVyu39s9dmBuHkK+G898CCdZN/Zh3lM8Wq0M0P4bq96rdkf+6Ar7WCJo0LojQtjNLUHqVpgb9fGCXRGsHSnGR1Y5oGC5Y1sGBZAye/ZDmu6zKwL83eTV4419+Von1VI2tOXsiyo1tGDXcVEZG5YdLh3Mc+9jFe97rX8d73vpcLLriAc87xSvx//etfc+qpp07qWb/73e/4t3/7Nx555BE6Ozv56U9/ymWXXVa+7rouH//4x/na177GwMAA5513Hl/96ldZv359+Z6+vj7e+c538r//+7+YpskVV1zBF77wBRKJRPmexx9/nHe84x089NBDLFy4kHe+8528733vq+nLbbfdxkc/+lG2b9/O+vXr+cxnPsOll1462V+PiIiIyKzmFhzyu4a9SrTtg+R3DOHma4cuGmHLGxK6uonQ8gawXexkHidZwE4VcJIFnGQeO+kd28k82C5u3sbus7H7Rle3jWLghXTxIFZDCNd2Kew+8Hxx4VWNhFY2YkYm/RG2wi7AEz/25pTb/6z/M6LwvDfDuddB07JDf/Y0KuRshvuyJPuyDPdlGe719qXhp5nhAy96EYpYNLXHvBDOD95KW7wpPC+HlM5FhmHQ0hGnpSPO8S9YWu/uiIjIFJn0J5tXv/rVPP/5z6ezs5OTTz653H7BBRfwqle9alLPSqVSnHzyyVxzzTVcfvnlo65/9rOf5Ytf/CLf/va3Wb16NR/96Ee5+OKLeeqpp4hEvHkTXv/619PZ2cndd99NoVDgLW95C29729u49dZbAW/yvYsuuogLL7yQW265hSeeeIJrrrmG5uZm3va2twFw//33c9VVV3HTTTfx8pe/nFtvvZXLLruMjRs3csIJJ0z2VyQiIiIyazh5m/yOofIw1fyuYSjWDmM0YwFCq5oIr24ivKaJ4OL4pMIa13Vxc7Yf1tWGeOVQL1nASXnHTroILn7IV6C4rzJ5/SHPF3cw2UF49Puw4cswuNNrCzfBmX8HZ18L8QWH/zMOkeu6ZJOFmtDNC+Jy5bbsBFacjTYE/cAtRmNV+NbUHiUSD2oRABERkVlq0qu1ThfDMGoq51zXZcmSJfzjP/4j//RP/wTA4OAgixYt4lvf+hZXXnklTz/9NMcddxwPPfQQp59+OgB33nknl156Kbt372bJkiV89atf5cMf/jBdXV2EQiEAPvCBD3D77bfzzDPPAPDa176WVCrFL37xi3J/zj77bE455RRuueWWCfVfq7WKiIjIbOBki+T8Odry2wbJ707CiDnFzIagF8T5W6B9EnO0TQHXdnBSRS+480M813YJLU9Mbr64idj7Z3jov+DJn0DBDwHjC+Hsf4Az/hYiTVP3s8Zh2w6p/lxV6FYdwuVI9mUpTmDhhVDEoqEtQqI1QoO/lYejLowSih5GRaGIiIhMuWlbrTWVSvHpT3+ae+65h+7ubhyn9oPE1q1bJ9/bMWzbto2uri4uvPDCcltTUxNnnXUWGzZs4Morr2TDhg00NzeXgzmACy+8ENM0eeCBB3jVq17Fhg0beOELX1gO5gAuvvhiPvOZz9Df309LSwsbNmzg+uuvr/n5F198Mbfffvu4/cvlcuRylfk7hoaGpuBdi4iIiEyOnSr488VVFnAYuXqp1RwuB3GhNU0E2iJ1raIyLBOrMYTVGDr4zYcin/bCuIe/AXs3VtoXHusFcqe+AYLRKftxjuOS7M8y1JPxFl7Y7y20MNybJdmfJTWQYyJfh8eaQuXQraE1MiKIC2uCfxERkSPUpMO5t771rfzf//0fb3zjG1m8ePG0fbDr6uoCYNGiRTXtixYtKl/r6uqivb295nogEKC1tbXmntWrV496RulaS0sLXV1dB/w5Y7npppu44YYbDuGdiYiIiEye67rYg3mK3WkKPWmK+9LkdgzVDAktCSyIegsm+MNUAy2ROvS4Dnqe9QK5R78PuUGvzQrBca+E06+BFefAIX52zWeLDO3PMrQ/U57nbagnUw7iHPvA6ZsZMGho8QK3htba0K2hLUKiOaLJ/EVEROapSYdzv/rVr7jjjjs477zzpqM/c8YHP/jBmmq7oaEhli9fXsceiYiIyJHALToUezMUutMUuzMUe9IUerz9yIUbSgKLYlXDVBuxGg9h9dK5qpiHZ/4XHv4mbP99pb15pRfInfqGCc0n57ou6aF8OXirDeCyZIbyB3y9aRk0LojSuMAbatrYFq0K4sLEGkJadEFERETGNOlwrqWlhdbW1unoS42Ojg4A9u3bx+LFi8vt+/bt45RTTinf093dXfO6YrFIX19f+fUdHR3s27ev5p7S+cHuKV0fSzgcJhyeRx98RUREZEo56YIXunVXwrdid5piX3bUsNQy0yCwIEJgYYzgwhihZQlCqxqxEtM0PHQ2698Bj3wL/vwdSPV4bYYJR73UC+XWvgTM2kq0Qt4mWbXC6VCPNwS1FMIdbN63cDxA04IojQuj5bneSvt4cxhT4ZuIiIgcgkmHczfeeCMf+9jH+Pa3v00sFpuOPgGwevVqOjo6uOeee8ph3NDQEA888ADXXnstAOeccw4DAwM88sgjPO95zwPg3nvvxXEczjrrrPI9H/7whykUCgSD3jwdd999N0cffTQtLS3le+655x7e8573lH/+3XffzTnnnDNt709ERESOfK7jYg/magK4QneaYk8GJzn+6ptG2CLQHiO4MOrvYwTaowRaIxjWPB766Niw6W5v6OqmX+O6Ljk3TiZyMpm1ryG95ELSxQYyT+dJP/gcmaE8meE86aE86eECxZx9wMcbBiRaIzWhW2Uf0ZxvIiIiMi0mvVrrqaeeypYtW3Bdl1WrVpUDr5KNGzeO88rRkskkmzdvLj/35ptv5vzzz6e1tZUVK1bwmc98hk9/+tN8+9vfZvXq1Xz0ox/l8ccf56mnniIS8eZOeelLX8q+ffu45ZZbKBQKvOUtb+H000/n1ltvBbwVXo8++mguuugi3v/+9/Pkk09yzTXX8LnPfY63ve1tANx///286EUv4tOf/jQve9nL+MEPfsCnPvUpNm7cyAknnDCh96LVWkVEROYv13Ep9mYo7ktT2OcHcN1pivszuAeoxrKaQl4VXHuMwMJo+dhsCNZ1wYZ6chyXbLJQCdWG8mT295LZ8hjp3dtJZ4NknCYyTjNptxnHndx3zcGwRePCaLkCrmlBpFwJ19AWwZrP4aeIiIhMqWlbrfWyyy47nH7VePjhhzn//PPL56U53K6++mq+9a1v8b73vY9UKsXb3vY2BgYGeP7zn8+dd95ZDuYAvve973HddddxwQUXYJomV1xxBV/84hfL15uamvj1r3/NO97xDp73vOexYMECPvaxj5WDOYBzzz2XW2+9lY985CN86EMfYv369dx+++0TDuZERERkfnAdF3sgR6Er5QVwXSkvjOtJQ3Gc7zstg0BbtFwFV66IWxjFDE/6o9ic5bouuXSR1ECO5ECOVH+OZH/WO/a39FCebLIwzsqmHf42WihiEW0MEWsMEWsIEW0Ilc+jDUGvzT8Phq15G3yKiIjI7DTpyjkZmyrnREREjhyu62IP5b1KuFIAty9FsXv8RRmMoOkFb4v8AK5UDTcPhqK6jksmWfCCt/4syf5cOXRL9ufK7cVxfndjPJGIlSJm9BE1B4iZA0Qbo8RWH0t07cnEWuJEGyrhWyBoTev7ExERETkU01Y5V/LII4/w9NNPA3D88cdz6qmnHuqjREREROrCdV2cZKESvpWGpe5L4WbHmZ/MMrw54BZ5QVxwUZzgohhWa+SIXI3TsR3SQ3kvcCsFbQM5Un7VW6nNsSf2fW8kHiTeEibREibR7O3jzWHihZ3EdvyM6LafEHV6MA0HQgk46W+8BR46TpzmdyoiIiJSH5MO57q7u7nyyiu57777aG5uBmBgYIDzzz+fH/zgByxcuHCq+ygiIiJyWNyig50sYPdnKezzK+G60hS7Uzip4tgvMiGwIFoO3wJ+EBdoi2JYR14IV5IeytO1ZZC9mwfo3DzA/l1JHGcCwZsBscaQH7hFvACu2QveEn4YF28KEwhVVbn1PAd/+SH8+afQ80ylfdHxcMY1cNJrIdww9W9SREREZBaZdDj3zne+k+HhYf7yl79w7LHHAvDUU09x9dVX8653vYvvf//7U95JERERkZFc28FJFbCHC9jJPM5wHjtZGLHPYw8XcDPjBHAABgRaIwT8EC64KEawI05gQRQjcIQPR3VdBnsydG4eoHPzIJ1bBhnYlx51n2ka5ZAt3hwuB2+Jlki5LdYUmthiCvs3w19+6m3df6m0W2E4/jI4/W9h+Zne0qkiIiIi88Ck55xramriN7/5DWeccUZN+4MPPshFF13EwMDAVPZvztCccyIiIofPdVw/cMvjJEv7fCWAq2obt+JtPKaB1RTyqt8WeXPCBTvi3sIMofkxZ5ljO+zfnfSCuM0D7N0ySGYoP+q+1iVxlqxrZvG6JjrWNNFwuEN2+7ZWArmuJyrtZgDWvgSOvxyOfilEmw/9Z4iIiIjMMtM255zjOASDwVHtwWAQx5noJL8iIiIyX7lFh2Jvxp/bLU2xO01xf8YL3VIFmMzXhiaY8RBWIojZ4O2thhBmIoTVUNtmRAPzbpXOQs5m37ZB9vphXNe2IYq52rn0zIDBolWNLF5bCeMi8dGf9Satf0clkOt8tNJuWLDmxXDC5XD0pRBrPfyfJSIiIjKHTTqce8lLXsK73/1uvv/977NkyRIA9uzZw3vf+14uuOCCKe+giIiIzE1u0aG4P0Oh2w/h9qUodKcp7s/CgeYwM8CMB7ESIcyGkfvqAC6IGQsekYswHKr0UJ7OLQPlyrieXUncEb/rcCxAx9omFq9tYvG6ZtpXNkzdaqcDu+Cp271Abs8jlXbDhNUvhONfBcf8NcTbpubniYiIiBwBJh3OfelLX+IVr3gFq1atYvny5QDs2rWLE044ge9+97tT3kERERGZ3cohXGnF01IY15uBcYrqjbDlLbLQ7s3xFlgYw2oMeaFbLHhEL7gwVSY6X1yiNczitc0sWeeFca2L41MbaA7ugad+5gVyux+stBsmrDzPC+SOfQUktGiYiIiIyFgmHc4tX76cjRs38pvf/IZnnvFW1Tr22GO58MILp7xzIiIiMntUQriUXwmX9irhJhzCVVY9tRpD826I6UQVcjaZ4TzpoXzVvuAdD5faCqQHc+TSI+bdM6BtSbw8RHXxumYaWiNT38nhrkogt3NDbQdWnlsJ5BoWTf3PFhERETnCTHpBCBmbFoQQEZEjhVtwKOzPlIehlueFO1AIF7G8BRYWxSvVcArhAG+Ri2yq4AdrBTJDfshWCt/84K0UxBXzE5/Dd9rmixtLstsP5G6HHX+kZnLA5Wd7gdxxr4TGxdPz80VERETmmClfEOLee+/luuuu409/+tOoBw4ODnLuuedyyy238IIXvODQey0iIiIzxi04FHrS5WGoNSHcOF/dGRGrUgHnh3DB9hjmPAzh8tki6cE86aEcqYE8qcEc6UF/71e7pYfzZIfzTPar0EDQJNoYItoQItYQrDoOEW0MevuGEE3t0ambL24s6b7KHHLb/wBuVXC47Aw/kLsMmpZOXx9EREREjnATDuc+//nP83d/93djJn1NTU38/d//PTfffLPCORERkVnGLdgUujOVEK7bW5yh2Jc9QAgX8IK36hBuUQyz4cgO4VzXJZ+1SQ/mSA3mSQ34gduQvx/wgrfUYI5C1j74A6uE44FyqBYrhW2NQaI1bd55MGzV7/fs2LDlt/Dod+GZO8DOV64tOc0L5I6/DJpX1Kd/IiIiIkeYCYdzjz32GJ/5zGfGvX7RRRfx7//+71PSKREREZk8J29T7MnULMpQ6E5jHyiEi44RwrXHMRuCR0wI5zouhbxNIWd7w0sH85XwraraLeW3T2ZYaSBsEW8KEW8KE6veN4Yq1W6NISKJIJZlTuO7nAL7N8Gj34PHfgDDnZX29uPhpNd4FXKtq+vWPREREZEj1YTDuX379hEMjj+HSSAQoKenZ0o6JSIiIuNzssXy6qg1IVz/+CGcGQvUDEMN+ENTzcTsCuFc18UuOhRyNoWsF6gVcjb5bLGmrXxe02ZTyI24L2dTzE2uwg0gFLGIN3tBW6wxTLw5TLwpVA7gSiFcKDLptbVml+wQ/OV/4M/fq11pNdoCJ74GTnk9LD4ZZtGfEREREZEjzYQ/US5dupQnn3ySdevWjXn98ccfZ/FiTQAsIiIyFdyCQ7Ev41XC7c9QrNqcZGHc15mxAIFF/sqo7d6iDMH22RXCZZMF+jqT9O1N0deZpq8zyWBPxgvUsjaOMz1rVRkGhKIBL3RrHKParSlMvDlErClMMDSN87jVm+PA9t/Bo7fCUz+HYsZrN0xYd6EXyB39UgiE69tPERERkXliwuHcpZdeykc/+lEuueQSIpFIzbVMJsPHP/5xXv7yl095B0VERI5UruNi92e9KrgRAZw9kBu3Cg7AbAgSWBAbNSTVSoRm7g0cRDZV8AM4f/OPM0P5g78Yb1GEYMQiGLYIhgOESsflfYBg2Kq0+/cFIxah8n2B8msCQXPWBJR10b/dC+Qe/T4M7qy0LzjKC+ROvhIaOurWPREREZH5ynDdia0ftm/fPk477TQsy+K6667j6KOPBuCZZ57hy1/+MrZts3HjRhYtWjStHZ6tJro8roiIzC+u6+IMFyjuT1Pcn60K4dIUe7Ngj/+fYSNsEVgYJbAgSnCBty9t5iwaTplNFejrTNFfFcD17U2RPkAI19AaoXVJnJbFcVoXx2npiBGOBcrhWjBsYZrzOEibKvkUPPUzb9jqjj9U2sNNcMLlcOobYOnzNGxVREREZBpMNCua8Cf7RYsWcf/993PttdfywQ9+kFKmZxgGF198MV/+8pfnbTAnIiLiui52b5b83qQ3F1wphOvJ4OYPMOdZwCDQNiKA8wM5Mz57hqIC5NIFbxjq3mRNJVx6cPwQLtEaptUP4FqXxGldnKBlcWzuz9U2m7ku7NzgBXJP3Q75pH/BgDUv9qrkjn05BKN17KSIiIiIlEzqk/HKlSv55S9/SX9/P5s3b8Z1XdavX09LS8t09U9ERGaIbTvYeYdiwaGYtynmHeyiQyQRJN4cVhVTFddxKfZmKOxJemHcbm/vZscJ4QywWiKVAM4P3wJtUazmMMYs+t3aBYeh3gyDPRmG9mcZ7EmXK+JSBwrhWrwQrmVJVRDXEScUVQg3YwZ3w2Pf94au9m2ttLesrgxbbV5ev/6JiIiIyJgO6RNzS0sLZ5xxxlT3RUREDsIuOqQGc6T6c+TSRQp5G7tQG6gVCzbFQiloK7V518e7t5h3cA8wCb9pGTS0RmhcGKWxLULjgqi/eceR+Pirec91ruN6c8LtSZL3t8LeJO5YK4AGDIIdcW9bGKtUwbVGMALmzHd+DK7rkk0VGOrJMrg/7e8zDPVkGNqfIXmQue7izWG/Ai5e2S9WCFc3hQw8cwf8+buw9T7K//CCcTj+VXDq62HFORq2KiIiIjKL6ZO0iMgsUSzYpAbyJPuzJPtzpAZyJPtzJPuz5eP0cP6AwclUCQRNrJCJFTDJDhdwbJfBHq+aaizhWICGtghNC6I0LIjStKAS4DW0RrCCsyOYOhjXcSn2pL0ArhzEpcYelhowCS2OE1yaILQ0QXBpguCiGIZV//dq2w7Jvmy5+m2oJ+MFcH4Ilx+vws8XCFs0lcLXhVFaO0pzw8UIx47cIHZOcF3o3wa7HvLmkPvLzyA3WLm+8vleIHfsKyCcqF8/RURERGTCFM6JiMyAQt4m5QdtST9oS/Xn/GMvfMsMFyb0LDNgkGgOE4kHCYQsAiGTQNDCCprlY29vEgj57f5x+bofvgXL1yuvsUasaOk4LqmBnFdZ1Vsa6phhuDfD4P4smaE8uXSRXDrJ/l3J0R02INEcrqm0q668izWG6jKvmmuPFcQlcQvO6LcQNAmWg7gGL4hrj9YtiLOLDvlMkWR/zg/gMjXVb8N9uQNWQoJXAde4wAtUGxd6/zya/H20YXbNdTev5dOwdyPsehB2P+RtqZ7ae5pWwClXwclXQevq+vRTRERERA6ZwjkRkcNUyNsk+7LlKrekH7p5YZzXlksXJ/SsQNAk3hIm0RIm0RzxjpvDJFoj3r4lTCQxs8GJaXpDWhtaIyxl9ByjhZzNUG+G4f3ZSnXW/qy3781SzNn+7yHH3k2jnx8ImiRaIwTDFlbAxAoaWAELK2BgBb3qvcpm+PfUtpkBP1gstZkGJi6m42+2t5Ep4nSnsbtSFPeloThGEBcyCS6uVMOFliUILIhhWIf/O3ddl0LOppC1yWWK5Etb1iafKVbasqVr3n2FbNW1jI09Rr9HsoKmF7j51W/V4VtjW4RAyDrs9yNTzHVhYIdXFbf7QS+Q2/ckOCP+/8MMwuKTYfmZcNTFsOqFYNa/YlNEREREDo3CORGRAygWKsFSqj/LcFXgluybZPAWtmhoCRP3Q7ZES4RE+dw7DscCc65iKRi2aFuSoG3J6CF0ruuSGS74QV2GoZ6sX33nHSf7sxQLDgP70gAEDAj6+4Bh+HsIGhCgcl66HjTA9a85BpgGYHgribuA7W/jKbouA7bLoO0y6MIwBpm8i7l1CHP7MKZlYlpG1TbOuVl7zXXcqrDNroRtWfugFW2TEW0M1YZvfhVc04KoV5E4ixaakDEUMrD30UoQt+tBSHWPvq9hMSw7wwvjlp3pBXPByIx3V0RERESmh8I5EZm3bNupqW5L9ue8Criqud4mOtQ0GLFItES88K0qeEs0V85DEWvOBW+Hw7UdnFSBQLJAc9GhIWCyuCGAY0SwIxZOSxh7OEpxOI+bLo5ZxXa4bMB2oYhLwYW84zJYrARyyan/kRNimAahqEUoEiAUDRCOevtQxPL2pbaq89K9oahFOBogGAloBd25xHW91VR3PeANTd31IHQ9Ac6I/48xA9BxkhfElcK4pmVa0EFERETkCKZwTkSOWI7jepPid2cY6E4z2J1huD9bDuDSQxNbXKE07DLRUlvxVt63RgjPg5UqXcfFyRRxUgWcZB47WcBJFcr7kW1uZmIVhaNYBmbEwggHMMMWRtiq7COBqnP/esQa3VY6H2OFVNd1cRwXx/Y213axbad87tQcl+4d77pT8yzHf5ZpGlWBmlUVtnkBWyBkzqugdl4qZKHzsUpV3O6HYLhz9H2JRbVVcUtOgWB0xrsrIiIiIvVz5P9tUkSOaKVhkwPdaQb2pRnsTjOwrxLGHWxurtLiComWCInWcLn6rXzeHCEcn3tDTSeiNmwrYKf8kM3fyufJAnYqj5MqwGQrzUww40GseAgzEcRMBLHiQcxEyN9X2oxIYNxAbSoZhoFlGViack2mSmYA9v3F356Arie9ueLsfO19hgUdJ1aCuOVnQPNKVcWJiIiIzHMK50RkTshni14F3L50OYjzjjPkD1ChZVoGTQujNC+K0bQwSkNbpKby7UhaldItOjjpqkq2kSHbiGMnXZxQ5eBIRjSAlQj6oVspYAtV2vxzMx7EjAY075kcORwH+rd5w1H3PemFcV1PwuDOse+PLYDlZ3kh3LIzYcmpEIrNbJ9FREREZNZTOCcis4ZddBja7wdwfvVbKYxLD+bHf6EBDa0RmhfFaG6P0bwoSlO7d9zQFjni5uUq9KRJP9JNYV+qJnRzswda+mB8RjTghWzxqsCttCUqAZyVCGLGgtNe2SYyK+SG/fCtKojb9xQUUmPf37QcFh0Pi06AjhO8RRtaVqsqTkREREQOSuGciEwLu+h4q1Wm/S1TIJcuVtr8fT5dIJsuMtiTYXh/BvcAlVzRhmBVAOftmxZFaVoYJRA8sscougWb9BP7ST3URX7b0Pg3Gt4wUjNWVcU2RuhWbo8FMCyFbTKPOQ4M7PACuNJw1H1PQv/2se8PRKD9WC+EKwVxi46HaMuMdltEREREjhwK50RkXPlskcxwvhym5UuhWsoL28rn/rWsH7blMkWK+UNbBjMYtvzgLUpTTRAXJRwLTvE7nP3ye5OkHuoi/efuSmWcAZGjW4kc04JVGj5a2jSMVGR8haxfCVc1L9y+pyA/PPb9DUv88M0P4DpOhNa1YOnjk4iIiIhMHX26FBEKOZv+rhR9e1P07vX2fZ1Jkn25w352KGIRigUIx4KEowHCsYC/D3rtflvjgghN7TFijaEjZg64Q+Vki6Qf7SH1UBeFPclyu9USJn56B7HTFxFoCtexhyJzyOBueO4u2HQ3bPs/KKRH32OFYOExXvhWroY7AWKtM99fEREREZl3FM6JzCPFvE1/V5q+zlIAl6Jvb5Kh3uy4CwMEwtaIUC3gh2pB77h0rSp0K7WHooEjbr636eK6LvkdQ6Qe2kfm8R7cgl95aBlEj28jfkYH4bXNqooTORjHht0P+YHcr73quGrxhdBxkh/Anejt29aBNf8qc0VERERkdlA4J3IEsgsOA91pvxIuWQ7ihnrGn9Mt2hCkdXHc25bEaV2SoHVJnEhcf2GdTnYyT3pjN6mHuij2ZMrtgfYo8TMWEzt1IVYiVMceiswB6T7YfA9sugs2/wYy/ZVrhgnLzoD1F8FRF3sVcfO8OldEREREZheFcyJzmG07DO7LlCvgShVxA90ZXGfsFC4cD/gBXKISxC2OE2tUADRTXMclt3mA1ENdZJ7qBdv7Z2UETaInLSR+ZgehFQ3zfnivyLhc11s9ddNd8NyvYfeD4FbNcxlpgnUXwlGXwNoLIN5Wv76KiIiIiByEwjmROcB1XdJDefbvTtK7O+nt9yQZ2JfGsccO4UIRq1z9VqmGi2tOtzoqDuRIP9xF6uF92AOV+fyCyxLEz+ggdvJCzIj+b1lkTPkUbPtdZf64od2119uPq1THLTtTizaIiIiIyJyhT64is4xtOwx0pdm/a5j9VUFcZrgw5v3BsEXL4jhtS+I1QVy8OawQbhZwbYfs032kHuoi+1x/eW4/IxIgdupC4md0EFqSqG8nRWar/u1eZdymu2Db78GuWqQmEIXVL4SjLoL1F0Pz8rp1U0RERETkcCicE6mjbLLA/t3DlYq4Pd7QVKc4uhrOMKB5UYy2ZQkWLEvQttSrimtojSiEm4UKPWlSD+8j/cg+nGQlWA2vaSJ+RgfRE9owglYdeygyC9kF2PmnynDV/c/WXm9aUQnjVr8AgtH69FNEREREZAopnBOZAY7jMtidrgnhencnSfbnxrw/FLH8EK7BC+KWeUFcMKQwZ7Zy0gXynSkKe5Nknuojv22wfM1MBIk/bxGxMzoILlCYIFLmutDzLOz4ozdkdctvIVf5dwfDghVnV4arLjxGizmIiIiIyBFH4ZzIFMtni+V54Upb394kxbwz5v2NCyIsWNZQrohbsCxBQ5uq4WYr13WxB3IU9ibJ701R8AO56jnkADAgcnQr8TMWETmmFcMy69NhkdnELkDn47DzftixAXZugExf7T2xNlj3V16F3NqXQLSlPn0VEREREZkhCudEDkGxYDPYk2GwO8NAd5rB7gyD3WkGujOkRoY0vkDQpHVpJYArDU0NRfWv4Wzl2g6F7gyFvUlv60yR35vCzRbHvN9qjRBaHCe4vIHYqe0EmsIz3GORWSafhj0P+0Hc/bDrISikau8JRGHZ6bDyPG+F1aWngakqYRERERGZP5QKiIzDLjoM7c8wUBW8efu0Nxx17EVSAUi0hL1KuKWJckVcU3sM01Q13GzlZIsUulIU9iS94amdKQpdKRhrNVzLINgeI7gkQXBJnNBib6+VVmXey/TDzgf8yrj7Ye+j4IxYzCbSBCvO8baV58HikyEQqkt3RURERERmA/1NUuY123YY3p+trX7r8fbDvVncAwRwoYhFU3uM5vZo7X5RjEg8OHNvQibFdV2c4bw3JLVcDZfE7s2Oeb8RtrwAbkmCoB/CBdtjGAENUxVhaK8Xwu3c4FXHdT/FqG8uGhbDynP9MO5cWHgsmPr3R0RERESkROGczHmO42IXHZyig130ju2Cg207OKXzokMhZ4+qhBvuzeI64ydwwbBFU3uU5vZYZb/QC+GiDUHNCzfLuY5LsTdDYa8XwHnDU1M4qcKY91tNIa8abrEfxi1JYLWE9c9ZBLzFG3q3VM0Xdz/0bx99X9u6ShC34hxoWaVFHEREREREDkDhnEw5x3Ep5mwKOZt8tkjBPy5k7fJxTXvOpljwAjXHrg3YRp7b/rnjB2520T1guDYRgZBJ08JK5Vt1GBdrDCmYmSNc26GwL03Br4jL+0Gcm7dH32xAoD3mzQ/nD00NLk5gqeJRpFbvFtj8G2811R0bINVde90wYdEJtZVxifb69FVEREREZI5SOCdjKhZstj/eSyFXJF8VqnkBW7EmbMvnbApVYdt4q5LOFDNgYAXMqs0/D5o0tEZqq+DaY8SbFcDNNU7e9uaH25uksMevihtvfriA6VfCeUFcaEmCYEcMI6gJ50VGKea9irjnfg3P3Ql9W2qvWyFY+rzKfHHLz/DmkBMRERERkUOmcE7GZBcc7vrak4f1DMM0CEUsguGqLWIRDAeqjr0tEDRHBWrmQc6r7y8FcqZlKGg7wjiZYmVI6p4k+b0pij3pMRfkMCJWeThqcEmc0NIEgQUxDEt/JkTGNbwPNv0aNt0FW+6D/HDlmhnwquFWv8jbLzkNgpG6dVVERERE5EikcE7GFAxbLFnfXBOghcKBmvPS8XjtVsBUUCaTYg/nye+pCuI6U9h9Yy/UYCaChJZWBXFLElitEf2ZEzkYx4HOP3vVcZvugr1/rr0eXwjrL4ajLoI150OksT79FBERERGZJxTOyZhMy+RV/3havbshc4jrulB0cHI2bs7GyTu4ef/Yb3PzNo7fVm7P2ziZIoV9KZzhcRZqaAlXKuKWekNTrcbQDL9DkTksOwRbfwvP3QWb7h49d9ySUyuB3OJTtZqqiIiIiMgMUjgnIjXcgkOxP0uxN0OxL4uTLlaCNX/vhW9VIVvea+dwpxs0ILAwWjU0NUFoSRwzpoUaRCZt/2Zv3rhNd3mLOThV4XcoAWvPh6MugXV/BQ2L6tdPEREREZm3nHyewu495HfuoLBzJ0YwSMtVV9W7WzNO4ZzIPOO6Lk66iN1XCeCKvVmKfRnsviz2UH7M+dwmwwiZGCELM2xhhCyM8Ihjf199HFgQJbg4jhnSQg0ih6SY81ZVLQ1X7dtae71tXaU6bsW5EFD1qYiIiIhMPyeTIb9zF4VdO8nv2El+504/jNtFobPTm3bFF1q5UuGciBwZXMfFHshR7PPCN7s364dw3rmbtQ/4eiNsEWiNEGiLYCZCNSHaWMGaETIxwwGMsIkRtDBMzfsmMiOGu7zFHJ67C7beB/lk5ZoZhFXn+YHcxdC2tm7dFBEREZEjm51Mkt/hVb/ld+7ywjc/iCt2dx/wtWYsRnDFCkIrVhBau2aGejy7KJwTmaOcvD1G9VvWa+vPgn3g8jezMeQHcNFyEGf552YsoIUVZim3UMBJpXDSadxi0Z8bzMAw8I4NAwwTDDBK5/78YbXnhheils4NA4OqZ5hzY0EXt1jEHh7GGRrCHhrGGR7CHvI2Z3gYe3AIe3gIZ2gYe2gIt1gguHQpoeUrCK1YTnDZckIrlmM1NdX7rUxcqhee/DE89gPYu7H2WmIRrL/IC+PWvBjCDXXpooiIiIgcHtdxcAsF3Hze2493XCxiBAIYlgVWACNg+cfW6LbSfaZV2zaBz/2u62IPDPjhW6kCzqt+y+/cid3Xd8DXm42NhFauJLRiBcEVywmtWElopRfIWW1tc+LvHtNJ4ZzIHOAWbPJ7U+R3DpPfNUR+1zB2f+7AL7IML3RrrYRu5RCuJaLhozPAdV3cTAYnnS4Hagfcp8Zrrxy7hbEXzZg2hoERDGJEIpjhMEY4jBEJY4YjGOEwZiSMUToOhzEiEYxwyLse8dtGHHuvCfuv915rBIM4qVRNqOYFbV6o5gwNYQ8PYw8NekHb8DDO4CBOOj0lb9NsaiK03AvqgstXEFq+zNuvWE5g0SIv2Kwnu+BVyD16q1clV54/zoClp1WGq3acrMUcRERERA7AW8iuWAm5DrTlC7iFfNXxeNvIe/IjnuG3jXzGAYI37AOPdppSplkJ6kyzHOJVB3qlz+QHYrW1edVvK1YQXLnC+0K8FMA1N8/Me5mjFM6JzDKu41LszfhBnLcVOlPgjK6EM6KBcuAWaI1WVb9FsBrDGl56GFzXxU2nsZNJPxhKlsMiJzlcqdIqtQ8nywGSk0yWAzXcw5zAbxxGKIQRCHjTA7quN0+D63ofNqrOD/vnu673QSGfP+z1PqaTGYthNjZiNTZiNjZgNTRiNTZgNjZhNTR4bY1NYBoUdu/x5rvYuYv87l3YPftxBgfJDg6SffLJUc82QiGCy5YRWr6cYDnAW+596Fi2DDMcnr431vm4F8g9cRuk91faF58Mp7wejn8VJNqn7+eLiIjItKj+zOY6jvfZzXFwHRcc2zt2XbBt73rpXtsB16kc43pfpI6xYVl1q0ZyHQc3l8PJZnFzOdxsFqe0z2Rxc1mcbM7fZ3GzOZxc1vvcWSz64VmxXBnmFguVtuKI9lLbgdqrrjHTX3ZPlUDA+2cbCtX+s7YsXMeGoo1r27h20Tt2HO93ZnvtFIvj/92g9OewUDjo9OOBjg7vc/HKFV712wovgAsuX4GViE/5254vFM6J1JmdKngh3M4hP4xL4maLo+4zE0FCyxsq29KEVjE9CNd1cZJJ7N5ein192H19EwvXhr3KrKn8tsqMxTDj8dH7+HjtY7RV7Y3gxP/Zu9VhneN4/8GtPnfxPuSVz/3/JJc+JObzOLl85cNT+TiHm8+VP1BVHzs5/77SB7FcrupDmH+9fJzDLRQw43GshgY/YGv0QrWmxqqgzQ/fGrygrdyWSEzq9zGSk06T37W7Etjt2umV5+/eRWHPXtx8nvzWreS3bh39YsMgsGgRoWXL/HkyvOAuvG4d4fXrD63iLtnthXGP3gr7qsLCeDuc9Ddwyutg0fGH/H5FRETmssoXqCmcVNL7UjSZ9L5QTfojDlIj2kr3+CMS3GKhsgBa6XPPOHu3dOME76+8jspnKT9kKx+XwrjpVhoBUQrrgoERAV5o3GBvVNAH5c9vTjbjfY6rDtyq95mMV/k1h9S83+rwKxSEMX8nE/zd1TzrIMch/7mhMe4JBqdkJIfrOF7ga9u4RRvsYm2IV2qzHX9faTNjMYLLl2NGIlPwG5eRDNedprKOeWZoaIimpiYGBwdpbGysd3dklnKLDvm9yXJFXH7XMHZvdvSNAZPQ0kRNGGe1hGfkmy/XcbAHB7H7B7AH+gE/WIrFMKNRLxiKRus2zM/N5yn293uBW28fxd792L19FPt6R+z7sHt7D/+DgWV5IVFDg1+B1YjVkMBsqNo3NmAmGsp7syGBFY9jxGLevo6/Lzk8brFIoaurMrFtObjbTWHnTpxUatzXmk1NxJ73PGJnnkHsjDOIHHOMNzRgLMUcPHcnPPp9b/iq6wfDVgiOvtSrklv7ErD0nZqIiMwdrm37lVIZnGzWmzM3m8VJZ7yAJ5PByWRxMn57Ko2TGitUqzpPpaZtZMKsZZqVKjjT9D5XljbD8Kqd/G1WCgS8qUxK06RU7yNhjEi0MlWKPzrECAQwggEvGAsEMALBSlv5eqjcZgRK7aUwK1B+Trk9FKx6dlXwOME510QOxUSzIoVzU0ThnIzkui52b7YcwuV2DVPYmxxzoYbAwmhNEBdcHMewpibMcXI5r2Ksv59iXz92fz92f58XcJXO+/ooDvjnAwMT+ibP8IO6kcGdGY9VXYvXtJeCvZrXxWIY4XClwm1k0La/txy0Ffv6DjrPwVjMWAyrrQ2rtcWruBorVGsYEbr5lVtGNKr/WMuYXNfF7u/3grtd3kS4hZ27yO/aRfaZZ3BHzIdnNjR4Yd0ZZxA70w/ruh/3ArknfwyZ/srNS0+HU66C4y+HWOsMvzMRkbnNdZxKIJQpBUCZSiDkz+XkFm1wvL1rF8tt1cfjXveHj9Vcrx5SZjtYjY0E2hcSWNju7yubGY3W+9c0LrdY9D439vZS7O3F7u3FHhiohGiZUthWHa5V/Z6zWdx0ujyccdpYFmbC+0LUTCS8LR7HTMSxEgnMuN9WOi+1xeO1Ffelz3mlXfl8nD1VnwsP+hrT+0xvmiOODX9Sfn8BLsvyrptGTQg32WGpk59L7QBzp43YcF1/ruAIZjRSNY9wKWCLjArgytcC+nJR5i+FczNM4dz85mSL/mqpGYr70uVAzkmPMTw1FqgEcSsaCS2b3PBUJ5+n2NVFcf9+L1SrDtlGhG7F/v5RAcFEmQ0N3qSdpuF9y5nOTOscapNiWQRaW7Ha2kbv29qw2loJlNpaW2f1B2A5MrmFAtmnniL90EOkHnyQzCMbR1XZmUGILsgSa88TX5gjsnIhxqmvhZNfBwuPqlPPRURmjus43lQSQ0PeQkDJZKWCKu0Ha9lM+djJZrzPI9XH5RCuEhq52TFGJcwyZkNDJaxrb68J7ipBXvuUzd/kpNPel53791Ps66t8jtzfi93XS3F/b/nLUXtgYFo+7xnRKGYkghmNesf+uRGLYka8cyMWxUo0jBGqxf2wrdJmRCL6AlVEZj2FczNM4dyRzZu7rECxN+OHcFmKvRlsP5BzUqNDOAAsg9ASf3jqCn94auv4HyTcYpFiTw+Fzi6KXZ0UOrsodNUe2/v3j/naAwoECLS0YLW0YLW2YrU0E2hp9c9bvGut/nlLC4HmZoxQaMzfg+sPSXAyGW/oQdpb+KC8Kmk67bWXz1NVK5amK68t3eu/1mxo8MK0BQv8oK2VQGslaLNa/cCtrQ2zsVHDRGVOcTNJsnd9g/TdPyH99E7SPSGcQu2fYSMaJXbaaX5l3ZlETzh+zH8PRURmE7dYLK+gXQrZ7KHB8srb3irbpfahyqrb/urc0/2l31iBkBEK+SsQWhhWoGY1Qiyzqs2/HrDAKq1gWN3mHZdfU91mGtgDgxR7eipbdzfFnp5JhYdGLEZg4QKCI6vv/EDPam72Vjbv3V873Ydf8Vb0Rx5M+staw/A+E7a1eaMPWpoxo/5IiWjE/71GMWPR2uNIxL9vxO88HNZnNxGZlxTOzTCFcxPnui5u3sZJFXFSBZx0AUwDMxLACFuYEQsjHMAImTP6bZhru9iDuaoAztuXAjg3f+ChnmY86K2a2hYltCxBaEWjNzw14H0Q8Ya59vohWyfFMYK3Ynf3hBYhMMJhAu3tXrDWXAnWAq0tWC3Vx941M5GY1d8suq47q/snckhcF3Y/5C3s8OT/QG6wcmnpWeRaLyDV10T60SdJP/wwzuBgzcuNSIToqacQO+MM4meeSeSkkzAV1omIzy0WvSqxQgG3UIRiwZ+4u7SaYcEfhjn2OXax6lrRH5Y5znk+jz087AVr5ZBtCGdw0KuqP0xGNOov+JPwgp1SNZV/PCoAGisMivlVWNXHkcisC4RKi1VVh3XF7tEBXrGn54Dzmh4KIxwuh23lkQatbQQWtGGN3Dc3jz9PqoiITJjCuRk2n8M5t+Bgpwte0OaHbU6qiF0+LuCki+XrdroAxQn8sTPwwrpwACNi1YR3Zrg2yPP21qiAz4xYGCHLm78BcAu2X/WWramCs3szFPtz4BygXwZYTeFyAGe1Rgi0RbBaI5hhGzczjD0w4H1D2dVVW/3W2Umxq2tik7QGAgTb2wksXkywo4Pg4g4CHYsJLu4guHgxgcWLvQ9MCrNEZh/Xhb6t8JefwmPfh97NlWtNy+HkK+Hkq6Btbe3LHIfcc8+RfvAh0g89RPrhh7H7+2vuMcJhoiefTOzMM4mdcQbRU07GDIdn4l2JyGEohWg1FePVVeQHqjavfl3Gf63fPttWQjTjcW+F7cYmf9XthvKx1eSvwt3YhNXUWFmV299UJTw2J5Wqrbzr6aFQFd4Ve3qwBwa9ue2qRx8saKsafbCAQFsrVtsCb15gfX4UEZlRCudm2JEWzrlFh/zOIexUsRKw+SGbnaoN4g5WUTaugIkVD2LGAriOi5uzcbI2bq5YWap8ihghCyNojD/8tNwnA6sxiBU3MMJFDDOL6wzj5vpxUvtxBvuxBwaxBwYq2+AgFA/y3HJHDAILFtQGb4sXE/TDt0DHYgIL2vRNpchc4TjQ8zTsuL+yJbsq14MxOO6VXiC36gXe5M4T4DoOuc2bvaDuoYdJP/ggdl9fzT1GMEhg8eIx5uyJjK4qKR9HK0OS/LZypUnUn8hZqwuL4BYKOKkUdjKFk/JWh6ysGpmqWTWyZmXJqvvKQdxMhGiW5a0+aFlVKxuWzv1VCv17DnZeXgnRqqyWaASD3oJJ5WCtCauxwTtuavIWUNKE7yIiIqMonJthR1o4Z6cKdN74p4m/wDQw4wHMWNAL3PzQzduPaEt4bWZo7ADKdV3cgoObtXFyxRF7GzdbxMnVHo+6J1fEydpjroyKUQQjA8Uh3Gwf9vA+7P492D3bsXv3cqjJoBGJ+HO2NXthW0cHgcUdNcFbsH2hvh0WmcvsInQ9VhvGZQdq7zGDsOJsL5A77hUQbjjsH+u6LvmtW72w7sEHST30EHbPIcw/OUFGOFyZKygS8VdcjldWWS6tvhyLYcXjGDUrMMf96/HyfaVVmVWxIYfDdV0oFHDyBdx8Djefx815eyeXr2lz8nncXN47z+dq27KZUWGaXQ7gvPNpWWHSskavcB6LecF6LD5q5XNvcvzS/bX/7pXuM2IxL0BToC4iIjIrTTQr0ldcMiYzGiCwMOqFaH6oVgnYgl4QF6+EbkZ4cst8H4hhGBghC0IWFhMPstx8ntz27eQ3bya3eTO57k3kNm+j0NkDZhgjEMLJ9EPhIHOjGIY3zKK5efTWMkabv5mRyGG+cxGZdQpZ2POIH8T9EXY9CIURcwAFY7D8TFh5Hqw8F5Y+D4JTu0KwYRiE164lvHYtLVdeieu6FHbupNjbW16Z0En7qxdmMjiZbM1KhuXVDrNZ/3pphUN/dUO/vcTN5bBzORgYmLo3UR1MjNzifpAXT2A2JLAaGmqP/ZX5rEQCs6FBQd80cl3XC7KGh/0AywutSvOajTWPmVusmpvMtr17qucuK/rzm1Wd19zjv8YtFHDzhXLg5uZyOIWqkC2Xm/EVw41wuLxqpBmPY8WrVo6sXkkyFh9xX7wcaJcCNiMU0p9bERERGZMq56bIkVY5N5u5xSL5nTvJPbfJC+E2bya3eRP57TvGHV5qNjYSXru2vKrVuFtLszf3iYaVisxPuWHY9UClKm7PI2CPGJIWaYIV53pB3MrzYPFJYAXr098p5DqOF4Zks958WNksTiaLm0nXzJVVXnU5laptH6dt0isETkQw6IUfDQ1egBf3QjsvLGmoHDc0YCZGHMdjGMHg6O0I+P99t1j0qsBKoVp1wJZMYg+Xjocrx8PD3jDN4eHykE0mMj/qbBAMYoZCXlgbCmGEQ955qHQexggFMcPhqrYQZjhSDnzNhB+klc7jXvBm+SGbEZz7/26LiIhI/ahyTg6L67oM/Oi2yrfCNR9cvQ+y0z0807VtCrt2VQK4TZvJbdpEftu2cRdWMONxwuvWET5qPeF16witW0d43XoC7Qv1bbWIjJbqhZ0bvCBu5/3Q+Ri4I+bRTCyqBHErz4WFx0547ri5xDBNbxhrNAotLVP2XNdxvKq9dMoL/cYK8lLp2nm7hoexk8NVx5WACX9oY2nezyljmqMDu4A315YRCnrzeI3aQmMHfcEgGIZXYeY6YDu4ju0tOuTYuM5Yba53v+OAU3XtQG22jZPJlH9X1dWPh80wvP/2N/iBZig09rxkgdL8ZtaI87HnLqu5Jxjw50qrnBuhcCVkK4VuoTBmOFQVuPnHR+C/hyIiIjI/KZyTMbmZDF0f//gB7zFCoZrQrjyEIzHGkI94JeArfRtdvi8apdDVRW7TJi+A2+xVxOW3bB13zhcjGvVCuNK2fh3h9esJdHQohBOR8Q3trZ0vrufp0fc0r6wEcSvPhdY1XtAih8QwTayEV4l0uLygL12p+BpOepP1lwK84eSIUG+M43Ta+4JnZKW1Xzk4LXONzTAjEqkMA074w4MTCb+KMIHVkDjgsGFvmGZM4ZeIiIjIDFE4J2NybZvEBRdUViIrTZZc9c28m89j5/PY/f3T1g8jHCa0do0fwK0v74NLlugvDSJyYLkkdD7qDU3d8wjs2QiDu0bft/CYSmXcinOgaemMd1Umxgv6vBCJjo7DelZpcQF30lux6jg/9j3+6pyGaYJpgWlglPaWBaaFYRojrpkYlgmGCZY5qs2wTK9i0zTLzzUsr9qxOlSbicp2EREREZlaCudkTFZDA8u//KUxr7nFYqVyIZWqWvGsKshLJr1hSqV5bkasgjZyXhsjGCS0Zk2lCq4Uwi1bdkTMAyQi08wuQPfTfgj3sBfE9TwzeoiqYULHSZXKuBXnQLytPn2WujIMA/zhkSIiIiIi9aRwTibNCAS81UynYOELJ5/HSaWwGhowAvrjKCIT4LrQv71SDbfnEW+uuOIY8201LoOlp3krqC59Hiw5BcINM91jERERERGRcSkNkboyQ96kzyIi40r1wt6NVcNTH4F07+j7wk2w9FRYerofxp0GDYc39FFERERERGS6KZwTEZHZo5CBzsf9oal+ENe/ffR9Vgg6TqxUxC19HrSuPSJXURURERERkSObwjkREakP14W+rbDrAdj1oBfE7fsLuPboe9vW1wZxHSdAIDzzfRYREREREZliCudERGRmFDKw98+VMG7XA2MPT423w7LT/bniToclp0K0eca7KyIiIiIiMhMUzomIyPQY2lsbxHU+Bk6x9h4r7IVvy8+AZWd4VXGNS8Ew6tNnERERERGRGaZwTkREDp9dhH1PVIK4XQ/C4K7R9yUWwfKzKtvikzQ8VURERERE5jWFcyIiMnnpPtj9UO18cYV07T2GCYtOqArjzoTmFaqKExERERERqaJwTkREDsxxoHeTH8T5Ydz+50bfF27yhqcuP9sL4paeBuGGme+viIiIiIjIHKJwTkREahWy3sINOzfAzj/B7gch0z/6vrZ1lYq45WfBgqPBNGe+vyIiIiIiInOYwjkRkfku0+9Vw5XCuD2PgJ2vvScQ8RZrKAVxy86EeFt9+isiIiIiInIEmdUlDp/4xCcwDKNmO+aYY8rXs9ks73jHO2hrayORSHDFFVewb9++mmfs3LmTl73sZcRiMdrb2/nnf/5nisXa1QLvu+8+TjvtNMLhMOvWreNb3/rWTLw9EZH6GNgFj98Gv7gevnIufGY13Po38IfPeQGdnYf4Qjj2FXDxp+Dv7oUP7IK3/BIu/AQc/VIFcyIiIiIiIlNk1lfOHX/88fzmN78pnwcClS6/973v5Y477uC2226jqamJ6667jssvv5w//vGPANi2zcte9jI6Ojq4//776ezs5E1vehPBYJBPfepTAGzbto2XvexlvP3tb+d73/se99xzD29961tZvHgxF1988cy+WRGRqeY40PN0pSpuxwYY2j36vrZ1sOJsWHGOt7Wu0cINIiIiIiIiM8BwXdetdyfG84lPfILbb7+dRx99dNS1wcFBFi5cyK233sqrX/1qAJ555hmOPfZYNmzYwNlnn82vfvUrXv7yl7N3714WLVoEwC233ML73/9+enp6CIVCvP/97+eOO+7gySefLD/7yiuvZGBggDvvvHPCfR0aGqKpqYnBwUEaGxsP742LiByqYg72bKyEcbv+BNnB2nsMCxaf7AdxZ3tbor0+/RURERERETlCTTQrmvWVc5s2bWLJkiVEIhHOOeccbrrpJlasWMEjjzxCoVDgwgsvLN97zDHHsGLFinI4t2HDBk488cRyMAdw8cUXc+211/KXv/yFU089lQ0bNtQ8o3TPe97zngP2K5fLkcvlyudDQ0NT84ZFRCZj1HxxG8HO1d4TjHurqJbCuKWnQzhRn/6KiIiIiIhIjVkdzp111ll861vf4uijj6azs5MbbriBF7zgBTz55JN0dXURCoVobm6uec2iRYvo6uoCoKurqyaYK10vXTvQPUNDQ2QyGaLR6Jh9u+mmm7jhhhum4m2KiEyM60LvFm/11N0Pwc4HoPspYEQBdHxhZXjqirOh40SwgnXpsoiIiIiIiBzYrA7nXvrSl5aPTzrpJM466yxWrlzJj370o3FDs5nywQ9+kOuvv758PjQ0xPLly+vYIxE54mQHYffD/vYQ7HnYq5QbqXUtrDxH88WJiIiIiIjMQbM6nBupubmZo446is2bN/NXf/VX5PN5BgYGaqrn9u3bR0dHBwAdHR08+OCDNc8oreZafc/IFV737dtHY2PjAQPAcDhMOByeirclIgKODT3PeCHc7oe8QK7nWUZVxQUisPgUWHY6LD/TC+M0X5yIiIiIiMicNafCuWQyyZYtW3jjG9/I8573PILBIPfccw9XXHEFAM8++yw7d+7knHPOAeCcc87hk5/8JN3d3bS3e395vfvuu2lsbOS4444r3/PLX/6y5ufcfffd5WeIiEyLVG9VEPeQN1dcfnj0fS2rYNmZsOwML5BbdAIEQjPeXREREREREZkeszqc+6d/+if++q//mpUrV7J3714+/vGPY1kWV111FU1NTfzt3/4t119/Pa2trTQ2NvLOd76Tc845h7PPPhuAiy66iOOOO443vvGNfPazn6Wrq4uPfOQjvOMd7yhXvb397W/nS1/6Eu973/u45ppruPfee/nRj37EHXfcUc+3LiJHErsA+/5SG8b1bR19XzAOS0/zKuKWneEt3JBYOPP9FRERERERkRkzq8O53bt3c9VVV9Hb28vChQt5/vOfz5/+9CcWLvT+svq5z30O0zS54ooryOVyXHzxxXzlK18pv96yLH7xi19w7bXXcs455xCPx7n66qv5l3/5l/I9q1ev5o477uC9730vX/jCF1i2bBlf//rXufjii2f8/YrIEWK4y1tBtTQ8de+foZgZfd+Co/yquNO9MK79WDCtme+viIiIiIiI1I3huq578NvkYIaGhmhqamJwcJDGxsZ6d0dEZopjQ/fTsOtP3uqpO/8EgztH3xdp8oem+sNTlz4Poi0z318RERERERGZERPNimZ15ZyIyKyTT8GeR7wgbtefYNdDkBusvccwof34SkXcsjOgbR2YZn36LCIiIiIiIrOWwjkRkQMZ3ldVFbcBuh4Hp1h7TyjhBXErzoHlZ3nH4Yb69FdERERERETmFIVzIiIljgP7n/NCuF3+ENX+baPva1gCK86ubO3Hg6X/OxUREREREZHJ098mRWT+KmRh70YvhNv5Jy+Qyw6MuMmARcd7FXErzoEVZ0HTcjCMevRYREREREREjjAK50Rk/kjt9yviNnjDVPf+GZxC7T2BqD9E9WxYfjYsP8NbzEFERERERERkGiicE5Ejk+NAzzNeGLfrQW/ft2X0fYlFflWcP0S14ySwgjPfXxEREREREZmXFM6JyJEhNwy7H64EcbsfHr2KKsDCYypVcSvOgpbVGqIqIiIiIiIidaNwTkTmHteF/u2VIG7Xg9D9F3Cd2vuCMVj6PK8yrrSKaqy1Ll0WERERERERGYvCORGZ/QpZ6HzMD+L8MC7VPfq+phWw/Ew/jDsTFp2gVVRFRERERERkVtPfWkVk9hneVxvEdT4Kdr72HjMIS07xK+LO8MK4xiX16K2IiIiIiIjIIVM4JyL1lUtC72bY/VBlmOrAjtH3xRb4c8X5lXGLT4FgZMa7KyIiIiIiIjKVFM6JyPTLJaF/G/Rugb6t3qqpvVu942TXGC8wYNHxtUNUtXCDiIiIiIiIHIEUzonI1KgJ4PwQ7oABXJVoa2WI6vIzvUUcIk0z0m0RERERERGRelI4JyITl0v6lW9bDy2Aa10DbWu9fetaaFvjHUdbZqb/IiIiIiIiIrOMwjkRqWUXoG8b7H/O2w46BLWKAjgRERERERGRSVE4JzJfpfu8hRhKIdz+Td6+fzs4xfFfpwBOREREREREZMoonBM5kjk2DOysBG/VIVx6//ivC8ZhwXpva1unAE5ERERERERkmiicEzkS5Ib9KrgRIVzvFrBz47+ucakfwh0Fbesrx41LtDKqiIiIiIiIyAxQOCcyVzgODO32Q7fqIG4TDO8d/3VW2Kt+KwVvC46CBeu8tnDDzPVfREREREREREZROCcy2+SGawO43k2wf7N3XsyM/7r4Qj94qw7h1kPTcjCtmeu/iIiIiIiIiEyYwjmRenBsGNzlV7+VAjg/kBvuHP91ZhBaV/tDUNfBgqMrlXCaC05ERERERERkzlE4JzKdsoNe1dv+52oDuIPNBRdfWBXAVc0H17wSLP1rKyIiIiIiInKk0N/yRQ5XPgX926Fvq7f1bqkMSU11j/86K+StgjoygGtbB9Hmmeq9iIiIiIiIiNSRwjmRicgMQP82P4Db5m9+GJfsOvBrEx2V0K28Muo6aF6hueBERERERERE5jmFcyIArgvp3krgVh2+9W2FTN+BXx9phtY1/ra6tgou0jgjb0FERERERERktnJdl2Qhyb7UPrrT3exL76Mr3eUdp/axL72PhbGF3HLhLfXu6oxTOCfzh+N4VW5jBnDbID984NfH22sDuNK+ZTXEWmfmPYiIiIiIiIjMMo7r0JftqwnaSgHcvvS+clummDngcwZyAzPT4VlG4ZzMfcUcJLv9bZ+/jXNczB74WY3L/OBtdVUQtwZaVkG4YUbejoiIiIiIiMxfruvi4lb2uHj/c3Fcp3wNvLaDPeugP+9gz8AllU+NCtpK4VtpX3SKE3p/jaFGFsUX0R5rpyPWwaKYd7wovoiOWMeEnnGkUTgns5PjeENJS6Ha8AFCt+zAxJ9rWN5cbzXVb/7WvBKCkWl7SyIiIiIiIlJ/BadArpgja2fJFrPk7KrjYo6MnSFXzJGzc2SKGe96MUvWztYeV9078nrOztWEa47rAGMEb1X3lI7nKgODtmgbi2KLagK30nkpkIsGovXu6qyjcE6mn+NAbtBbVCE76IVpmYHafaqnKnjzq+Bce+I/wwxCYhEk2sfZ+8dNy8AKTse7FBERERERmZdc16XgFMYMuEpt1fua9qprBaeA4zrYro3t2N7eP3Zch6Jb9K5XX6u+7hTHva/6uj2Zv2sKAAEzUAncxgnfFsQWEDT19+1DoXBOJsYujg7WxgrZxgrgskNwqOl/rK0qXBsjbCvtoy1gGIf9NkVERERERI50tmOTKqZI5pMM54dJFpLecWGYVD7FcGGYZD5JsuBdTxfTlQqzqjCturKsVBk210QDUcJWmLAVLh9HAhEiVoRwIEzEihAJRGray+el40CYqBWtuT9khTAxMQwDA2P03j8Gr+LMNMya85H3jTrHv7fqeCTjAH9HHvc147RbpoVpmBP+vcrkKJyTsaX74NuvqIRsB1ssYSICUYg2eyubRpoqx9FmiC8YHbrFF6rKTUREREREZj3HdRjODzOQG6A/289QfgjbsccMXExMMGrPxwppSiGJaZhjhzuGgeM6pAqpcsA2nPdCtVShErCVg7aq43QxPW2/C9MwywFVdZA1MviqaQ944VjIDGGZFpZhVfaGFwoFzIC3N7z9ePeNajMrryk9o9SPkBk6YIAlU69YKJAe6CfZ30eqv4/kgL/3z6ONTVx63T/Wu5szTuGcjC0YhX1PjG4PJbxgrRSqjbsf455AeGb6LiIiIiIicohc1yVdTNOf7S+HbTX7XD8D2dr9YG5wTg6VDJkhEqEEDaEGEsGEt4W8fUOooXwcC8aIBqIHDdsiVoSAGVDgdYhc16WQy5IdHiYzPEQmOUy2vB8mkxzy95X2Yj5POBojkmggkkgQiScI+/tIosE7rzqOJLzzQHBqC2EqoVsvqX5/P9BPsq+P1EAlfMsMDx3wOQ0LFk5pv+YKhXMytmAU3vATv8qtuRK4qZJNRERERETmiFJF21B+iKHcEIP5wUqwVhW4jQzbCk7hkH5ePBinOdxMU7gJy7DKE/yXFwOomvR/1AIBYy0SMN6iAf65gUE8FKch2FAbqgUTNe3l6/49pftCVmjKftdSy3FssskkmeHRgdqBAje7OLEVT6ul+vsm/ZpAOFwJ7KpCu5pQL5Eg6u9dx6lUu/X31QZw/X1kDxK6VTOtAPGWFhItrSRa2vzjNuLNLTS0KZwTqbXuwnr3QERERERE5jnXdcna2XK4Vr0fyg8xmBscdz+cHz7k1S/DVpiWSAst4Raaw800R5q945H7cDMtEW+vsGvucV0Xu1Agn81QyGYpZDMUcrma8/yB2nPZyrl/nM9mKOZyh9wn9u2VlQAAXvZJREFUKxAg0tBINNFApKGBaKLR3zeU26ONjUQSjQRCIXKpFNnUMNlkklwqSTY5TDaVJJtKkU0O17Tl0mlwXYq5HMlcjmTv/in7XVqBAPGWVuItrSSa/X35vIV4qxfARRsaVV05gsI5ERERERERmRGZYobB3GC5Ym0wN+hVrvnH1RVu1fu8kz+snxsNRGkMNdIYbvSCtnBtwFYO4aqCt2ggOkXvWqab67rk0qlKJVoyWa5OywwPk00O+Xtvy2cyNWGb60zfYhbhWHxUsDZu4Nbgtf3/7d15mBTV1T/wU1uvs6MgqOwooIAIKIu+EtlcolFA0IgiEBdeFRCNETSCSkwUNPGNRIygaFxjxBh30ZgfiiuGYRNREVxYRYaZ6Z5eajm/P6qrurpngOllZpri+3mefqrqVnWdvj3dd7pP37pX8fqaLHllGDrF6uooFgqZCTwraRcOmc+btbSSeoltQRSSybYyR9LNsfQVFSPpliUk5wAAAAAAACAj6RMgpCfZ9rce03PoTSRIVOottZNsJZ4Se7uhZamn1D4OPdoOHWo8RtFEIi09sdbgpaCJWz4SbLLHS4rPRx6fjxSfnxSvlxSf397eX7ni85HH6yfFl1ruCxaRKEl5eFbyRxQlMxFYVNzSDwUckJwDAAAAAAA4zEW0CFVFq2hvdK99c25bSTZrWROvscdMy5QsynbvtVJvqb1e4i2hUk9paoLNsR6QA+iVU8A0VaV4pI7idXUUi9SRGolQLFJnlkXqKFZXR/FIhOLROorXRcwya39dHcWjEYqGQqTFs0/gKl4f+YqLyVeU3iOtODFhgnnzBgJpyTYfKT4viWJhJdLg8IHkHAAAAAAAgMvE9BhVRavop+hPdpKtoW0r+RbRIlnFCcgBezy29GSbc93aLveVI8lWwNRYlOqqq6muZl/K0rwUNJFcsxNtZkItnljPZiKD/RElyU6kmYm1EvIVFZmXfSbK/Iky+1LRomKSPeghCYcmJOcAAAAAAACagW7opBoqaYZWb5leZt0a2mct43qc9sX2pfR22xvZS1WxKgqr4YwfnyIqVOGrsG/lvnJ72VDCrdRbistFC5yh6xSpraG6mmqqq95HdTXVFEks6+otq0mNZpekdVJ8fvL6/aT4A+T1+8njD5DHHyBvIJBYd5T5/eSxyn1+M9lWVEwePxK4cHhBcg4AAAAAAA57BhsU1aJUp9VRnVpHES1ir6cv0/dF1Ei9fXE9Xi+hlu2sodmSBblekq2h5Jt1CypBJEQOAYauU3hfFYX2/kShfXspUm0m2MINJN8ioVoizux1JykKBUrKKFBaSoGSUgqUliUuBQ2aSbSAn7z+BhJtgQApPh8uDQXIApJzAAAAAABwSFN11ZzlM15DtfHa5DKWWlYTr6GwGk4m1bRIynpzEwWRFFEhWZRJFmV7PX25v32KqNizjFb4K6jCW0EV/gp7u1jBzImHEmvG0XDVXqrd+5OZfLNuVdZyL9Xt20ecyXh/gkD+4hI70Za+9JeWOpJxZeTx+/G6AWhmSM4BAAAAAECLYmaKaBGqiddQdaw6NcHmTLrFUsus8nwm1gQSKKAEKCAHKKAEyC/7KSAHyK+Yy/Ry57HOfYqokCIppAjmUhZlkgU5ZV1CD6PDhq5pFN63Ny3htjcl+Va79yfSYo2bDEGUJAqWVVBReQUFylITbv60BJy/pAS92QAKHJJzAAAAAACQNwYbVBOroX2xfSm36lg1VUWrkuuxKnvmz32xfaQZuQ8mX6wUU4m3hIo9xVTiSS7tdW8JBZUgBeVgMtmWSKr5ZT8FlAD5JB96DUGjaKpKkdpqitSYY7pFaqopUltDkZpqqqupTknA1dVUN/ryUm8wSEXlraiowrwVJ5bB8uR6oKSUBFFs4hoCQHNBcg4AAAAAAOphZorpMQqpIdoX3VcvmbYvuq/BRFt1rDrrsdVkUbaTaSWeEir2FlOJUpKScHMm2pxlRUoReqJB1piZ4pGInWCzkm11dsKthiK1zu1qikcy67EpSjIVVVQkE2/lFXYCzr6VV5Di9TVRLQGgUCE5BwAAAADgIrqhU51WR2E1TKF4iEJqyFxXQ1Sn1lFITZTFwyn70o8Jx8Okcfa92YJK0J7Vs8xbRmW+5Ayf5d7y5HpiJtASTwn5ZYx1BfmjayrVVVdTeF+VfavbV2Un2OzeboltXcv89S6Ioj2em9+6FZdQoKSEispbUTCRgCuuaEX+4hL0dgOABiE5BwAAAABQYDRDo+pYdUpPtfT16lg11aq1dpLNSqrVaXV5fSwCCVTiLaFybzmVekvrJdysZJu1r9xXTqWeUlIkJa+PA4CIiA2DIqHalGRbSvKtuorC+8yZS6O1NRmfX/Z6zURbsTlWW6C4JC3plrruDWKGWwDIHZJzAAAAAABNxJro4EBJtvQx2aykW65kUaYipYiCSjC59KRuN2ZfQAmQKKC3DzQdXVPNS0pra81kW3VVvd5u4ep99pKNxs9UKkoSBcrKKVhaTsGyMgqUlidmJU1PuJWQv7gEl5QCtABmpphmUDimkWYwtSk5/N6HSM4BAAAAAByAZmgUVsNUE6+hUDxEtfHalNlEQ2qo3va+2D6qjpqJt7gRzzp2safY7qXm7LVmrRd7iu0EWpFSZCbWPGZSzSN58vgsACQxM+mqSvFohOJ1deYyUkfxSGLZYHlD+8yybC4n9ZeUUrCsnAKlZRQsKzdvifWAtV1WTr5gES4lhWan6gbFNIM03SDNYNJ0Js0wEsu09QaPcZY5j0ksHesGE3kkgTyySB5JJI8skZLY9spiojxZZpUrkui4T2JbEkkUD94T1DCY6lSdwjEtcdMpHDfXQzGN6uJ6SnkoplFdTKNQTKe6tOOspW6YY5V2a11Ey2ee0dR/ooKD5BwAAAAAuJLBBsX0GEW1KEW1KEX0CNWpdXYSrTZeS6F4KLmt1trJN2eiLayGc34ssiinXg66n2SbdZmoNQabLOLjOjQ961LR0N6fKLyvikJVP1F4714K7auicNVPVFdTk0iyJRNthp777LrpPH5/IuGWTK6ZybZEAi5R7i8pJUnGewMah5kpqhoUSiSEwjGNIqpOMdWgmKZTNG0Z0wyKquYyphoU1fSUZcy5dBxr30cz7ETToUiRBPJIIimOxJ1HFskwmMKJpFtdXG+y+HojZzV2G7RoAAAAAIch3dCpNl5r9vCKV9tjmNXEa+z16ng1heIhEgSBFFEhWZRJEZUG163thpYH2qdICsmCTIIgUEyLUVSPUkSLmAk1PZFU0yINljV4TGLb2pdPftlPxUqx2VvNU0TFnmJ7tlCrB5tVVuoppVJfMvkWkAMYlwqanT0+W9VeClXtNZNuVVUUqtpLYef6vqqsk22K10cev588/oC59PnJEwiYywbLHOX2fnMpSphtF5Jimk7hmE6hqEa1MdVcj6lUG9Xs9VBifyixvzamUShqHavZt5ZOlkmiQLJ1k0RSJCFRJpIsmeWKJJplkmgfa5UpknmsJAmkiAJJonkOWRJIIIFU3aC4ZlAssbS245pBcT1t6VhXdYNUPfW5UXUmVdeJGpGAEwWioEemoFemoFcylx7HulemoMdZnti3n/sEPDJJjei550ZIzgEAAAAcwlRdpep4NdXEalKSbFZyrTrWwL54NdXGcx/T7FDiET3kk30UUAJmAk1xJNUSibb0JJu1bR2jiJjgAAqDFo9TJFRDkZoac1w2O/m2l8KJW2jfXgpXZZZ085eUUlF5hTnDaOIWLKugQFkZef3BREItmVRTfD4SRSTU3EDTDYqoZu8xswdYct3qUWYmbQzSDINUjUlNXIJpJXhU3byMM64nL7mMJ8pU+7jEfQwmVTPPZR2vJh5DKJF8i+uNH1uwMQQ7kWQmgbyJyzu9ipRYl8inmEuvIpIvsfTKIvkaOsYqTzvGWlqXikqC0KhLRVuKkfg7xXWD1LQkXsyR6BMEgYJeiYrspJtMPkXED095guQcAAAAQJ5ohmb32IrrcXsZ02P20lqPao59RnJfTIulHO+8X8r99SiF4rnPzFmkFFGpt5RKPCVU6i01b55Se71IKSKDDNIMjVRdJY3TlobWYJlq7H+ZXqYZGjEx+SQf+eTETfKRX/bX27bLEsc2tO0s88t+8kpekpBAgALEhkHRujBFQ7UUra2lSKjGXNbWUjRUQ5HaWoqEailaW5NYmsdosVhGcfwlpVRUVk7BilZ2wq2ovIKCFRVUVGYm44JlZSTJSEAXEsNgimo61cV1isR1iqjOdc1ejzqSatG0pJp5KaaeknhzJtysMq2AL8MMJHpeFSeSQkVemYp8iWXaurW/2Oc4NnFMQJEKOknWUkRRIJ8okU/B/8mWhOQcAAAAHDYMNlIugXTenOV1Wl2Dx+3vvtZNNdQWqZdAgnkppSOxVuItSUmyOccxs7aLPcXoDQaQJ2o8RtHaWoqGUpNr5naNvUwm2WopFgoRc3a9gwRBJF9xsZl0s3u7taJgeXmi15u5HiwrR9Itj5jNwfhjds8ic/yxuG7Y45BZPY7q4ubg99FEUq0ukUiz1iOqRhF7XU9ZN++X355jjWX1/vIrZi8xnyLZvcAUSUgszUsvFVkkxb5UM7lfToxbZl226UmUpR5j3ldx7PN7pJREW9AjkSxhQg9wPyTnAAAA4JBgsEF1ah2F1JA9a6Y1S6ZzxkxrkH/n4P7Weq69zDLhk3zkkTzklbz20lpvaJ/zGOexzqVPTr1fsVJs925DzzCA/DB0naLhUP0kW20NRcMhM9Fm9WgL1drJNi2eWW82J8XrI19xMfmLShLLYvIVl5DfuV5UnHKM1x/ALKRkJsuciTArwVXn6F1m9TAzl5o9aH9MSw7qn0yw6amJN8flfVbirSU6mfkUkQIemfyKRH6PRAGPZCfQnEk06zJLf2LdJyfLfYp5CadPNs/hS1y66XPc3yvjMkWAloDkHAAAADSLmB6zk2f2LJlqTTKB5kiyWTNoWutWco0pf9+InJdJWpdBOretsoAcOPBxip/8Uuq2R/Tgyw1AC2Jm0tQ4xcJh81YXolg4bCfdoqFQ8hLSxGWjVlksnP3svIIokr+4hHzBIju55isqNsuKihPJttQEnK+omGTl0OnZZvUc0w22xw/TDCbNcKwnxhjTjeS4ZFq9ZfJYazumpSXS6iXXkttWoi2i6i2SLLMokmCPP+axxjCTzZ5mzkRaynoiyWauSynrgQb2+XE5JoDrITkHAAAAB8XMFFbDKb3WauO1dgLNmVxL78Vm3eJGPC+PRRZlKvGUUJFSZA7k75g90zlbprVuz6qpFFNQCdoJNlFAjxOAQqapKsXCIYqGQ4kEW5hi4RDF6sIUdW4nkm7mdrJc17KbfdTiDQTJV1xMvmBxvSRbMtGWTLD5i4vJ4z+0ZuVlZqqOqLS7Nka7aqK0uyZGu2rN5e7aKO1KLKvCKqm6QXoioVaoPLJIAY9EAcWR6EokxMwEmZzocSbWT6gpEnkkMTG4v+RItFnHSMkJBBITBXgkEUkzAMgLJOcAAAAOAwYb9RJmziSbtW3vV+sn24wsx0VyEkiol1CzEmf2dtq6fUwi4eaVvIfUl1+Aw52uacnx1qxLQhPrzls0VOtIroVJU3NP6AuCSN5g0LwFguQLBskbLLJ7r/mKGrps1CwXpUP3UvHGJt121cQoruVnXDNFEszxxUSBZMkcg8xaV0SRJHF/ZeZYY5IokNdKrllJNUeSLdmzLDXR5uxhhrHJAOBQheQcAABAAdMNnaJ6YhIC1ZyowJp8IKyGG0ymOZNsVvItpObnklCr15qVULMSZ1ZPNiupZh1jlZV4SqjIU0RBJYgeawCHMGeibX9JtvR9sbrsLxMlQSBvIEDeQBF5g0HyBYvIGwgm1oN2uVlWRL7EPm+wiHzBICk+f4sl85nZ7mmmG0w6M+mJyzcN69JQPVFuGIlLPB37HDfNYDLscxmkG0SaYY6F9mMolnPSrSygUOtiL7Up8dGRiWWbYi+1LvFRmxIvlQc85JGTg/srokiSJJgTAkgiiQLhRxMAgBwgOQcAAJAjZraTZWE1TGEtTBH14LOBHmjWT+vYmJ79AOMN8Um+lJ5oxZ5iKlFKUradtyKliEq8JXbyDb3WANxBjcfMnmqhUGIcNuvy0cSYbM6yUCj3RJsg2L3U/MUl5C8pcYzDZm77iort5JsvaCbdPD5/g5Me6AYnZ7SMGxRRdaqNa7Rb1Ska0SlSrVFd/CeKqtbMl+YyGtcpnhjjzJk40wwjNZGWsi+RPNMb2ue4n55aXghXfx4s6da62Cz3KYduL0EAADdAcg4AAA5LzExxI06heMhOqoXU5PpBy+JmEs5a5uOSzwMRSKg3EYFzfLWGbg0l3TySp0kfJwA0D2YmXdPsMdmioZBjvTa5bSXawuHEZaPmMbqqZh+8gUSbnWRLJNyUYDGJ/iCRL0i6J0C67KeozimD+O9JDPIfietUF9MpUpvYVqspou5NrOsNLuN607a5TU0WBZIcNzllXSRRJJITl31KgmBf/ikKqccqkkitijxIugEAHOKQnAMAgGZjsEExPUZRLWr2DNPNHmIxPUaqrpJqmDfN0Ox1VU/drrePNfu+BzzO0ChmxFKSahrnNlh4OoEEKlKKyK/4683wub/ZQJ0zfFr3sWcRVRz3lXzosQZwCGBm0lWV1HiMtFiM1FiMtLh5s9bNZdzcnzhOi8fS7hNPuY8Wj6fdP0Zs5JagEkSRZH+QZH+QJH+QRK+fBG+AyBsg9vhJ9/hIl/2kyT6Kyn6KiT6qE30UFjwUUY1kj7S4TpGQTnV7kwk03agioqr8PKkHqoNA9syWPiU5I2aDy8S6VxZJEkWSRCIpMUaaM0EmS0LD5Y4x0hosd95fcOxL2RYwgQAAANSD5BwAwGGGme2Elr1MJLIaWkb1qJ1Ms8Y+sxJq1qWX6cc4l879+b5EM18CcoCKlCIKKOYy6AlSUA5SkafI3JcYKy2oBFOOS7lPYhZQJNAADi3MTFosRvFoxLxFIqRGIhSPmevxSITUaJTi0TrHulXuuE/iGDUaJUPXm+/xk0CG4iVN9pMmeyku+SgmeSkm+igieKhO8FIdKRQicz0mmreo5CVVUMzslkUnorrErR7jQDv3S5GERPJMthNozgH8zXXZsX6QBFsDiTa0uwAAcKhDcg4AIE+Y2eydpcfsHltxPZ7Se6uh8vR1KzFml+sqxY14vXOoukoqq6Tp2gF7jTWUcCsEHtFDPtln3iQfeSQPyaJMiqjYN3tbUkgWZFKktPK0Y/a7zzqHKNdLqgWUACYoADiEpCTTImbCLB5NJMcidXayzC5PLFPWnYm1aJSIm2hwMFEilhViSSEWFdJFmTRRJk1QSBUkipNEMZYpShJFWSSVrP0yqYK5tLad6/Y+Qaa46ElNsDWSRxapWBbJp0jkU0Tyygde+hWZ/B7RnEVTSc6aaSXe/B7Rnj3T70iyKZg9EwAA4KCQnAMA19INneJGnOK6eYvpMbO3lx6lmBaze3dZPcDs/Y5eX84y57793aepxx1rKlbiy0pmOZdeyWtejin5U5JpKcvE5ZrO7ZR9aff1Sl6SRIyDA+BmbBiJSzGjKZdjqrFoyuWc1n41Fk0mzRxJtIZ6qHETtLVMRIbkIU3ykCZ6SBUVigsKxQSZYqRQVFBIFRSKi4q9TxWtMo9jPVnOWSb+gx6JAl6Zgh6Jgl6Zgh6ZAl6Jgh6Zgl4zGWYt05NrPlkir2Im3bxyw0uPJOLSSgAAgAKC5BwANBtmprAaptp4LdXEa6gmXkO18VoKqSGKalEziWbE7fHHrISaaqgU02N2ks2ZcLOOj+txUnWVYkbyOJ2b77KihjgTXh7RY/fscq47e3ylHCN56u1PL5dF2extZsXZT4ItPdnW0D5cEgRweGPDoHg0QrFwODljZzhEsXCYYnXhgyTVYhSPJtbt8dOiZOQy4UBjHjMRxYVEUiyRLDMTYx47cRYXPaTa6wqpgictueaxE2qaIDe6B5ooUCIpJpFPFsmrSCm90KxLNwMeR4LNa/YqMxNsqck2Z/LNr0hInAEAABxmkJwDgEZjZorqUaqJmUm1WrWWauO1VB2rNretm1prH2Ml4KxjW6pnmSiI9mWUVk8wr+Q1e3HJXruXl1fy1tvfmPtYZdb9FVFBzzAAaDbMTJoap2goROGaWqqpqaXamhoK19RSOBSiSKiWouEwxcJhiteFSI3UkR4Jkx6LEMcixPEICU11aSeRfRmmmnJpplJvPT2plkykeeol2NKTaR5ZtC+z9CcSZ9all2WKszzRi0xJ9jRz9iqz9te/tDO5rkgCftQAAACAvEFyDuAQ5RzU37q00l43Yg2WWz3OnL3QDlYejoftxFpNvCYv45UpokIlnhIq9hRTiaeEijxF9qWOimT2DvNKXvKIHvJIiZtj3TrOK3qT+xPH2OdIrFv7ZBHNHQA0HV1TKWaPcxalWDRG0VicYvF4YqlSPLFU43GKx1VSVY3UeJxUVSXNvmmkaxrpmkq6ppGha2QklqxrxJpObGjEuk6kayRqMZK1KCl6jKQcegtbaSZNkBITBnjsiQOSvc9SE2nOMdFUQbHXSfaQqHhIUDwkyl4SPQp5ZMm8SQJ5ZJEUSSSPLJJHEkmRRSpObNuTBSQSa9bsmwGPRL60iQCcS58ikYTeZgAAAHCIwrdVgCZk9TSLaBHzpprLOq0uWea41anJ8gaPUZPlMT3WYr3QJEGiYk+xnVxLX3eWWdvOMq/kRY8DAJcyDCbVMEjTmTQ9ua7qBmkGk6YbpOpMmpFYJspVPXlcPHGMqhvmtpa2rRukamnbOpOqObeT94lryW1D10nQ4yTpKklGnCTNXMp6nCRDI0mPk2yo9tK6KYZKshEn2dAS23GzjDVSDJUkym97LFB2H9IMEigmeiieSKxpspc02UeGx0es+Ik8fhK8fhJ9AVL8QZL95tIbLCJ/MEhFfh8dmZb08ilm4swri+SRJFJkwUyqSYkyR7JNFtGjDAAAACBTSM7BYU/VVYroycSZdYtq0ZQkmbXd0DHOhFpUi6bch6npLhNyssY1c/YWs9cdPcrSy/Z3rEcyxz8rUorqJdn8sh9fvgByZM7um0xg6XpqUkszUpNWVmLLKtMNtpNc9rojAaYZqfdxxmnoHPaxVqxE8kxPS6ilJtwcZYk4usHpFSWJdZJIN5eOm8z1y5I3Y7/329+xgQaPN1K385xES6cJEqmCTLogky5IpAsisSARi+aNRIlIlIkkiQRJJkGUSJBlEiSZREkmSZZJlM2lJMskywrJikKyIpPs8ZCiyKQoHvJ4FFIUmfzBIAWLi6iopISKi4upuDhIfq+SmCUTiTIAAACAQwGSc1AwmJlUQ6WoHk2ZWTOux+3JAuztho7RD3xMTIuZCTM9mpKI0zj3yzQbwyeZs1lat4ASSNlu8KYkjpVTjw3IAXt8MyuhhvHNoCUxMxlMpBtMRiLppBtMRiJBZLC5bd/Sto3E/Q1mYjbPx2T2wmIyy4nJXmfr2ERsczv5OIg4sZ16nMFcL+GkO3t6pSWznL27zOMaSIA5jzvIeXTjAEmspvnDkEgGyayRbOgksWYnxGTWUpbWevp+H2uJBJdmJ7usfeIBEmxyMyXDsiWIIkkeH0leH8leL8keH0leL8len3nz+UjxONYdS8Ve+snjM4/x+Pzk8XpJUhSz15skYGwyAAAAAGgUJOegQTE9RgsrF5Ju6KSzTpqhkc66ve1cd+7TWEsek7Z9oOOsGTdbkizI5Jf95JN99ZJkDZUFlEC9hJtf8ZNP8qUk3gJygHyyj0RBbNH6Qar0ZJKVMLKTSY4EkmFQg8kk532cSSc7IZO4vM7qVaQa5mV3VqLGeRmfvZ22z7y/c3/yeCOR3LF6Z1pjubOjjs5tZyfO/R2TPEfynMyU6J1lJro03bCfO2eiDRqJmWTWyMda4pJILZEU00hhjXykk0fQyMM6eQWdFNbIQ+Y+JZFkk9m8nFIyEgkzQyPRcRMMjQTdXC80kiyTpHhIUhSSFQ9JikySrDi2zXW7TJbrlSWPd5Sllx/gOI/PbybRkDQDAAAAgAKA5Bw0SDM0emz9Yy0WXyDBnPVS9tqD/lu9xHyyz962yyRf6jFS/WO8kne/CbeAHCBFUlqsvociZqaYZiaf4pp5i2nJ9biu29up5c7jdXOpJy+1sy7R06zeTUayN5K1bfU+cm6by2SvJd1xLrunlGGkJNqg+UiiQJIgkCgSyaJIopAoS9xEwbwJAqUuyZyMURAEEgWzbUjZTjku9X6iIBAJRGLaOWVRIEkUSZEEkiVzjCyZDFLIIIXMhJdCZsJLMlRH8kslUTf3m8mvOAm6RoKuEmkqkW7eWDO3DTVOrMbJSNx0NUZ6PE56vOV+iJA9XjNR5fEkElgekj0ekhUPyZ7EtpU483jNMlkh2eOxk13W/VKSYFZiLT05pnhS1iVZRkIMAAAAACANknPQII/ooct7Xk6SKJEsyCSJEkmCRLIokySY6+n7nEtZkBs8xr5/2rY17pk1Y6cs4guchROX4cW01GRXTNNJ1dhOdjkHPbcTYLpBqpYcLD2WfpwjWeYcdD0liaY3nFiL64V5qVq+CAKRJCSTR2ZiKXVbEs1kk7VPTiSZJFEwB0eXRJITCSCPJJAsmrMSKon9smQurSSRIiX2JQZVNwdXN4/zpB8vmsckH7C1EOzH7yi2309C/bs4yhq+r+SoV3r9nck1WXQ8R4JzH2X1fmZm0lWV1HiMtFiM1FiMtHhyaa/HouYx8bh5nPP4tPuYy3jillw39P33MNMTt6YgKQopHi/JXi8pXq+ZEPN6k2Vp+1KW1vFWcs2RbLPOaybZPEiMAQAAAAAUMCTnoEGKpNCvB/y6pR9GXqRcnsiOSxadlyHqqfu0tP3OSx0163x6/XGzrJuVSIs5EmkxNbked+5TnUk3PaU8rpvrfAh08vIkZurzyGLKujetzLntlSV7lj9FTvZokkXBTGo5ts2EV+q2eVzqtpRelnae9CRaSm8uMZmQyzSJYei6nQDSVZV0XSND08nQNTJ0nXRNs9cNTSNdj5Nh6A0co5MR18jQNDIMI3GsnnZfnaKJbTYMYsMgI7FMruv7KU9f15PrnCx3HmsRzC5rZtLOXhdIEAWiRI82q4zshFzqfYTELf08RER6PJ5MrCUSZy3x4rcSWs7El+JMhDn3pR3nLFd8vpQkm+LzpSXWPCRirEgAAAAAgMMeknPQIFU36ONv9joGN3fM9pc2MLpzlkDVcWmheSmhkTaAev2B0XUjdYwvw9j/WGDp5cll/SScVe42HlkkrzMRlkhueSSzV5Y3kejyWD2xrDLJcaxs9uRybifLk9tK4hivnEykedJiexKxRbHleuSYEwIYZOhGMomVSFwZVmJLNcu0eJzUWNRcOnpbpfaqiiWOS/bQSm7HU3ttJbYNvan6VgERkSjJdlLLSnjJHk+9Hmayx0qk+dJ6m3lS77O/RJviIUHE+JAAAAAAANB8kJyDBkVVnSYs+bilH0aTEwSye1E5e1WlXLonpV/CJ5IkkrkUkj2uzKV5f68joeVVkr3FvLKU3KdIZu8xJbXck3Y/KynmlQ+eBGPDIF3XiXXd7LmVSFKl3tLLY8mkltWTK64ne24ljtMNg8KGTiFdt8vt5JfVA8ta13UyDGdyLNlDy76fkZZAM/SU5Bo74phljvvoul1Pq6yQyIqHRFkiUZJJlCQSZZkkybFtrcsSSY5jRCltW5Ts80iOY6xtQZJIFEUSRNFeCqLkWBf3s37wY0RRssuIiIg5OXmENUuEY53t/ebMqcRsTiphz7JqHUfmMYZzv3kuuV6CLXkZpyihhxkAAAAAALgTknPQIEUS6fg2xfalhLIkJtcTA6lblw8qKYOrJ8fCkqXkcYrkvDRRtC81tMbTShnTK3GZYeplh8mxq6xyMW1Mq4bKneOGOS9nlMXMLl20kl6GppKmqualhYmboamJddVRppmDvzv3qSrpEc1cJi5xtM+lqlSnaVSrqcljE+fRtOQx6XGsJJyVrDokrn9tZsmEmEiiJCcTP4rHHrPLecmi3cvK40vbPsCx1nkSY3xhXC8AAAAAAABoLCTnoEE+RaI3b/ifFn0Mhq6TppqDteuqSlpipkNNVUlT46THE0s1TnFVTRxn7k85To2TFldJV+P2WGCpSTUtJRmWTIAlywqtZ1YmBEG0E1PJXltWL66Gyp37zXWrJ5W9Lkl2zyrzHKnHNHgfUUy5v9V7K1km2+cSRbNXWLJ3mONxiWKyV5kkkSClxk0eJ+HyRAAAAAAAACh4SM5Bg3RNpW/++2nKAPSGY4B73Sq3BrDXzZ5gumNw+/0NZG/YyTHHQPiJRFoysRZPGYi+0AiiSJKskKTIJMmKedmiLJMkJZaKQqKskKzIJMqKWWYtleS2KMskK9b9lfrHJPbJzhiKeZx9eaNsJrokWU48LsflkEhQAQAAAAAAABQ0JOegQVo8Tv+67+6Wfhg283JEhSTFmhHRQ7KikJQYwN2aXdHcr5hlnsQyUSZZN2eizJn0kuVEQi29LDVxZiW9AAAAAAAAAAByheRcmoULF9L8+fNp586d1KdPH/rzn/9Mp5xySks/rGYnyQq1O67HAQejT9mWJbOHmPNySOcg+Ac5j51UcyTYJE8yqYZkGAAAAAAAAAC4kcCMEeQtzz33HF1++eW0aNEiOvXUU+lPf/oTPf/887Rp0yZq3br1Ae9bU1NDpaWlVF1dTSUlJc30iAEAAAAAAAAAoBA1NleEwagc7r//frryyitp0qRJ1LNnT1q0aBEFAgF69NFHW/qhAQAAAAAAAACACyE5lxCPx+mzzz6j4cOH22WiKNLw4cPpww8/rHd8LBajmpqalBsAAAAAAAAAAEAmkJxL2LNnD+m6Tm3atEkpb9OmDe3cubPe8b///e+ptLTUvh177LHN9VABAAAAAAAAAMAlkJzL0qxZs6i6utq+ff/99y39kAAAAAAAAAAA4BCD2VoTjjjiCJIkiXbt2pVSvmvXLjrqqKPqHe/1esnr9TbXwwMAAAAAAAAAABdCz7kEj8dD/fr1o3feeccuMwyD3nnnHRo0aFALPjIAAAAAAAAAAHAr9JxzmDlzJk2cOJH69+9Pp5xyCv3pT3+icDhMkyZNaumHBgAAAAAAAAAALoTknMP48ePpxx9/pNtvv5127txJJ510Er3xxhv1JokAAAAAAAAAAADIB4GZuaUfhBvU1NRQaWkpVVdXU0lJSUs/HAAAAAAAAAAAaEGNzRVhzDkAAAAAAAAAAIAWguQcAAAAAAAAAABAC0FyDgAAAAAAAAAAoIUgOQcAAAAAAAAAANBCkJwDAAAAAAAAAABoIUjOAQAAAAAAAAAAtBAk5wAAAAAAAAAAAFoIknMAAAAAAAAAAAAtBMk5AAAAAAAAAACAFoLkHAAAAAAAAAAAQAtBcg4AAAAAAAAAAKCFIDkHAAAAAAAAAADQQpCcAwAAAAAAAAAAaCFIzgEAAAAAAAAAALQQJOcAAAAAAAAAAABaCJJzAAAAAAAAAAAALURu6QfgFsxMREQ1NTUt/EgAAAAAAAAAAKClWTkiK2e0P0jO5UltbS0RER177LEt/EgAAAAAAAAAAKBQ1NbWUmlp6X73C3yw9B00imEYtH37diouLiZBEFr64eRFTU0NHXvssfT9999TSUkJ4hRIDMQp3BiIU9hx3FQXt8VxU10Qp3BjIE7hxkCcwo2BOIUdx011cVscN9XFjXGaEzNTbW0ttWvXjkRx/yPLoedcnoiiSMccc0xLP4wmUVJS0ixvDDfFcVNd3BbHTXVBnMKNgTiFGwNxCjuOm+ritjhuqovb4ripLohTuDEQp3BjIE7hO1CPOQsmhAAAAAAAAAAAAGghSM4BAAAAAAAAAAC0ECTnYL+8Xi/NmTOHvF4v4hRQDMQp3BiIU9hx3FQXt8VxU10Qp3BjIE7hxkCcwo2BOIUdx011cVscN9XFjXEKESaEAAAAAAAAAAAAaCHoOQcAAAAAAAAAANBCkJwDAAAAAAAAAABoIUjOAQAAAAAAAAAAtBAk5wAAAAAAAAAAAFoIknMAkJPmmFPGMIwmjwEA2UM7AJCZ5pqPrbneN81Rn+aIEYvFmjyGW2GOwcw113Om63qzxGlqzdWeRaPRZo3nlvYTcofkHOTMTW92t31YbkqhUIiIiARBaLIYe/fuJSIiUWzapuq7776jtWvXEpE7/jZOzfWaRjuQOTe81tAOHBqa6jWdfl43tQNNxfqS3NTP1Z49e4jIfN805RfzzZs3U1VVVZO2AUREW7Zsoeeff56qq6ubLMamTZtoxIgR9PXXXzdZDCKicDhM8XicqqqqiOjQTwCkv76asj5uaWPi8TgRJZPBTVWvnTt3EhGRJElN2g589dVXVFlZ2WTnJzLbmgcffJB+/PHHJo3z+eefU/fu3WnNmjVN+rmjpqaGqqqqaOfOnSQIQpO9bzRNI6Lka6wp4uCzQP4gOQcZ2717N61bt44++eQTImq6L2XWG9tqVJrCvn376Ntvv6UvvviCiKjJGsedO3fSBx98QP/617+IyPyw3BRxvvjiC5o/fz6Fw+G8n9upsrKSLrvsMtq8eXOTxVi/fj2NGDGCFi9e3GQxiIg2bNhAHTt2pGuuuYaImi4BsHXrVnr00UfpzjvvpM2bNzfZP67du3fT+vXraeXKlcTMTfb+bI52oDnaACK0A9lCO5A5N7UDmzZtojlz5tAVV1xBixcvpi+++KJJ3ju7du2iL7/8Mq/nbMiWLVto0aJFNHPmTFq+fLmd3MqnL7/8km666SYaM2YMzZs3j7Zs2ZL3GFaczp0701VXXUVETffFfM2aNdStWzd68cUX835up7Vr19Ipp5xCq1evtr+Y5/t1VllZSQMHDqT333+/SZP0n3/+OY0bN46GDh1Ko0aNoo8++qhJ2hvn+/PBBx+kdevWkSAIeW9zNm7cSNdffz1dcMEFNHv2bPrss8/yXp8ffviBPvvsMyJq2h+Cvv76a7r77rtp4sSJtHjxYtq6dWuTxPniiy/o6quvplGjRtHVV19N69evb5J6bd68mdq1a0fnnHMOETVtO3D88cfThx9+mPdzW9auXUunnnoqffvtt3bb3BTvz8rKSjr99NPpu+++o+XLlzdZnA0bNtDPf/5zGjZsGPXu3ZveeuutJmkHNm7cSNOmTaOLLrqIbrjhBvrwww/zHsdtnwVaHANkoLKykrt168adOnXiNm3a8Mknn8zvvfceh8PhvMZZv349n3POOVxVVcXMzKqq5vX8zMzr1q3j0047jbt168Zdu3blSy+9NO8xmJnXrl3LJ5xwAvfq1YvLysp4yJAheY9hGAaHQiHu1KkTC4LAs2bN4lgslvc4zOZrQJZlvummmxp8HPmwYcMGLisr45kzZ/I333yTl3M2ZPXq1RwMBvm0007jHj168PLly5k5f/WwrF27lo8++mj+n//5H27Tpg0fffTR/MMPP+Q1BjPzmjVr+Pjjj+c+ffpwhw4duGfPnvzqq69ydXV1XuM0RzvQHG0AM9qBbKEdyJyb2oENGzZwaWkpjxkzhgcPHsynnnoqH3PMMfz2228zc/6eu88//5zbt2/P48aN4/Xr1+flnA1Zu3Ytt2vXjs8++2zu1q0bH3/88XzPPfewrut5q8vatWu5VatWPHHiRL7gggt44MCB/Lvf/Y4Nw8j7a+3FF1/k1q1b88CBA/mqq66yy3Vdz1uMyspKDgaD/Jvf/CZv52zId999x+3bt+cbb7wxpdxq2/JRp8rKSvb7/Txv3jweN24c9+vXL+dzNmTDhg1cXl7OM2bM4Pnz5/NFF13EI0eO5EgkktfXwLp167i8vJwnT57Mv/jFL/iss87i8vJyfuONN/IWg5l548aNXFJSwhMnTuQxY8bwiBEj2Ov18hNPPJG3GF988QW3adOGBwwYwO+9917ezptu3bp1fOSRR/K4ceN40KBBPGDAAL7mmms4FArlNc7atWu5vLycr776ap46dSqPGjWKJ02axPF4PO/twAcffMDHHnssd+vWjUeNGmWX57sdCAQCTdoObN++nbt06cIzZ85MKa+rq8trnMrKSvb5fHznnXfyjBkzuEuXLvZnz3z+bTZu3MitWrXiX//61/z000/zVVddxd26dbP/R+cr1vr167m8vJyvueYanjp1Ko8fP55lWeZHHnkkb69rt30WKARIzkGj7dixgzt37syzZ8/mNWvW8KeffsrDhw/ntm3b8uLFi7mmpiYvcb755hv7y2W/fv3sL+eapuXl/MzJhvHmm2/m5cuX8+LFi7lXr178f//3f3mLwWw2Jq1ateLZs2fzxo0b+b333uM2bdrw+++/n9c4lqlTp/KVV17JgUCAr7/++nrJklwbyXXr1nEgEODbbrvNLqupqeHdu3fndF6neDzOl156KV999dXMbD7mVatW8QsvvMC7d+/mSCSSlzjWB4o5c+ZwOBzmjh078vTp0/NybqcffviBu3btynfddZf99+jSpQs/9dRTeY3z7bffcvv27Xnu3Ln81Vdf8bZt23jEiBHcunVrXrBgAe/ZsycvcZqjHWiONoAZ7UC20A5kzk3tgKZpPGHChJRE9urVq3nKlCksSRK/8sorzJz7F8Bt27bx4MGDuU+fPnzKKafwlClTeN26dTmdsyFbt27lbt268ezZszkejzMz8y233MJdu3bN2+ts8+bN3KFDB7711lvtsilTpvC0adOYOf8/Prz22mt83HHH8R/+8Afu1auX/T5iZq6trc35/Bs3bmRZlvnOO+9kZvNv/c477/DDDz/MK1euzGvS+dlnn+WhQ4facW699Va++OKLefTo0fzOO+/kfP7Vq1ezx+PhW265hZmZ//3vf3OHDh342WefzfncTpFIhC+88EKeOnWqXbZkyRK+9NJLOR6P848//piXOKFQiEeNGpXyw8lnn33G5eXl7PV6+e9//zsz5ydB87//+798wQUX2Nu7du3i2267jSVJ4r/85S/MnNv/mx07dvDQoUN5yJAhfPbZZ/PIkSN5xYoVOT/udN999x337NnTfg0wMy9cuJA7d+7M27Zty1ucb775hrt06ZLSDsydO5cnT57MzGwnTPLxtzEMgz/88EPu0aMHP/3003zcccfxOeecY+/PR72sdsB63gzD4BdeeIHvvvtufuaZZ3jTpk05x2BmfuONN3jw4MHMbD43119/PZ977rk8YMAAfuKJJ/LSTq9evZplWeZZs2YxM/OWLVv42GOP5XvvvTfnczupqsqXX345X3755XbZ8uXLefTo0bx3717+/vvv8xInGo3ymDFj+Prrr7fLtm/fzt27d2ePx8P33XcfM+f2/nTbZ4FCgeQcNNqqVau4a9eu/MUXX6SUT5o0idu3b89PP/10zl/6wuEwT5s2jceMGcPPPfccDxw4kHv37p3XL+fV1dX8i1/8gq+99lq7zGrELrvsspzPb/npp5944MCBKb/2qqrKZ555Jj/33HP82GOP8Y4dO/ISy2r4JkyYwPfffz+//fbbrCiKHXvx4sU5N/i7du3i0tJS/tnPfmaXXXPNNTxo0CDu3r07n3vuufaX81xeB5FIhAcMGMAvvPACMzMPGzaMe/fuzUVFRdy+fXv+3e9+x7t27cqpLl9++SULgpDyAWnRokV8xBFH8Mcff5zTudO9+eabfPLJJ6d8WTnvvPN43rx5fN111/Frr72Wc32YmV944QUeOnQo19bW2u+Tf/7zn+zz+fj444/nxYsXM3PuiZmmbgeaow1gRjuQLbQD2XFTOxCPx/mMM85I+SLLzLx7926eOnUq+3w+/vDDD7OvRMI777zDo0aN4srKSl66dCmffPLJef9QrmkaP/DAAzxu3DjesWOH/Zzt3LmT27dvz2vXrs1LjEWLFvHkyZN579699nN/3XXX8ZlnnslnnHEGT5gwgVeuXJlzLMv333/Pl1xyCe/Zs4fvv/9+7t27N8+cOZMnTZrEixYtspOQ2dB1ne+44w4WBIE///xzZmY+88wzuU+fPlxaWspdunThYcOG8Zo1a/JSl/nz5/MvfvELZmYeNGiQ3dNozJgxLAgCL1myhJmze03/9NNP3L9//5TX8o8//sh9+/bN6/8BZvN/Tu/evfnBBx+0y2bPns3t27fnPn36cMeOHfmxxx5j5tzen3v27OGePXvyP/7xj5RzjRkzhocOHcoej4c/+uij7CviMHr0aJ4yZUq98rvvvpsFQeBXX3015TFk6tNPP+Vhw4bxypUr+fXXX2+SBJ1hGPz444/zBRdcwFu3brX/j0ajUe7cubPdkzofnnvuOb788stT2vqZM2dy7969+ZRTTuHTTjvN7t2Yjx5H4XCYx4wZw9u2beMXX3yRu3btyhdeeCFPmjTJ/kEqF4sWLWJBEPiVV15hXdf5jDPO4AEDBnD79u25V69e3KVLF/7ggw9yrsdTTz3F//M//8PMzKeffjqfddZZPHv2bL7uuutYEASeM2cOM2f/nNXU1PC5556b0g7U1NTweeedx2effXbOj98pEonw6aefznPnzrXL5syZw+Xl5XziiSdyaWkpz507l6PRaE5xamtruXfv3rxo0SJmTv4ANGXKFD7nnHPsv1su3PRZoJAgOQeN9u9//5uPOOII3rx5MzNzSqN+ySWXcNu2bfPypezhhx/mp59+mpmZ33///bx/Od+1axdPmjTJjmH9I37kkUf4jDPOYMMwUj645lKXBQsWpHyIuOuuu9jj8fCAAQO4W7du3KZNG/sDeS5xrDo8/fTTdiP5yiuvsMfjsS/R+fbbb7M+v2Xs2LF88skn8+LFi/nUU0/l4cOH8/33388LFy7kXr16cY8ePexf/rKtTyQS4REjRvCyZcv41ltv5VGjRvGGDRs4HA7zrFmz+MQTT+RHH300pd6Z+uijj+xfdS1r1qzhnj178oIFC5g5f0mgxx9/nIuLi+0veQsWLGBFUXjChAk8ZMgQ7tq1K9977705x7vnnnu4Xbt2KWVvvfUWT548mc8//3w+6qij8tKN/d13323yduCvf/1rk7YBzM3bDtx3333N0g5Y923qduCiiy5q8nYgGo26qh144oknmqUduPfee5ulHbj22mt50KBBvHfv3pTy7777jseMGcPnnHNOzpfRRiKRlC92jz76qP2h3Jk0y/VL7NKlS/mBBx5IKdu1axeXlZXxu+++m9O5LZs3b065FOeOO+5gn8/Hd999N99+++08fvx47ty5c94u3w6Hw9y7d29evXo1h8Nh/utf/8qtWrViQRDs5y6X19rOnTv5qquuYq/XyyeeeCKPHj2aKysrOR6P87Jly3jkyJF80UUX5aWX3lNPPcVt2rThxYsX8znnnMM//fSTve93v/sdy7Kc02VOn3zyib1uPSfLli1jn8/H//nPf7J/4GkMw+BLLrmEe/Xqxf/4xz/4pptu4kAgwEuXLuVXX32V7777bhZFMefE0+7du3nQoEE8b948u0fRN998w+3ateMXXniBzzrrLL700ktZ07Sc3ztz587lY4891u6FZZ0vHo/zNddcwz169Mj5x6fKykp7/dVXX7UTdP/v//0/u9z6H5Dt/4JXX33VTmIwm/Wora3lo48+mp9//vksH3l9VVVVKT9s3nvvvezz+fhPf/oTL1q0iKdOncoejycvPwowm/9H+/btaydh/v3vf3NZWVlKO5Brr925c+eyJEncpUsXHjNmDG/atIk1TeNPPvmEL7roIu7fv3/OPzy9/vrr7PP5+PHHH+fRo0ennO+JJ55gQRByvhLB2cvPeh29//77LAiCnejOl2nTpnFxcTEvXLiQr732Wvb7/fzMM8/w6tWr+amnnmJBEHjZsmU5xYjH43zeeefxlClT7P/FW7du5SOOOILfeustvuKKK3jIkCE5J2jd9FmgUCA5B41mGAb36NEjpQu7M7Pfo0ePlO6zucZiNj8orVixot6X87q6Ov7mm2+y+kccjUb5s88+qxfr4Ycf5oEDB6aU5dOrr77KHTp04Jdeesn+cDl06NCUHii5eumll7hv37728/Kzn/2MJUniiy++OG91+uUvf8mSJPEvfvGLlMvYtm3bxh06dKg3Lkw2Ro8ezSeffDJPmjSJn3zyyZR9kyZN4r59++Z0fufrxvm8TJs2LW9fXp369evHFRUVPGrUKPZ4PPzWW2/Z+2644Qbu1KlTvX9smdq4cSN36NCBb7jhBt61axd/+umnHAwG7a7rnTt35ocffjinGMzmc9ezZ88maQca+rLYFG2Adf9Vq1bZ203RDjT0obep2gHnY22qdsCZrGzKdsB6jE3dDjj/Pk3VDjjP279//yZrB6w4n3/+ebO0A8899xyfdNJJfN9999W7lH3p0qXcrl07/u6773KOk/56behX8zvuuCNvvbSseJFIhLt3757Sg/Kll17KqU7WuaPRKJ9zzjkpvRbee+89bt26dcprIlvxeJxVVeWRI0faY3SNHz+eS0pKuFu3bvaltLmyekf079/f7kFn+eMf/8hHHXVUXi5v3bp1K5933nncr1+/lMtbmc0kardu3fi5557LKUb662zLli3cr18//u1vf5sSL1fvvPMOjxs3ji+44ALu2rVrynsxFovxCSecYPcCysWMGTO4d+/e/Mtf/pLvvfdeLioqsnuJz58/n0844YSsk7PO5+Ljjz/mIUOG8HXXXWcnTKz9b7/9Nrdr145Xr16dU4x0r732Gp911lk8atQoO5E5ffr0rHoDNvQcOF8L/fr145deesnefvzxx7O6VLOhOLFYjK+88sqU97yVRM12zL6GPttOnDiRX3zxRWY2f0CtqKjg9u3bp3yGy1R6febNm8e9evWq97d+/vnnuVWrVlklG5110XWdL774Yu7UqZP945+mafYxffv25fvvvz/zijDvtxexYRhcU1PD559/Pl922WVcV1eXUzvgvO/mzZv52muv5QkTJvDJJ5/M8+fPTzl2yJAhfM011+Qc509/+hMPHDiQTz/9dJ41axYHg0H7vM888wx37NiR9+3bl1Ucy3PPPcd9+/Z13WeBloTZWmG/fvzxR/rss89o7dq1VFtbS4Ig0L333kuVlZU0ffp0IiLyer32dOB9+vTJaop7Z5xQKERE5mxMuq6TJEl02mmn0T333EOBQIDOOOMM2r17N9188810+eWXUzQabXSMVatW2dNin3zyyURkzsDjnCHJmsVIEAS64YYbaPTo0VnXJX2mxK5du9Jrr71G559/PpWXlxMR0amnnprR+RuKU1dXR0TmzJZdunShNm3akCiKNGXKFPryyy9p/vz59PLLL9OVV15p/62yiVNTU0NERE899RTNnj2bLrnkEjryyCPtY9u0aUMdO3ak2trarGNY9/3jH/9I0WiUli5dSnv37rXrR0Q0atQo8nq99vTzmcSxXgPO141zRqGrr76aioqK6LHHHkuJmW19rOds1apV9Le//Y0mTJhAgwcPpsGDB1MkEiEiohEjRpDX6814Zk1nnEgkQl26dKEbb7yRli1bRr1796Zhw4bRlVdeSTNnziRd18nr9drPZSbq6urIMAz7ORNFke69917673//m7d2wIqhqmpKuaZpeWsDnHEikQj5/X7q16+fHSef7YAVp6FZZvPZDjj/NtbjZ2bq1KlTXtsBK45zlrennnqKbrnllry1Aw3V5Y9//CPV1dXltR1wvgZkWU7Zl892wIrjfHyffvopPfHEE3ltB9LjdOzYkW666Sb6xz/+kbd2YOvWrfTII4/QkiVL6M033yQionHjxtFpp51GDz/8MD355JMp5xwwYAAFAoGMXwMNxbFeC9Zrb+LEiTRt2jRavXo1PfDAAzR+/Hi644476v0tGxvnjTfeaPAYURRJFEU7/uzZs+nqq69u9GvhQHXxer308ssv07nnnmu/5ioqKqhNmzZUUVHR6Hqkx3nrrbeIiEhRFJJlmfr27Utff/01XX755bRixQp6+eWXafr06bRs2TK68cYbs45j1efII4+kO+64gx544AHq0qULESX/Tl27dqXy8nLyeDw5x+nQoQMNGzaMvv32W6qsrKQtW7bYsw0WFRVRWVkZeb3erGJYz5mz/SQy30dnnXUW/eUvf6Hdu3dnNbthQ6+zM888k5577jlavHgxybJMRx99tB1X0zQqKSmhtm3bZh3n9ddfJyKz7Rw/fjzt27ePXn/9dfrtb39LDz74IBERlZaWkt/vz7hd27dvHxGZ7w3r73zKKafQeeedRx988AEtWLCAtm3bZj9X3bt3p2AwmFGb5oyRPtOj9XjPPvtsmj59OomiSHfffTddeOGF9H//938ZvdasOJIk1fs/7fwsIIqiHffWW2+l6667LqNZVZ1xnP8/mZk8Hg8tWrSIRowYYddVEARq27YtHXvssY2O4YzjfN6sx3nCCSdQZWUlTZgwgd5991167bXX6KGHHqIVK1bQ+PHjs4qTXp9bb72VnnjiCerevTsRJf+XtmvXjo488kgKBAI51UUURRo9ejSVlZXRli1baPPmzSRJkn1MUVGR/Xkq0ziKojQ4q6ggCFRcXEzDhw+nZcuW2a/tfLxvOnfuTA8++CA98sgjJMsyHXXUUURktp+appHX66VOnTplHcd6TU+fPp2mTp1KnTt3pi+//JJ+97vf0UMPPURE5v+hkpKSjGJs376dXnnlFVq2bBmtWrWKiMzPAgMHDqRHHnkkb58FnHGcszQzs/23ysdngYLVAglBOASsXbuWe/Towb169WJBEOyBv6uqqnjBggV83HHH8ZVXXplyn4svvpivvPLKjGY3ayiO877WumEYvGLFCh4yZAjLsszBYLDRYwI1FKOhXz+eeeYZPuWUU5iZedasWRwIBDK6Vn5/cQ70XEycOJGvv/76vD1nqqry8OHD+bjjjuM2bdrYPQT//ve/c5s2bXjnzp051cc582P6eAiqqvL5559v/wLUmPrs7zmLxWL8j3/8gzt16sQnnXQSr1+/3o49bdo0HjVqVEYDwDb2NaCqKo8aNYqHDx/e6HMfLI7zOXviiSe4d+/eKfeZMWMGn3baaRl1+06PY42ZFYlEeNu2bbx8+fKUX5Framp4+PDh/MwzzzBz43uErVu3jocPH85Dhw7l4447jv/yl7/wDz/8wJqm8X333cddu3bNuR1Ij/HQQw/xli1b7P3WL7S5tAGNiWM91lzbgYPFaUg27cCB4miaxmeeeWZe2oGG4nz55Zf2/vTZ0rJpBw5UlxdeeIE7duyYl3agsa+BXNuBht43X331lb1/6dKleWkH0uMsXLjQ7r2yfft2fvPNN3NuB6wZRgcOHMhdunThoqIivuKKK+xfyKdMmcInnngiz5gxg7/++mv+8ccf+eabb+bjjjsuo8knGorzq1/9irdv324f4+ytsWTJElYUhUtLSzPqmdOYOMzmZ50jjzySV65cyXfddRf7fD7+9NNPm6QuzOYEFAMGDMhoUoD9xbF6q911110sCAJ36tTJbgOqqqr4L3/5iz0sQbZxJk+efMB2ZPr06TxixIiMep82FGfSpEl2b+kFCxbwUUcdxb179+aPPvqI161bx7fffjt37Nix0T0zMvnbfP/993zSSSfx3LlzM+4xs7/nzBnnwgsv5JkzZ/KOHTs4Eonw7bffzu3bt8/o0uaG4kycODGlN0x6b5bJkyfzmDFjMprJ+/PPP+dOnTrZPQmZU3sc3X777Xzqqafyeeedx5WVlfzVV1/xLbfcwh06dGj0Za0NxUh/3p1t1ssvv8zl5eVcVlaWculrPuIwm5+nOnfuzC+++CL/4Q9/YJ/Pl9LbPt/1YTbHIOzTp09GlwIfLM7ixYtZEATu1q2b3Q5Eo1F+9dVXU/4vZRPnYL0vb7zxRh48eLD9Hs4mhrOH+9/+9jc+/vjjuaSkhP/5z3/y22+/zbfddhsfc8wxGb1vMvnbGIbBgwcP5ssuuyzjsTob85xNmTKFzz33XN6yZQvv2bOH58yZw0cffXTOf5v093f6Y7/mmmt45MiRjZ7xdu3atdy5c2c+5ZRT+IgjjuD+/fvbnyWYma+44gru1atXXj4LpMdJv7Tc+bfK9rNAIUNyDur5+uuvuU2bNvyb3/yGt27dygsXLmRBEOyxivbs2cMPPfQQt23blvv27ctTp07lSy+9lAOBQEbjfjQURxTFegOWWw1ZJBLhc889lysqKhodp7ExmM3EybBhw/j2229nj8eTculrPuMwm/9sbrvtNm7dunW9gfVziRMKhXjChAncv3//eo8/k7FfMq2Ppml82223cbt27Rr9oX9/rzPrQ3ZdXR2/8cYb3LVrVz722GN5+PDhPHr0aC4rK8uo23Jj62J9APjvf//Loiim/NPJV5zvv/+eKyoq+Oyzz+YHH3yQr776aq6oqMi5Ps7nLV0kEuFZs2Zxu3bteOvWrY2O8+WXX/KRRx7JM2bM4Oeff57nzp3LgiDwhRdeyGvWrOF4PM4PPfQQt2vXLut2YH8xxowZkzK+hPWPOJs2IJM4zLm1A5nEYc6+HThQHGvclQkTJvCAAQNyagcaE8cpm3ZgfzFGjx5tfxF64403uFu3bjm1A43921j/b7JtBw4UxxpX8Pvvv+dWrVrl1A4c6Hlr6LWWTTtQW1vLgwYNsi9T37FjB7/++utcUVHBw4YNsxOBd9xxB59++un27MpHHXUU//e//210XQ4U56yzzuKvv/7aPlbXddY0jadNm8bl5eUZtQOZxKmtreW+ffvy0KFDM/pSnkkMZnN23V//+tdcXl6e0d//QHFGjhzJ27dvZ1VVeerUqfaYataXzUwSTQeKM2rUqHrv82+//ZZvuukmrqioyOhStgPFGT58uJ3UevLJJ/mss85iQRD4hBNO4K5duzb6tZbp30bXdR45ciQPHTo0o0RWY+PMmzePBwwYwK1bt+YzzzyT27Vrl7f3zYgRI+rVp7KykqdPn86lpaUZDaT+3Xff8UknncTdunXjE088ke+44w57n/N5eeyxx/jss89mQRD4xBNP5A4dOjS6PgeK0VDSRNd1njFjBhcXF+etLulxdF3n0047jU844QQOBAKNTs5nGoeZ+YsvvuAbbriBy8vLM0o0HiiOMwn0m9/8JqPEYrZxLBs3buQZM2Zk1K419nX23nvv8cSJE7moqIh79uzJvXv3zuh9k+nfhpn5yiuv5FNPPTWjHxsaG+fJJ5/kM844gz0eDw8cOJDbt2+ft/o0NHTHypUr+dprr+WSkpJG/22+/vprPuaYY/jmm2/mffv28apVq3jixIk8efLklI4auX4WOFCc9DEyDcPI+rNAoUNyDuq57bbb+Oc//3lK2dlnn83vv/8+v//++/avpd988w1PnDiRL7roIr788ssznjVlf3FWrlzJH3zwQUqPhng8zn/4wx/Y4/FklBnPJIY161BpaWnG/8QyifPuu+/yL3/5S27btm1GjdbB4rz//vtcVVXFtbW1OQ/6nkl93nnnHR47diy3bt06o/oc7HVm/fofi8V47ty5PH36dL7lllt448aNTVYXwzD4+++/53HjxmU8MHdj4yxfvpz79u3Lffv25Z///Od5f984H/cnn3zCl156acb/IJnNng8XX3xxStkVV1zBPp+PR48ebY8xtHnzZr7iiiuyagf2F8Pv9/PYsWNT3oeapmXVBmQa5+GHH866Hcgkzn/+85+s24EDxRk9ejR//fXXvHv37oySsZnGGTt2bEri79///ndW7cDBXmfWh8doNMp33nln1u1AJn8bZs66HWhsnLfeeov79euXdTtwsDjOL5KrVq3Kqh2IRCJ88skn87PPPptSvmnTJj7iiCNS2qFdu3bx66+/zu+//37GMwIfLM4FF1yQ8gXwk08+YUEQMvqynGmcvXv3cocOHbiioiKjL8uZxPjoo4/4f//3f7lPnz4ZxWhMnPT/EdnKpD4ffPABT548mbt3755xG32wOOedd55dZhgGf/bZZ/zVV19lNNB8JnWxvtR+9913GY8xdrA4559/vl326quv8j333MOLFi3KuK05WJwLL7zQTgLs27eP//a3v3Hfvn0z+tsYhsH33HMPn3POOfzWW2/xnDlzuHv37vtNnDCb49Bt2LCh0b2/GhMjPQG0du1aPvroozP6H51pHFVVefDgwRknzjONs379ervnbL7jZNKzPF/1Wbt2Ld9www3cq1evRrdr2bzOvvrqK965c2fKBDH5rouluro6o97GjYnj7Mm2bt06XrJkCb/wwgsZfX/LtD66rvNLL73EgwYNavTfJhaL8cyZM3ncuHEpf4MlS5Zwq1at6vWK27NnT1afBTKNw5z9Z4FCh+Qc1DN9+nQ+++yz7YGprUsjBgwYwG3atKk3SxJzdrN+HSjOUUcdxaNGjUqJ89hjj9UbdDgfMazZuD7++GMeNGhQVlMzZxLno48+4lmzZmX85fJgcdq0acMjRozIecaiTOuzcuVKnjFjBm/YsCGvdRk5ciS/8847zVKX9NdzY7t5Z1of54ycNTU1eY+zv/dNJt3jLWPHjrUHkLYui5k3bx6PHDmSjzvuOJ49e3a9+2TaDhwoxvHHH29frmv9WpZNG5BJHObc2oHGxolEIjm1Awf728yaNYuZc5/QIpP6ZNsOZPK3aY66OH/Rzub9ebA4zvdNLu1Aps9bNu1AKBTio48+usEvFGvWrOFgMMhz587N+LFnE+euu+5KuU9jL5PKJc7vf//7jN+fmcZYuXJlvUtq8xXnzjvvzPi82cRx1ufdd9/NahKI5nitZVqXbNvPxsTJx6QPmdanrq4uq/fNjh07eOnSpcxsJuGtBIDz75Hp5X7ZxEjv1ZTNDJCZxnn00Uez+vyUaZz169dnNaNpY+LkY8bxTOuzevXqjGfpbUyM/U3i1JR1yXY22+Z43zQ2Tvp7J/1S9wOJRCJ8//338yOPPMLMyefdmoTO+jvnOmlOY+Oky6ZNK3RIzkE9Dz30EAeDQR47dixfeumlrCgKL1u2jEOhEH/44Yd8+umn8y233JIyPlI2jWRj4+TyBbOxMZjNxirbN3kmcXRdz7qxzyROLjKJo2laVv9gMvn7W41+U77OmHP753KwOKeddpr9vslFJu/PXNxwww3ctm1buxv/jh07uLy8nJcvX84PPfQQ+/3+er+KZfr3OViMQCCQcS+cXOOEQqGs24HGxHFefpxtO1BIz5tVH8MwsmoHsqlLNu1AoTxnfr8/LzOXNVd97rvvPj7mmGP45Zdftsusv/O8efP41FNP5Z9++inn9qaxcaz3TLafCxoTxzn7cFPFyGRsuVzi/PTTTzkn6ZvjOWtsnFzrU0jP2Z49e3L6bJNJnFzr47R9+/YGEwD//Oc/85IIOlgMq375qNP+4rzwwgs5n7uQ4vzzn//M24zDB4qTz/q0dF2aK86LL76Yt/dNU8Vx9uq13nc7duzgrl27pnyeyfQqkHzEyWfbViiQnIMG/fnPf+Y//OEPPHbs2HrTOV9xxRV8+umn56XROlic0047Lec4jYmR7ZfkTOPkowFujuessXFyrU8h1QVxUn377bc8ePBg9nq9fNZZZ3EgELAnf9izZw8fffTROffSbI4YiFPYcdxUl0M9zvbt2/njjz/mN954w27bt2zZwhdddBGffvrp/Oabb6Ycv2jRIu7RoweHw+HDNo6b6uK2OG6qS0vHYeaUH+S3bdtmJwDmzJnDM2bMYEEQeNu2bQUTA3EKO46b6uK2OFaM119/PeW7hDPeF198wa1atbKTZr/97W+5vLw8ox8DmivOocYF881CLjZt2kRLly6lH374gfr06UNDhw6l/v3703XXXUdERDNmzCC/309E5tTfzqm5DcNo9PTy2cY58cQTGx0nlxiZyCUOZzAFd3M8Z81Vn0OhLoiTjDNy5Ejq3bs3vfnmm7Rw4UIyDIMmTJhAl156KRERfffddxQIBKi0tLRR52+uGIhT2HHcVBe3xVm7di2df/755PV6adeuXXTUUUfR3LlzacyYMXTzzTfTHXfcQbfddhvt3buXLr74YlJVlb755htq3bo16bp+WMZxU13cFsdNdWnJOG3btqXbb7+dRo0aRRUVFWQYBhERtWvXjq6++mpiZrrzzjuprKyMPv30U2rXrl1BxECcwo7jprq4Lc7BYljfNQRBIFEUqaioiObNm0cLFiyg9957j1q1apWXuuQrziGp+fKAUGg2bNjAZWVlfNFFF/E111zDxx57LJ988sm8cOFC+5g777yTg8Egr1ixgj/44AOeM2cOV1RUZDSuUHPEcVNd3BbHTXU5XOKcdNJJvGjRIvuY9F54N998M5900kmNvjSrOWIgTmHHcVNd3BZn9+7d3L17d549ezZv3ryZt23bxuPHj+fjjjuO77jjDo5Go1xZWcnXXHMNy7LMffr04YEDB3J5eXlGg8u7KY6b6uK2OG6qSyHE6dGjB8+ZM8e+dNnZW+Wyyy7jkpKSRn/maI4YiFPYcdxUF7fFaWwMZnN8u759+/L48ePZ4/FkNDlLc8U5VCE5d5iqra3lUaNG8c0332yX/fDDD9yqVStu06aNPYisrus8fvx4FkWRjzvuOD7ppJMymlWsOeK4qS5ui+OmuhzOcSwrVqzg66+/nouLixv9ob85YiBOYcdxU13cGGfDhg3csWPHeh96f/Ob3/AJJ5zACxYsYMMw7HEt77rrLl60aFHGA6W7KY6b6uK2OG6qS6HE6dWrF997770pl8guXryYy8rKMhpnqjliIE5hx3FTXdwWJ5MYn3/+OQuCwH6/P+PZuZsrzqEKybnDVDgc5gEDBvDTTz9tbzMzX3TRRTxs2DAeNGgQv/baa/bxK1as4HXr1mU8m1BzxHFTXdwWx011ORzjDB48OCXO+++/z1OnTuX169cXVAzEKew4bqqLG+NUVlbyMcccwytWrGDm1Flqp02bxh06dOA1a9ZkdE63x3FTXdwWx011KaQ4nTp1Somzc+fOlAHcCyUG4hR2HDfVxW1xMomxY8cOvvbaazOe0bw54xyqkJw7DBmGwbt27eJ27drx/Pnz7fLvv/+ee/bsyY8//jj37t2bp0yZUvBx3FQXt8VxU10O5zi/+tWvUu4XiUQKKgbiFHYcN9XFjXEsAwYM4J/97Gf2djQatdf79+/PF198cVbndXMcN9XFbXHcVJdCjJPLZGDNEQNxCjuOm+ritjiZtDXZft5ozjiHIiTnDiPpb9YHH3yQBUHgyZMn82233cZFRUX2bG/PP/88d+zYMWWq90KK46a6uC2Om+qCOMk4mcxo3BwxEKew47ipLm6LEwqFuKamhqurq+2y//73v9y6dWu+5JJL7DLrnDNnzuTzzjsvo3q4LY6b6uK2OG6qi9viuKkuiIPXgNviuKkuboLk3GFi06ZNvGDBAt6+fbtdpus6L126lAcMGMBnnXUW33PPPfa+P//5z9y3b9+Mpylujjhuqovb4ripLoiD1wDi4DXgtjgbNmzgkSNHct++fbldu3b85JNPMrP5y/QzzzzDRxxxBI8dO5bj8bid+J8wYQJffPHFrKpqo2O5KY6b6uK2OG6qi9viuKkuiIPXgNviuKkuboPk3GHgq6++4oqKChYEgWfNmlVvBrdIJJLSnZSZ+brrruOxY8dyJBJp9BujOeK4qS5ui+OmuiBOdnHcVBfEyS6Om+ritjgbNmzgVq1a8Q033MBPPfUUz5w5kxVFsQeMDofD/K9//YuPOeYY7t69O19wwQU8btw4DgaDvG7dukbVw21x3FQXt8VxU13cFsdNdUEcvAbcFsdNdXEjJOdcLhQK8eTJk/mKK67ghQsXsiAI/Otf/zrlg7/zQ/3GjRt5xowZXFxczGvXri2oOG6qi9viuKkuiIPXAOLgNeC2OD/99BOPHDmSp02bllI+dOhQvv7661PKampq+Oabb+Zf/epXfN111/GGDRsaXRc3xXFTXdwWx011cVscN9UFcfAacFscN9XFrWQCVxNFkfr160etWrWi8ePH0xFHHEEXX3wxERHdfPPNdMQRR5AgCEREVFtbS8uXL6fVq1fTihUrqFevXgUVx011cVscN9UFcfAaQBy8BtwWR1VV2rdvH40dO5aIiAzDIFEUqVOnTrR3714iImLzB1sqLi6me+65J+W4xnJTHDfVxW1x3FQXt8VxU10QB68Bt8VxU11cq2lyflBIQqFQyvazzz7LgiDwTTfdxHv27GFmcxDqXbt2saqqvHfv3oKN46a6uC2Om+qCOHgNIA5eA26L8+WXX9rr8XicmZlvu+02vuyyy1KOcw7anM14L26K46a6uC2Om+ritjhuqgviZBfHTXVxWxw31cWN0HPuMBAMBomISNd1EkWRxo8fT8xMv/zlL0kQBJoxYwYtWLCAtmzZQk8//TSVl5cXbBw31cVtcdxUF8TBawBx8BpwW5xu3boRkfnLtKIoRGT+cr179277mN///vfk9Xpp2rRpJMuy3WPvcI3jprq4LY6b6uK2OG6qC+LgNeC2OG6qiys1VdYPCpNhGPZsKM8++ywrisLHH388y7JsD9B4qMRxU13cFsdNdUGcwo2BOIUdx011cVsc69fpW2+9lc8++2xmZv7tb3/LgiBwZWVlXmK4LY6b6uK2OG6qi9viuKkuiFO4MRCncGM0Zxw3QHLuMGQYhv0mOfPMM7mioiKjwasLKY6b6uK2OG6qC+IUbgzEKew4bqqLm+JYyb85c+bwVVddxfPnz2ev18ufffZZ3mK4LY6b6uK2OG6qi9viuKkuiFO4MRCncGM0Zxw3QHLuMKVpGt9www0sCAKvWbPmkI7jprq4LY6b6oI4hRsDcQo7jpvq4rY48+bNY0EQuLS0lD/99NMmieG2OG6qi9viuKkubovjprogTuHGQJzCjdGccQ5lSM4dpjRN48WLF/Pq1asP+Thuqovb4ripLohTuDEQp7DjuKkubovz6aefsiAIvGHDhiaL4bY4bqqL2+K4qS5ui+OmuiBO4cZAnMKN0ZxxDmUCM3NLj3sHLYOZm2XgxeaI46a6uC2Om+qCOIUbA3EKO46b6uK2OOFw2J6QAnEKJwbiFG4MxCncGIhT2HHcVBe3xXFTXQ5lSM4BAAAAAAAAAAC0ELGlHwAAAAAAAAAAAMDhCsk5AAAAAAAAAACAFoLkHAAAAAAAAAAAQAtBcg4AAAAAAAAAAKCFIDkHAAAAAAAAAADQQpCcAwAAAAAAAAAAaCFIzgEAAABAzpiZhg8fTt26daO1a9fS8OHDacuWLS39sAAAAAAKHpJzAAAAANAoH374IUmSROeee269fVu3biVJkujBBx+kyy67jMrKyqhTp04t8CgBAAAADi0CM3NLPwgAAAAAKHy/+tWvqKioiJYsWUKbNm2idu3atfRDAgAAADjkoeccAAAAABxUKBSi5557jqZOnUrnnnsuLV261N73n//8hwRBoHfeeYf69+9PgUCABg8eTJs2bUo5x0MPPURdunQhj8dDxx9/PP3tb39r5loAAAAAFB4k5wAAAADgoP7+979T9+7d6fjjj6cJEybQo48+SukXYNx6661033330apVq0iWZZo8ebK978UXX6Tp06fTjTfeSOvXr6err76aJk2aRO+++25zVwUAAACgoOCyVgAAAAA4qCFDhtC4ceNo+vTppGkatW3blp5//nkaOnQo/ec//6Gf/exn9Pbbb9OwYcOIiOi1116jc889lyKRCPl8PhoyZAidcMIJ9Ne//tU+57hx4ygcDtOrr77aUtUCAAAAaHHoOQcAAAAAB7Rp0yb65JNP6JJLLiEiIlmWafz48bRkyZKU43r37m2vt23bloiIdu/eTUREGzdupCFDhqQcP2TIENq4cWNTPnQAAACAgie39AMAAAAAgMK2ZMkS0jQtZQIIZiav10sPPvigXaYoir0uCAIRERmG0XwPFAAAAOAQhJ5zAAAAALBfmqbRE088Qffddx9VVlbatzVr1lC7du3omWeeadR5evToQStXrkwpW7lyJfXs2bMpHjYAAADAIQM95wAAAABgv1555RWqqqqiKVOmUGlpacq+MWPG0JIlS2j+/PkHPc+vf/1rGjduHPXt25eGDx9OL7/8Mi1btozefvvtpnroAAAAAIcE9JwDAAAAgP1asmQJDR8+vF5ijshMzq1atYrWrl170PNccMEF9MADD9CCBQvohBNOoIcffpgee+wxGjp0aBM8agAAAIBDB2ZrBQAAAAAAAAAAaCHoOQcAAAAAAAAAANBCkJwDAAAAAAAAAABoIUjOAQAAAAAAAAAAtBAk5wAAAAAAAAAAAFoIknMAAAAAAAAAAAAtBMk5AAAAAAAAAACAFoLkHAAAAAAAAAAAQAtBcg4AAAAAAAAAAKCFIDkHAAAAAAAAAADQQpCcAwAAAAAAAAAAaCFIzgEAAAAAAAAAALQQJOcAAAAAAAAAAABayP8Hd5w4cS7A/AIAAAAASUVORK5CYII=\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Normalizar los datos\n", + "scaler = MinMaxScaler()\n", + "scaled_data = scaler.fit_transform(grouped_data)\n", + "\n", + "# Reformatear los datos para la CNN\n", + "# Suponiendo que cada columna (región) es un 'canal' y cada fila es un punto de tiempo\n", + "X = scaled_data.reshape(scaled_data.shape[0], 1, scaled_data.shape[1])\n", + "\n", + "# Dividir en entrenamiento y prueba (usando los últimos datos para prueba)\n", + "train_size = int(X.shape[0] * 0.8)\n", + "X_train, X_test = X[:train_size, :, :], X[train_size:, :, :]\n", + "\n", + "# Generar Y (etiquetas) para los conjuntos de entrenamiento y prueba\n", + "Y_train, Y_test = X_train[:, :, :], X_test[:, :, :]" + ], + "metadata": { + "id": "9MZcbtw9t95l" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Asegúrate de que la forma de X_train sea correcta\n", + "# X_train debería tener una forma (num_samples, num_steps, num_features)\n", + "print(\"Forma de X_train:\", X_train.shape)\n" + ], + "metadata": { + "id": "jR-a5gHyQPMt", + "outputId": "84a08881-d3fc-41a1-a5fe-f915bf4aaf26", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Forma de X_train: (33, 1, 7)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Diseño de la CNN con ajustes\n", + "model = Sequential()\n", + "# Añadir regularización a la capa convolucional\n", + "model.add(Conv1D(filters=64, kernel_size=1, activation='relu', input_shape=(X_train.shape[1], X_train.shape[2]), kernel_regularizer=l1_l2(l1=0.01, l2=0.01)))\n", + "model.add(MaxPooling1D(pool_size=1))\n", + "model.add(Flatten())\n", + "# Añadir Dropout para reducir el sobreajuste\n", + "model.add(Dropout(0.5))\n", + "# Capa densa con regularización\n", + "model.add(Dense(50, activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01)))\n", + "model.add(Dense(X_train.shape[2]))\n", + "\n", + "# Compilar el modelo con un optimizador y tasa de aprendizaje ajustados\n", + "model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mse'])\n", + "\n", + "# Resumen del modelo para verificar la arquitectura\n", + "model.summary()" + ], + "metadata": { + "id": "1eAT7FatQ3_W", + "outputId": "1d80c495-eb16-4017-bee3-65c8a5c15e06", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv1d (Conv1D) (None, 1, 64) 512 \n", + " \n", + " max_pooling1d (MaxPooling1 (None, 1, 64) 0 \n", + " D) \n", + " \n", + " flatten (Flatten) (None, 64) 0 \n", + " \n", + " dropout (Dropout) (None, 64) 0 \n", + " \n", + " dense (Dense) (None, 50) 3250 \n", + " \n", + " dense_1 (Dense) (None, 7) 357 \n", + " \n", + "=================================================================\n", + "Total params: 4119 (16.09 KB)\n", + "Trainable params: 4119 (16.09 KB)\n", + "Non-trainable params: 0 (0.00 Byte)\n", + "_________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "early_stopping = EarlyStopping(monitor='val_loss', patience=100, mode='min')\n", + "history = model.fit(X_train, Y_train, epochs=500, validation_data=(X_test, Y_test), callbacks=[early_stopping], verbose=10)" + ], + "metadata": { + "id": "xros5lXUS3eR", + "outputId": "6d35db43-be9d-47dd-ad65-4e1d9411868e", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/500\n", + "Epoch 2/500\n", + "Epoch 3/500\n", + "Epoch 4/500\n", + "Epoch 5/500\n", + "Epoch 6/500\n", + "Epoch 7/500\n", + "Epoch 8/500\n", + "Epoch 9/500\n", + "Epoch 10/500\n", + "Epoch 11/500\n", + "Epoch 12/500\n", + "Epoch 13/500\n", + "Epoch 14/500\n", + "Epoch 15/500\n", + "Epoch 16/500\n", + "Epoch 17/500\n", + "Epoch 18/500\n", + "Epoch 19/500\n", + "Epoch 20/500\n", + "Epoch 21/500\n", + "Epoch 22/500\n", + "Epoch 23/500\n", + "Epoch 24/500\n", + "Epoch 25/500\n", + "Epoch 26/500\n", + "Epoch 27/500\n", + "Epoch 28/500\n", + "Epoch 29/500\n", + "Epoch 30/500\n", + "Epoch 31/500\n", + "Epoch 32/500\n", + "Epoch 33/500\n", + "Epoch 34/500\n", + "Epoch 35/500\n", + "Epoch 36/500\n", + "Epoch 37/500\n", + "Epoch 38/500\n", + "Epoch 39/500\n", + "Epoch 40/500\n", + "Epoch 41/500\n", + "Epoch 42/500\n", + "Epoch 43/500\n", + "Epoch 44/500\n", + "Epoch 45/500\n", + "Epoch 46/500\n", + "Epoch 47/500\n", + "Epoch 48/500\n", + "Epoch 49/500\n", + "Epoch 50/500\n", + "Epoch 51/500\n", + "Epoch 52/500\n", + "Epoch 53/500\n", + "Epoch 54/500\n", + "Epoch 55/500\n", + "Epoch 56/500\n", + "Epoch 57/500\n", + "Epoch 58/500\n", + "Epoch 59/500\n", + "Epoch 60/500\n", + "Epoch 61/500\n", + "Epoch 62/500\n", + "Epoch 63/500\n", + "Epoch 64/500\n", + "Epoch 65/500\n", + "Epoch 66/500\n", + "Epoch 67/500\n", + "Epoch 68/500\n", + "Epoch 69/500\n", + "Epoch 70/500\n", + "Epoch 71/500\n", + "Epoch 72/500\n", + "Epoch 73/500\n", + "Epoch 74/500\n", + "Epoch 75/500\n", + "Epoch 76/500\n", + "Epoch 77/500\n", + "Epoch 78/500\n", + "Epoch 79/500\n", + "Epoch 80/500\n", + "Epoch 81/500\n", + "Epoch 82/500\n", + "Epoch 83/500\n", + "Epoch 84/500\n", + "Epoch 85/500\n", + "Epoch 86/500\n", + "Epoch 87/500\n", + "Epoch 88/500\n", + "Epoch 89/500\n", + "Epoch 90/500\n", + "Epoch 91/500\n", + "Epoch 92/500\n", + "Epoch 93/500\n", + "Epoch 94/500\n", + "Epoch 95/500\n", + "Epoch 96/500\n", + "Epoch 97/500\n", + "Epoch 98/500\n", + "Epoch 99/500\n", + "Epoch 100/500\n", + "Epoch 101/500\n", + "Epoch 102/500\n", + "Epoch 103/500\n", + "Epoch 104/500\n", + "Epoch 105/500\n", + "Epoch 106/500\n", + "Epoch 107/500\n", + "Epoch 108/500\n", + "Epoch 109/500\n", + "Epoch 110/500\n", + "Epoch 111/500\n", + "Epoch 112/500\n", + "Epoch 113/500\n", + "Epoch 114/500\n", + "Epoch 115/500\n", + "Epoch 116/500\n", + "Epoch 117/500\n", + "Epoch 118/500\n", + "Epoch 119/500\n", + "Epoch 120/500\n", + "Epoch 121/500\n", + "Epoch 122/500\n", + "Epoch 123/500\n", + "Epoch 124/500\n", + "Epoch 125/500\n", + "Epoch 126/500\n", + "Epoch 127/500\n", + "Epoch 128/500\n", + "Epoch 129/500\n", + "Epoch 130/500\n", + "Epoch 131/500\n", + "Epoch 132/500\n", + "Epoch 133/500\n", + "Epoch 134/500\n", + "Epoch 135/500\n", + "Epoch 136/500\n", + "Epoch 137/500\n", + "Epoch 138/500\n", + "Epoch 139/500\n", + "Epoch 140/500\n", + "Epoch 141/500\n", + "Epoch 142/500\n", + "Epoch 143/500\n", + "Epoch 144/500\n", + "Epoch 145/500\n", + "Epoch 146/500\n", + "Epoch 147/500\n", + "Epoch 148/500\n", + "Epoch 149/500\n", + "Epoch 150/500\n", + "Epoch 151/500\n", + "Epoch 152/500\n", + "Epoch 153/500\n", + "Epoch 154/500\n", + "Epoch 155/500\n", + "Epoch 156/500\n", + "Epoch 157/500\n", + "Epoch 158/500\n", + "Epoch 159/500\n", + "Epoch 160/500\n", + "Epoch 161/500\n", + "Epoch 162/500\n", + "Epoch 163/500\n", + "Epoch 164/500\n", + "Epoch 165/500\n", + "Epoch 166/500\n", + "Epoch 167/500\n", + "Epoch 168/500\n", + "Epoch 169/500\n", + "Epoch 170/500\n", + "Epoch 171/500\n", + "Epoch 172/500\n", + "Epoch 173/500\n", + "Epoch 174/500\n", + "Epoch 175/500\n", + "Epoch 176/500\n", + "Epoch 177/500\n", + "Epoch 178/500\n", + "Epoch 179/500\n", + "Epoch 180/500\n", + "Epoch 181/500\n", + "Epoch 182/500\n", + "Epoch 183/500\n", + "Epoch 184/500\n", + "Epoch 185/500\n", + "Epoch 186/500\n", + "Epoch 187/500\n", + "Epoch 188/500\n", + "Epoch 189/500\n", + "Epoch 190/500\n", + "Epoch 191/500\n", + "Epoch 192/500\n", + "Epoch 193/500\n", + "Epoch 194/500\n", + "Epoch 195/500\n", + "Epoch 196/500\n", + "Epoch 197/500\n", + "Epoch 198/500\n", + "Epoch 199/500\n", + "Epoch 200/500\n", + "Epoch 201/500\n", + "Epoch 202/500\n", + "Epoch 203/500\n", + "Epoch 204/500\n", + "Epoch 205/500\n", + "Epoch 206/500\n", + "Epoch 207/500\n", + "Epoch 208/500\n", + "Epoch 209/500\n", + "Epoch 210/500\n", + "Epoch 211/500\n", + "Epoch 212/500\n", + "Epoch 213/500\n", + "Epoch 214/500\n", + "Epoch 215/500\n", + "Epoch 216/500\n", + "Epoch 217/500\n", + "Epoch 218/500\n", + "Epoch 219/500\n", + "Epoch 220/500\n", + "Epoch 221/500\n", + "Epoch 222/500\n", + "Epoch 223/500\n", + "Epoch 224/500\n", + "Epoch 225/500\n", + "Epoch 226/500\n", + "Epoch 227/500\n", + "Epoch 228/500\n", + "Epoch 229/500\n", + "Epoch 230/500\n", + "Epoch 231/500\n", + "Epoch 232/500\n", + "Epoch 233/500\n", + "Epoch 234/500\n", + "Epoch 235/500\n", + "Epoch 236/500\n", + "Epoch 237/500\n", + "Epoch 238/500\n", + "Epoch 239/500\n", + "Epoch 240/500\n", + "Epoch 241/500\n", + "Epoch 242/500\n", + "Epoch 243/500\n", + "Epoch 244/500\n", + "Epoch 245/500\n", + "Epoch 246/500\n", + "Epoch 247/500\n", + "Epoch 248/500\n", + "Epoch 249/500\n", + "Epoch 250/500\n", + "Epoch 251/500\n", + "Epoch 252/500\n", + "Epoch 253/500\n", + "Epoch 254/500\n", + "Epoch 255/500\n", + "Epoch 256/500\n", + "Epoch 257/500\n", + "Epoch 258/500\n", + "Epoch 259/500\n", + "Epoch 260/500\n", + "Epoch 261/500\n", + "Epoch 262/500\n", + "Epoch 263/500\n", + "Epoch 264/500\n", + "Epoch 265/500\n", + "Epoch 266/500\n", + "Epoch 267/500\n", + "Epoch 268/500\n", + "Epoch 269/500\n", + "Epoch 270/500\n", + "Epoch 271/500\n", + "Epoch 272/500\n", + "Epoch 273/500\n", + "Epoch 274/500\n", + "Epoch 275/500\n", + "Epoch 276/500\n", + "Epoch 277/500\n", + "Epoch 278/500\n", + "Epoch 279/500\n", + "Epoch 280/500\n", + "Epoch 281/500\n", + "Epoch 282/500\n", + "Epoch 283/500\n", + "Epoch 284/500\n", + "Epoch 285/500\n", + "Epoch 286/500\n", + "Epoch 287/500\n", + "Epoch 288/500\n", + "Epoch 289/500\n", + "Epoch 290/500\n", + "Epoch 291/500\n", + "Epoch 292/500\n", + "Epoch 293/500\n", + "Epoch 294/500\n", + "Epoch 295/500\n", + "Epoch 296/500\n", + "Epoch 297/500\n", + "Epoch 298/500\n", + "Epoch 299/500\n", + "Epoch 300/500\n", + "Epoch 301/500\n", + "Epoch 302/500\n", + "Epoch 303/500\n", + "Epoch 304/500\n", + "Epoch 305/500\n", + "Epoch 306/500\n", + "Epoch 307/500\n", + "Epoch 308/500\n", + "Epoch 309/500\n", + "Epoch 310/500\n", + "Epoch 311/500\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Visualizar el entrenamiento\n", + "plt.plot(history.history['loss'], label='train')\n", + "plt.title('Model Loss periodo Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "id": "uQuljCCiQnBd", + "outputId": "15c0864e-71e1-4fdf-e9bf-ff9661d08ad8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + } + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.plot(history.history['val_loss'], label='test')\n", + "plt.title('Model Loss periodo Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "id": "O5NpleLGSF4Q", + "outputId": "6b580f18-825b-4a8c-b5f0-b3ac81749864", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + } + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(electricity_data[\"Region\"])" + ], + "metadata": { + "id": "kT7euZcTW482" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(electricity_data.columns) # Si 2020 es una columna\n", + "print(electricity_data.index) # Si 2020 es un índice\n" + ], + "metadata": { + "id": "oDKGm3BTajlP" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "uKxrVjY4U9qL" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/proyectoIAPrediccion.ipynb b/proyectoIAPrediccion.ipynb new file mode 100644 index 0000000..3d923e0 --- /dev/null +++ b/proyectoIAPrediccion.ipynb @@ -0,0 +1,219 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyMwjdk5Ut+cy6M0j8j+tK6i", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import plotly.express as px\n", + "from wordcloud import WordCloud\n", + "import geopandas as gpd" + ], + "metadata": { + "id": "H7kZjC_GUZZd" + }, + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "id": "9_FId2wvQAgd" + }, + "outputs": [], + "source": [ + "\n", + "# Leer los datos\n", + "GES_Data = \"global_electricity_statistics_cleaned_2.csv\"\n", + "new_data = pd.read_csv(GES_Data)\n" + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Ver los primeros datos\n", + "print(data.head())\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lWY6qwmkQ2PL", + "outputId": "8b34e09a-3d35-419c-e717-996503396768" + }, + "execution_count": 25, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Country Latitude Longitude Features Region \\\n", + "0 Afghanistan 34.5328 69.1658 net generation Asia & Oceania \n", + "1 Afghanistan 34.5328 69.1658 net consumption Asia & Oceania \n", + "2 Afghanistan 34.5328 69.1658 installed capacity Asia & Oceania \n", + "3 Afghanistan 34.5328 69.1658 distribution losses Asia & Oceania \n", + "4 Afghanistan 34.5328 69.1658 imports Asia & Oceania \n", + "\n", + " 1980 1981 1982 1983 1984 ... 2012 2013 2014 \\\n", + "0 0.94200 0.99200 0.95200 1.00 1.01900 ... 0.8820 1.1034 1.1590 \n", + "1 0.87606 0.92256 0.88536 0.93 0.94767 ... 3.5490 4.2284 4.3490 \n", + "2 0.37400 0.42700 0.42700 0.45 0.45000 ... 0.5871 0.6011 0.5861 \n", + "3 0.06594 0.06944 0.06664 0.07 0.07133 ... 0.4040 0.4900 0.5200 \n", + "4 0.00000 0.00000 0.00000 0.00 0.00000 ... 3.0710 3.6150 3.7100 \n", + "\n", + " 2015 2016 2017 2018 2019 2020 2021 \n", + "0 1.1832 1.2147 1.26426 1.16493 1.07269 0.80728 0.829094 \n", + "1 4.4402 4.9577 5.26056 5.51093 5.31469 5.28916 5.530597 \n", + "2 0.5871 0.6341 0.63640 0.76740 0.77640 0.77640 0.776400 \n", + "3 0.5220 0.5900 0.61500 0.64000 0.67000 0.67000 0.666854 \n", + "4 3.7790 4.3330 4.61130 4.98600 4.91200 5.15188 5.368357 \n", + "\n", + "[5 rows x 47 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Reordenar los niveles de 'Features' en la secuencia deseada\n", + "feature_order = [\"imports\", \"exports\", \"net imports\", \"installed capacity\", \"net generation\", \"net consumption\", \"distribution losses\"]\n", + "new_data['Features'] = pd.Categorical(new_data['Features'], categories=feature_order, ordered=True)\n", + "\n", + "custom_palette = [\"red\", \"blue\", \"green\",\"purple\", \"#FF7F00\", \"cyan\", \"brown\"]\n", + "\n", + "# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\n", + "region_features = new_data.groupby(['Year', 'Region', 'Features']).agg(Total_Value=('Value', 'sum')).reset_index()\n", + "\n", + "# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "# Crear el gráfico de líneas con la paleta de colores personalizada\n", + "sns.lineplot(data=region_features, x='Year', y='Total_Value', hue='Region')\n", + "plt.title('Total Values by Region Over Time')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('Total')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 390 + }, + "id": "cYzGOiNeVfY7", + "outputId": "9c2ec83e-7518-4d20-eba9-35e2eccfada9" + }, + "execution_count": 26, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mregion_features\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Region'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0magg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTotal_Value\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Value'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sum'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36mgroupby\u001b[0;34m(self, by, axis, level, as_index, sort, group_keys, squeeze, observed, dropna)\u001b[0m\n\u001b[1;32m 8400\u001b[0m \u001b[0maxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_axis_number\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8401\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 8402\u001b[0;31m return DataFrameGroupBy(\n\u001b[0m\u001b[1;32m 8403\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8404\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/groupby.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, obj, keys, axis, level, grouper, exclusions, selection, as_index, sort, group_keys, squeeze, observed, mutated, dropna)\u001b[0m\n\u001b[1;32m 963\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrouper\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mget_grouper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 964\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 965\u001b[0;31m grouper, exclusions, obj = get_grouper(\n\u001b[0m\u001b[1;32m 966\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 967\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/grouper.py\u001b[0m in \u001b[0;36mget_grouper\u001b[0;34m(obj, key, axis, level, sort, observed, mutated, validate, dropna)\u001b[0m\n\u001b[1;32m 886\u001b[0m \u001b[0min_axis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 888\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 889\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGrouper\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkey\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 890\u001b[0m \u001b[0;31m# Add key to exclusions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "custom_palette = [\"#E41A1C\", \"#377EB8\", \"#4DAF4A\", \"#984EA3\", \"#FF7F00\", \"#FFFF33\", \"#A65628\"]\n", + "\n", + "# Filter the data for the past five years and 'exports'\n", + "export_data = new_data[(new_data['Features'] == \"exports\") & (new_data['Year'] >= (new_data['Year'].max() - 4))]\n", + "\n", + "# Group by 'Country' and calculate the total export value\n", + "top_exporting_countries = export_data.groupby('Country')['Value'].sum().reset_index().sort_values(by='Value', ascending=False).head(10)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(x='Value', y='Country', data=top_exporting_countries, palette=custom_palette)\n", + "print(top_exporting_countries)\n", + "\n", + "plt.xlabel('Total Exports')\n", + "plt.ylabel('Country')\n", + "plt.title('Exports - Last 5 Years - Top Ten Countries')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 512 + }, + "id": "pEGfENwGVhHK", + "outputId": "2dc0d837-10ef-4939-a46a-d36246f692a7" + }, + "execution_count": 27, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3801\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3802\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Filter the data for the past five years and 'exports'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mexport_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"exports\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# Group by 'Country' and calculate the total export value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3805\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3807\u001b[0;31m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3808\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3809\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3802\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3804\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3805\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;31m# If we have a listlike key, _check_indexing_error will raise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "RQfTp3HSXLqQ" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/proyectoIAPrediccion1.ipynb b/proyectoIAPrediccion1.ipynb new file mode 100644 index 0000000..63dfceb --- /dev/null +++ b/proyectoIAPrediccion1.ipynb @@ -0,0 +1,2142 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyOCDy3tr8QiViPGZS4dV1N6", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as mcolors\n", + "import matplotlib.cm as cm\n", + "import seaborn as sns\n", + "import plotly.express as px\n", + "from wordcloud import WordCloud\n", + "import geopandas as gpd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from keras.models import Sequential\n", + "from keras.layers import LSTM, GRU, Conv1D, MaxPooling1D, Flatten, Dense\n", + "from keras.losses import MeanSquaredError\n", + "from keras.regularizers import l2\n", + "\n" + ], + "metadata": { + "id": "H7kZjC_GUZZd" + }, + "execution_count": 77, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "id": "9_FId2wvQAgd" + }, + "outputs": [], + "source": [ + "# Leer los datos\n", + "GES_Data = \"global_electricity_statistics_cleaned.csv\"\n", + "df = pd.read_csv(GES_Data)" + ] + }, + { + "cell_type": "code", + "source": [ + "# Ver los primeros datos\n", + "print(df.head())\n", + "df[\"Features\"].value_counts()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lWY6qwmkQ2PL", + "outputId": "e89148ab-3b26-4467-9a79-ac3d32f733d6" + }, + "execution_count": 79, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Country Features Region 1980 1981 1982 1983 \\\n", + "0 Algeria net generation Africa 6.683 7.65 8.824 9.615 \n", + "1 Angola net generation Africa 0.905 0.906 0.995 1.028 \n", + "2 Benin net generation Africa 0.005 0.005 0.005 0.005 \n", + "3 Botswana net generation Africa 0.443 0.502 0.489 0.434 \n", + "4 Burkina Faso net generation Africa 0.098 0.108 0.115 0.117 \n", + "\n", + " 1984 1985 1986 ... 2012 2013 2014 2015 \\\n", + "0 10.537 11.569 12.214 ... 53.9845 56.3134 60.39972 64.68244 \n", + "1 1.028 1.028 1.088 ... 6.03408 7.97606 9.21666 9.30914 \n", + "2 0.005 0.005 0.005 ... 0.04612 0.08848 0.22666 0.31056 \n", + "3 0.445 0.456 0.538 ... 0.33 0.86868 2.17628 2.79104 \n", + "4 0.113 0.115 0.122 ... 0.86834 0.98268 1.11808 1.43986 \n", + "\n", + " 2016 2017 2018 2019 2020 2021 \n", + "0 66.75504 71.49546 72.10903 76.685 72.73591277 77.53072719 \n", + "1 10.203511 10.67604 12.83194 15.4 16.6 16.429392 \n", + "2 0.26004 0.3115 0.19028 0.2017 0.22608 0.24109728 \n", + "3 2.52984 2.8438 2.97076 3.0469 2.05144 2.18234816 \n", + "4 1.5509 1.64602 1.6464 1.72552 1.647133174 1.761209666 \n", + "\n", + "[5 rows x 45 columns]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "net generation 230\n", + "net consumption 230\n", + "imports 230\n", + "exports 230\n", + "net imports 230\n", + "installed capacity 230\n", + "distribution losses 230\n", + "Name: Features, dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 79 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Convertir las columnas de los años a numéricas\n", + "cols = [str(year) for year in range(1980, 2022)]\n", + "df[cols] = df[cols].apply(pd.to_numeric, errors='coerce')\n", + "\n", + "# Calcular el promedio de cada fila (ignorando los valores NaN)\n", + "df['avg'] = df.loc[:, '1980':'2021'].mean(axis=1)\n", + "\n", + "# Rellenar los valores NaN con el promedio de la fila correspondiente\n", + "for col in cols:\n", + " df[col].fillna(df['avg'], inplace=True)\n", + "\n", + "# Eliminar la columna 'avg' ya que ya no es necesaria\n", + "df.drop('avg', axis=1, inplace=True)\n", + "\n", + "# Agregar la columna 'Total' que es la suma de las columnas desde 1980 hasta 2021\n", + "df['Total'] = df.loc[:, '1980':'2021'].sum(axis=1)\n", + "\n", + "# Agrupar por 'Region' y 'Features', y obtener la suma\n", + "df_grouped = df.groupby(['Region', 'Features']).sum(numeric_only=True)\n" + ], + "metadata": { + "id": "9MZcbtw9t95l" + }, + "execution_count": 84, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "base de datos lista con regiones y caracteristicas 1980 al 2021 abajo listo falta red neuronal y entrenamiento\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "_28HoIcVTX5H" + } + }, + { + "cell_type": "code", + "source": [ + "print(df_grouped)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6wZ4FIMSDhZH", + "outputId": "77273682-c22c-41a9-fae1-a801427bd5e7" + }, + "execution_count": 81, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " 1980 1981 \\\n", + "Region Features \n", + "Africa distribution losses 1.874121e+01 20.443093 \n", + " exports 3.935375e+00 4.327375 \n", + " imports 5.659906e+00 6.051906 \n", + " installed capacity 4.814117e+01 52.983167 \n", + " net consumption 1.737664e+02 183.373190 \n", + " net generation 1.907831e+02 202.091751 \n", + " net imports 1.724531e+00 1.724531 \n", + "Asia & Oceania distribution losses 1.031399e+02 110.245063 \n", + " exports 1.190000e+00 1.158000 \n", + " imports 1.507000e+00 1.585000 \n", + " installed capacity 3.299673e+02 350.290346 \n", + " net consumption 1.162988e+03 1192.215726 \n", + " net generation 1.265811e+03 1302.033789 \n", + " net imports 3.170000e-01 0.427000 \n", + "Central & South America distribution losses 3.859152e+01 36.077525 \n", + " exports 4.380000e-01 0.590000 \n", + " imports 4.380000e-01 0.449000 \n", + " installed capacity 8.227979e+01 89.194786 \n", + " net consumption 2.705502e+02 280.515562 \n", + " net generation 3.091417e+02 316.734087 \n", + " net imports 6.938894e-18 -0.141000 \n", + "Eurasia distribution losses 2.617115e+02 262.611506 \n", + " exports 7.943247e+01 81.441472 \n", + " imports 4.476119e+01 44.761188 \n", + " installed capacity 6.222894e+02 632.202353 \n", + " net consumption 2.343170e+03 2298.454189 \n", + " net generation 2.639553e+03 2597.745980 \n", + " net imports -3.467128e+01 -36.680284 \n", + "Europe distribution losses 2.120365e+02 209.191182 \n", + " exports 2.115657e+02 220.309746 \n", + " imports 2.116504e+02 222.262370 \n", + " installed capacity 7.708206e+02 786.288617 \n", + " net consumption 2.740265e+03 2745.516068 \n", + " net generation 2.952217e+03 2952.754626 \n", + " net imports 8.462388e-02 1.952624 \n", + "Middle East distribution losses 7.515476e+00 11.216626 \n", + " exports 2.320000e-01 0.227000 \n", + " imports 4.111621e+00 4.106621 \n", + " installed capacity 3.230383e+01 38.292828 \n", + " net consumption 8.818376e+01 95.959605 \n", + " net generation 9.181961e+01 103.296610 \n", + " net imports 3.879621e+00 3.879621 \n", + "North America distribution losses 2.558195e+02 221.393494 \n", + " exports 3.466465e+01 39.482123 \n", + " imports 3.003898e+01 39.913572 \n", + " installed capacity 6.737250e+02 698.724000 \n", + " net consumption 2.461083e+03 2531.029293 \n", + " net generation 2.721528e+03 2751.991338 \n", + " net imports -4.625664e+00 0.431449 \n", + "\n", + " 1982 1983 \\\n", + "Region Features \n", + "Africa distribution losses 20.504713 22.792113 \n", + " exports 4.989375 4.251375 \n", + " imports 6.722906 6.253906 \n", + " installed capacity 53.899167 56.308967 \n", + " net consumption 189.994270 196.583670 \n", + " net generation 208.765451 217.373251 \n", + " net imports 1.733531 2.002531 \n", + "Asia & Oceania distribution losses 112.874513 121.149903 \n", + " exports 1.179000 1.265000 \n", + " imports 2.009000 2.005000 \n", + " installed capacity 368.918346 392.552346 \n", + " net consumption 1246.608115 1325.026719 \n", + " net generation 1358.652628 1445.436622 \n", + " net imports 0.830000 0.740000 \n", + "Central & South America distribution losses 42.593765 45.658395 \n", + " exports 0.475000 4.261000 \n", + " imports 0.601000 4.033000 \n", + " installed capacity 94.589786 100.067786 \n", + " net consumption 293.158242 310.713632 \n", + " net generation 335.626007 356.600027 \n", + " net imports 0.126000 -0.228000 \n", + "Eurasia distribution losses 267.411506 270.111506 \n", + " exports 82.052472 83.838472 \n", + " imports 44.761188 44.761188 \n", + " installed capacity 640.328353 649.579353 \n", + " net consumption 2408.629042 2452.972540 \n", + " net generation 2713.331833 2762.161331 \n", + " net imports -37.291284 -39.077284 \n", + "Europe distribution losses 210.397242 220.819682 \n", + " exports 216.397746 239.093746 \n", + " imports 218.558370 243.130370 \n", + " installed capacity 804.458617 817.115617 \n", + " net consumption 2757.528008 2819.162568 \n", + " net generation 2965.764626 3035.945626 \n", + " net imports 2.160624 4.036624 \n", + "Middle East distribution losses 12.716366 12.381506 \n", + " exports 0.330000 0.291000 \n", + " imports 4.209621 4.170621 \n", + " installed capacity 43.108828 48.766828 \n", + " net consumption 114.088865 128.651725 \n", + " net generation 122.925610 137.153610 \n", + " net imports 3.879621 3.879621 \n", + "North America distribution losses 227.643996 237.414793 \n", + " exports 40.319463 42.314293 \n", + " imports 40.319634 42.314038 \n", + " installed capacity 717.576000 728.127000 \n", + " net consumption 2476.041662 2555.949638 \n", + " net generation 2703.685487 2793.364686 \n", + " net imports 0.000171 -0.000255 \n", + "\n", + " 1984 1985 \\\n", + "Region Features \n", + "Africa distribution losses 24.310513 29.939433 \n", + " exports 4.594375 4.237375 \n", + " imports 6.369906 5.961906 \n", + " installed capacity 60.707967 63.234967 \n", + " net consumption 214.139970 225.634750 \n", + " net generation 236.674951 253.849651 \n", + " net imports 1.775531 1.724531 \n", + "Asia & Oceania distribution losses 126.509673 148.113229 \n", + " exports 1.696000 1.903000 \n", + " imports 2.134000 2.228000 \n", + " installed capacity 416.259346 440.239786 \n", + " net consumption 1422.219174 1498.540497 \n", + " net generation 1548.290847 1646.328726 \n", + " net imports 0.438000 0.325000 \n", + "Central & South America distribution losses 46.117535 50.984685 \n", + " exports 3.760000 5.323000 \n", + " imports 3.665000 2.648000 \n", + " installed capacity 106.934786 113.188786 \n", + " net consumption 337.728692 350.544262 \n", + " net generation 383.941227 404.203947 \n", + " net imports -0.095000 -2.675000 \n", + "Eurasia distribution losses 280.911506 288.511506 \n", + " exports 84.734472 91.332472 \n", + " imports 44.761188 46.361188 \n", + " installed capacity 659.918353 669.045353 \n", + " net consumption 2516.762419 2557.075511 \n", + " net generation 2837.647210 2890.558302 \n", + " net imports -39.973284 -44.971284 \n", + "Europe distribution losses 227.212242 239.311152 \n", + " exports 244.937746 246.803746 \n", + " imports 250.172370 257.239370 \n", + " installed capacity 842.635617 862.814617 \n", + " net consumption 2923.534008 3014.283098 \n", + " net generation 3145.511626 3243.158626 \n", + " net imports 5.234624 10.435624 \n", + "Middle East distribution losses 12.534696 14.515696 \n", + " exports 0.199000 0.328000 \n", + " imports 4.078621 4.207621 \n", + " installed capacity 53.286828 54.877828 \n", + " net consumption 143.957535 153.760535 \n", + " net generation 152.612610 164.396610 \n", + " net imports 3.879621 3.879621 \n", + "North America distribution losses 213.703069 235.735172 \n", + " exports 43.476293 47.519917 \n", + " imports 43.476432 47.458180 \n", + " installed capacity 748.786000 770.521000 \n", + " net consumption 2720.030437 2778.895211 \n", + " net generation 2933.733367 3014.692120 \n", + " net imports 0.000139 -0.061737 \n", + "\n", + " 1986 1987 \\\n", + "Region Features \n", + "Africa distribution losses 23.062873 26.468153 \n", + " exports 4.171375 2.530375 \n", + " imports 6.010906 4.454906 \n", + " installed capacity 69.761967 71.632967 \n", + " net consumption 245.635010 254.337430 \n", + " net generation 266.858351 278.881051 \n", + " net imports 1.839531 1.924531 \n", + "Asia & Oceania distribution losses 153.614063 168.974833 \n", + " exports 2.265198 2.838005 \n", + " imports 2.184701 2.737251 \n", + " installed capacity 462.890166 486.629886 \n", + " net consumption 1583.920647 1715.996800 \n", + " net generation 1737.615207 1885.072388 \n", + " net imports -0.080498 -0.100755 \n", + "Central & South America distribution losses 59.351220 65.950150 \n", + " exports 13.315000 18.816000 \n", + " imports 13.188000 18.337600 \n", + " installed capacity 117.481000 122.055000 \n", + " net consumption 375.881060 385.142790 \n", + " net generation 435.359280 451.571340 \n", + " net imports -0.127000 -0.478400 \n", + "Eurasia distribution losses 292.111506 297.411506 \n", + " exports 91.067472 95.700472 \n", + " imports 46.061188 45.661188 \n", + " installed capacity 675.670353 679.240353 \n", + " net consumption 2518.068596 2569.916228 \n", + " net generation 2855.186387 2917.367019 \n", + " net imports -45.006284 -50.039284 \n", + "Europe distribution losses 236.588012 243.415292 \n", + " exports 241.788746 255.341746 \n", + " imports 252.566370 271.346370 \n", + " installed capacity 878.766617 898.170617 \n", + " net consumption 3073.428238 3145.392958 \n", + " net generation 3299.238626 3372.803626 \n", + " net imports 10.777624 16.004624 \n", + "Middle East distribution losses 12.710696 16.239696 \n", + " exports 0.573000 0.478000 \n", + " imports 4.252621 4.191621 \n", + " installed capacity 58.097828 62.736828 \n", + " net consumption 163.961535 169.719535 \n", + " net generation 172.992610 182.245610 \n", + " net imports 3.679621 3.713621 \n", + "North America distribution losses 201.979128 210.630140 \n", + " exports 44.521565 54.824235 \n", + " imports 44.511861 54.829032 \n", + " installed capacity 783.141000 796.349000 \n", + " net consumption 2843.497120 2954.184324 \n", + " net generation 3045.485952 3164.809667 \n", + " net imports -0.009704 0.004797 \n", + "\n", + " 1988 1989 ... \\\n", + "Region Features ... \n", + "Africa distribution losses 27.225493 28.415993 ... \n", + " exports 2.427375 2.709375 ... \n", + " imports 4.419906 4.531906 ... \n", + " installed capacity 75.977967 79.771567 ... \n", + " net consumption 262.564790 271.933940 ... \n", + " net generation 287.797751 298.527401 ... \n", + " net imports 1.992531 1.822531 ... \n", + "Asia & Oceania distribution losses 178.805683 200.790531 ... \n", + " exports 3.310800 3.860101 ... \n", + " imports 3.174608 3.324543 ... \n", + " installed capacity 513.284356 536.453276 ... \n", + " net consumption 1856.190046 1977.313215 ... \n", + " net generation 2035.131922 2178.639305 ... \n", + " net imports -0.136193 -0.535558 ... \n", + "Central & South America distribution losses 67.784620 72.544900 ... \n", + " exports 19.189000 21.934000 ... \n", + " imports 19.033500 23.353000 ... \n", + " installed capacity 127.767000 130.554000 ... \n", + " net consumption 405.170040 413.088700 ... \n", + " net generation 473.110160 484.214600 ... \n", + " net imports -0.155500 1.419000 ... \n", + "Eurasia distribution losses 294.711506 296.411506 ... \n", + " exports 99.212472 98.535472 ... \n", + " imports 45.461188 45.461188 ... \n", + " installed capacity 692.645353 695.674353 ... \n", + " net consumption 2607.296149 2638.989586 ... \n", + " net generation 2955.758940 2988.475377 ... \n", + " net imports -53.751284 -53.074284 ... \n", + "Europe distribution losses 241.951762 243.408832 ... \n", + " exports 272.139746 293.217746 ... \n", + " imports 291.926370 312.685370 ... \n", + " installed capacity 908.236617 916.832617 ... \n", + " net consumption 3199.221488 3253.479218 ... \n", + " net generation 3421.386626 3477.420426 ... \n", + " net imports 19.786624 19.467624 ... \n", + "Middle East distribution losses 19.424696 19.650696 ... \n", + " exports 0.375000 0.380000 ... \n", + " imports 4.234621 4.259621 ... \n", + " installed capacity 69.399828 72.768828 ... \n", + " net consumption 189.148535 200.692535 ... \n", + " net generation 204.713610 216.463610 ... \n", + " net imports 3.859621 3.879621 ... \n", + "North America distribution losses 213.193537 278.523167 ... \n", + " exports 42.929646 39.016589 ... \n", + " imports 42.936199 39.084799 ... \n", + " installed capacity 798.026000 834.564000 ... \n", + " net consumption 3095.903194 3292.470057 ... \n", + " net generation 3309.090178 3570.925014 ... \n", + " net imports 0.006553 0.068210 ... \n", + "\n", + " 2012 2013 \\\n", + "Region Features \n", + "Africa distribution losses 90.741794 100.652074 \n", + " exports 31.560100 29.270320 \n", + " imports 39.407200 38.460900 \n", + " installed capacity 157.783510 166.204887 \n", + " net consumption 611.512095 620.559458 \n", + " net generation 695.766565 713.380728 \n", + " net imports 7.847100 9.190580 \n", + "Asia & Oceania distribution losses 678.990130 718.717462 \n", + " exports 38.076848 43.201222 \n", + " imports 48.086716 53.728922 \n", + " installed capacity 2169.864984 2330.909732 \n", + " net consumption 8227.563211 8719.145784 \n", + " net generation 8896.543473 9427.335547 \n", + " net imports 10.009868 10.527699 \n", + "Central & South America distribution losses 178.592105 183.188955 \n", + " exports 50.448000 50.482230 \n", + " imports 51.803500 51.705970 \n", + " installed capacity 296.354729 317.115300 \n", + " net consumption 1006.331172 1046.180499 \n", + " net generation 1185.825005 1230.402943 \n", + " net imports 1.355500 1.223740 \n", + "Eurasia distribution losses 290.124833 293.506833 \n", + " exports 81.157750 76.856750 \n", + " imports 28.093500 26.833500 \n", + " installed capacity 670.648753 680.877699 \n", + " net consumption 2613.014998 2608.658934 \n", + " net generation 2956.204082 2952.189018 \n", + " net imports -53.064250 -50.023250 \n", + "Europe distribution losses 312.122568 313.103557 \n", + " exports 443.876981 430.539587 \n", + " imports 461.685229 448.473861 \n", + " installed capacity 1268.886878 1286.459488 \n", + " net consumption 4021.955784 4033.031850 \n", + " net generation 4316.270104 4328.201133 \n", + " net imports 17.808248 17.934274 \n", + "Middle East distribution losses 115.204000 115.606100 \n", + " exports 16.475700 17.626000 \n", + " imports 20.749000 22.276000 \n", + " installed capacity 233.853100 253.873369 \n", + " net consumption 814.418020 859.965481 \n", + " net generation 925.348720 970.921581 \n", + " net imports 4.273300 4.650000 \n", + "North America distribution losses 332.848244 324.129033 \n", + " exports 70.976291 74.859494 \n", + " imports 72.321289 81.829801 \n", + " installed capacity 1263.275800 1260.288100 \n", + " net consumption 4620.822297 4683.045310 \n", + " net generation 4952.325543 5000.204037 \n", + " net imports 1.344998 6.970307 \n", + "\n", + " 2014 2015 \\\n", + "Region Features \n", + "Africa distribution losses 100.862683 107.622472 \n", + " exports 31.922840 34.030950 \n", + " imports 40.958282 40.208600 \n", + " installed capacity 169.635611 179.322610 \n", + " net consumption 646.013219 658.567024 \n", + " net generation 739.200236 761.371622 \n", + " net imports 9.035442 6.177650 \n", + "Asia & Oceania distribution losses 726.043045 728.905453 \n", + " exports 43.899299 46.000806 \n", + " imports 53.420703 58.622526 \n", + " installed capacity 2463.426712 2668.076439 \n", + " net consumption 9121.177292 9385.732178 \n", + " net generation 9837.698933 10102.015911 \n", + " net imports 9.521404 12.621720 \n", + "Central & South America distribution losses 195.090374 195.044023 \n", + " exports 46.755000 46.214375 \n", + " imports 48.488000 46.891300 \n", + " installed capacity 327.351239 341.688198 \n", + " net consumption 1029.599917 1064.668354 \n", + " net generation 1225.214520 1261.292682 \n", + " net imports 1.733000 0.676925 \n", + "Eurasia distribution losses 288.718833 283.011833 \n", + " exports 72.713750 68.759750 \n", + " imports 25.708500 24.632500 \n", + " installed capacity 706.369683 704.632633 \n", + " net consumption 2609.666644 2602.340334 \n", + " net generation 2945.390728 2929.479418 \n", + " net imports -47.005250 -44.127250 \n", + "Europe distribution losses 302.146616 307.118887 \n", + " exports 470.691760 499.598125 \n", + " imports 484.565844 512.493304 \n", + " installed capacity 1310.856618 1325.619640 \n", + " net consumption 3927.158554 4010.027085 \n", + " net generation 4215.431086 4304.250793 \n", + " net imports 13.874084 12.895179 \n", + "Middle East distribution losses 121.753000 136.956300 \n", + " exports 15.734300 13.304700 \n", + " imports 22.482000 24.437000 \n", + " installed capacity 267.802900 281.223764 \n", + " net consumption 921.739356 960.867656 \n", + " net generation 1036.744656 1086.691656 \n", + " net imports 6.747700 11.132300 \n", + "North America distribution losses 314.189122 319.202703 \n", + " exports 75.406872 84.372314 \n", + " imports 80.754999 88.191435 \n", + " installed capacity 1281.423800 1288.473000 \n", + " net consumption 4723.259542 4715.376861 \n", + " net generation 5032.100536 5030.760443 \n", + " net imports 5.348127 3.819121 \n", + "\n", + " 2016 2017 \\\n", + "Region Features \n", + "Africa distribution losses 120.267951 117.446872 \n", + " exports 34.692430 33.327730 \n", + " imports 41.309200 39.782764 \n", + " installed capacity 192.320816 210.921447 \n", + " net consumption 653.876644 686.573884 \n", + " net generation 768.887601 798.925498 \n", + " net imports 6.616770 6.455034 \n", + "Asia & Oceania distribution losses 762.739982 777.224502 \n", + " exports 58.194332 63.917965 \n", + " imports 65.819156 71.950994 \n", + " installed capacity 2887.051792 3072.989237 \n", + " net consumption 9870.251320 10499.360390 \n", + " net generation 10625.366477 11268.551864 \n", + " net imports 7.624824 8.033029 \n", + "Central & South America distribution losses 196.301150 196.639998 \n", + " exports 54.136813 49.679473 \n", + " imports 55.026600 51.657462 \n", + " installed capacity 362.778609 375.971286 \n", + " net consumption 1071.664743 1078.315722 \n", + " net generation 1269.333335 1275.234959 \n", + " net imports 0.889787 1.977989 \n", + "Eurasia distribution losses 282.647833 282.927833 \n", + " exports 70.614750 76.300450 \n", + " imports 19.114500 24.919500 \n", + " installed capacity 715.716686 714.825145 \n", + " net consumption 2624.207881 2632.181290 \n", + " net generation 2958.355965 2966.490074 \n", + " net imports -51.500250 -51.380950 \n", + "Europe distribution losses 306.535603 303.730092 \n", + " exports 461.683138 470.334575 \n", + " imports 479.089613 484.382843 \n", + " installed capacity 1340.532988 1366.865274 \n", + " net consumption 4075.724022 4087.731918 \n", + " net generation 4364.853150 4377.413742 \n", + " net imports 17.406475 14.048268 \n", + "Middle East distribution losses 141.557300 152.387842 \n", + " exports 14.215200 15.588800 \n", + " imports 23.822000 22.874000 \n", + " installed capacity 290.084263 296.263143 \n", + " net consumption 989.887694 1027.643852 \n", + " net generation 1121.838194 1172.746494 \n", + " net imports 9.606800 7.285200 \n", + "North America distribution losses 314.334447 306.825106 \n", + " exports 81.285189 83.214566 \n", + " imports 84.250796 77.729212 \n", + " installed capacity 1309.804900 1326.263400 \n", + " net consumption 4733.993558 4702.000202 \n", + " net generation 5045.362399 5014.310663 \n", + " net imports 2.965607 -5.485354 \n", + "\n", + " 2018 2019 \\\n", + "Region Features \n", + "Africa distribution losses 120.350344 123.135014 \n", + " exports 31.730300 36.012330 \n", + " imports 37.158895 36.120142 \n", + " installed capacity 231.117096 239.367773 \n", + " net consumption 698.793253 702.889739 \n", + " net generation 815.074778 827.276717 \n", + " net imports 5.428595 0.107812 \n", + "Asia & Oceania distribution losses 810.210076 811.441910 \n", + " exports 67.358170 69.461613 \n", + " imports 75.641028 79.321945 \n", + " installed capacity 3265.095200 3429.788250 \n", + " net consumption 11070.559832 11474.482488 \n", + " net generation 11872.487050 12276.064067 \n", + " net imports 8.282858 9.860332 \n", + "Central & South America distribution losses 199.318646 198.809974 \n", + " exports 48.688924 41.949039 \n", + " imports 49.430425 42.838501 \n", + " installed capacity 387.997173 402.208029 \n", + " net consumption 1096.508255 1099.521880 \n", + " net generation 1297.342629 1299.699622 \n", + " net imports 0.741501 0.889462 \n", + "Eurasia distribution losses 274.900433 272.615133 \n", + " exports 74.254750 73.869750 \n", + " imports 16.404700 16.388500 \n", + " installed capacity 714.917193 724.167792 \n", + " net consumption 2662.169213 2678.159241 \n", + " net generation 2994.919697 3008.255625 \n", + " net imports -57.850050 -57.481250 \n", + "Europe distribution losses 303.082485 297.535852 \n", + " exports 465.459254 464.196084 \n", + " imports 486.205733 491.142257 \n", + " installed capacity 1400.952397 1418.280092 \n", + " net consumption 4069.003190 4055.926950 \n", + " net generation 4351.339196 4326.516629 \n", + " net imports 20.746479 26.946173 \n", + "Middle East distribution losses 155.221385 165.089182 \n", + " exports 14.144000 13.858000 \n", + " imports 31.987000 44.946100 \n", + " installed capacity 298.368401 303.954947 \n", + " net consumption 1052.527842 1086.018911 \n", + " net generation 1189.906227 1220.019993 \n", + " net imports 17.843000 31.088100 \n", + "North America distribution losses 298.010523 288.822191 \n", + " exports 77.631527 83.441019 \n", + " imports 75.128295 76.293597 \n", + " installed capacity 1351.724789 1364.576789 \n", + " net consumption 4878.979091 4816.574574 \n", + " net generation 5179.492847 5112.544188 \n", + " net imports -2.503232 -7.147422 \n", + "\n", + " 2020 2021 \n", + "Region Features \n", + "Africa distribution losses 124.310329 124.988388 \n", + " exports 37.082820 37.662881 \n", + " imports 36.093690 37.648292 \n", + " installed capacity 243.532941 245.193015 \n", + " net consumption 680.388746 712.584720 \n", + " net generation 807.047981 838.947473 \n", + " net imports -0.989130 -0.014589 \n", + "Asia & Oceania distribution losses 786.911065 792.500149 \n", + " exports 75.376583 77.030618 \n", + " imports 88.089951 87.463914 \n", + " installed capacity 3680.474175 3853.457685 \n", + " net consumption 11742.523702 12665.270200 \n", + " net generation 12516.721399 13447.337052 \n", + " net imports 12.713368 10.433296 \n", + "Central & South America distribution losses 195.857514 199.680010 \n", + " exports 38.434271 38.794599 \n", + " imports 39.625489 35.477785 \n", + " installed capacity 414.911323 428.896663 \n", + " net consumption 1100.092492 1167.026170 \n", + " net generation 1297.016017 1372.280224 \n", + " net imports 1.191218 -3.316815 \n", + "Eurasia distribution losses 265.384183 263.323374 \n", + " exports 63.197350 72.384710 \n", + " imports 21.221200 26.346138 \n", + " installed capacity 733.129110 743.105110 \n", + " net consumption 2673.289939 2761.897411 \n", + " net generation 2980.650272 3071.259358 \n", + " net imports -41.976150 -46.038573 \n", + "Europe distribution losses 292.605807 294.824287 \n", + " exports 480.083713 507.242862 \n", + " imports 494.061577 529.015329 \n", + " installed capacity 1444.290822 1482.995172 \n", + " net consumption 3990.746417 4082.522458 \n", + " net generation 4269.374360 4355.574277 \n", + " net imports 13.977864 21.772468 \n", + "Middle East distribution losses 163.117147 169.089625 \n", + " exports 14.629100 14.358920 \n", + " imports 29.050000 28.806431 \n", + " installed capacity 306.974447 309.632447 \n", + " net consumption 1045.687765 1109.498530 \n", + " net generation 1194.384012 1264.140644 \n", + " net imports 14.420900 14.447511 \n", + "North America distribution losses 270.644224 296.127051 \n", + " exports 87.486172 68.009584 \n", + " imports 81.225548 71.680961 \n", + " installed capacity 1387.359489 1425.152689 \n", + " net consumption 4725.063247 4836.156431 \n", + " net generation 5001.968095 5128.612105 \n", + " net imports -6.260624 3.671377 \n", + "\n", + "[49 rows x 42 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Agrupar por 'Region' y obtener la suma de los valores\n", + "df_grouped = df.groupby('Region').sum(numeric_only=True)\n", + "\n", + "# Eliminar la columna 'Total'\n", + "df_groupedeT = df_grouped.drop(columns=['Total'])\n", + "\n", + "# Transponer el DataFrame para que los años sean las columnas y las regiones sean las filas\n", + "df_transposed = df_groupedeT.transpose()\n", + "\n", + "# Crear una figura más grande\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "\n", + "# Crear un mapa de colores\n", + "cmap = cm.get_cmap('tab10')\n", + "\n", + "# Crear un diccionario para asignar un color único a cada región\n", + "region_colors = {region: cmap(i) for i, region in enumerate(df_grouped.index.unique())}\n", + "\n", + "# Para cada región, trazar los valores a lo largo de los años\n", + "for i, (region, values) in enumerate(df_transposed.iteritems()):\n", + " ax.plot(df_transposed.index, values, label=region, color=region_colors[region])\n", + "\n", + "# Rotar las etiquetas del eje x\n", + "plt.xticks(rotation=45)\n", + "\n", + "# Añadir una leyenda fuera del gráfico\n", + "ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "\n", + "# Mostrar el gráfico\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 632 + }, + "id": "UAOFyFDLLMo-", + "outputId": "bce87c94-9834-48fc-f7f7-cc2e09897650" + }, + "execution_count": 85, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":14: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cmap = cm.get_cmap('tab10')\n", + ":20: FutureWarning: iteritems is deprecated and will be removed in a future version. Use .items instead.\n", + " for i, (region, values) in enumerate(df_transposed.iteritems()):\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Guardar el dataframe agrupado\n", + "df_grouped.to_csv('global_electricity_statistics_by_region.csv')" + ], + "metadata": { + "id": "3HyCu76yuvpS" + }, + "execution_count": 86, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Supongamos que 'df_grouped' es tu DataFrame y quieres predecir la columna '2021'\n", + "X = df_grouped.drop('2021', axis=1)\n", + "y = df_grouped['2021']\n", + "\n", + "# Dividir los datos en conjuntos de entrenamiento y prueba\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.42, random_state=45) # Puedes cambiar 'test_size' y 'random_state'\n", + "\n", + "# Crear la red LSTM\n", + "model = Sequential()\n", + "model.add(LSTM(150, activation='relu',kernel_regularizer=l2(0.1), input_shape=(X_train.shape[1], 1))) # Puedes cambiar el número de neuronas (50 aquí) y la función de activación ('relu' aquí)\n", + "model.add(Dense(1))\n", + "\n", + "# Compilar el modelo\n", + "model.compile(optimizer='adam', loss=MeanSquaredError()) # Puedes cambiar el optimizador ('adam' aquí) y la función de pérdida (MeanSquaredError aquí)\n", + "\n", + "# Ajustar el modelo a los datos de entrenamiento\n", + "history = model.fit(X_train, y_train, epochs=500, verbose=8) # Puedes cambiar el número de épocas (200 aquí)\n", + "\n", + "for i in range(len(history.history['loss'])):\n", + " print(f\"Epoch {i+1}: Loss = {history.history['loss'][i]}\")\n", + "\n", + "# Graficar la pérdida durante el entrenamiento\n", + "plt.plot(history.history['loss'])\n", + "plt.title('Model loss')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train'], loc='upper right')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "nfJrQD1i4qys", + "outputId": "0109bd7f-ecfe-485d-f633-dccdc80ec34b" + }, + "execution_count": 114, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/500\n", + "Epoch 2/500\n", + "Epoch 3/500\n", + "Epoch 4/500\n", + "Epoch 5/500\n", + "Epoch 6/500\n", + "Epoch 7/500\n", + "Epoch 8/500\n", + "Epoch 9/500\n", + "Epoch 10/500\n", + "Epoch 11/500\n", + "Epoch 12/500\n", + "Epoch 13/500\n", + "Epoch 14/500\n", + "Epoch 15/500\n", + "Epoch 16/500\n", + "Epoch 17/500\n", + "Epoch 18/500\n", + "Epoch 19/500\n", + "Epoch 20/500\n", + "Epoch 21/500\n", + "Epoch 22/500\n", + "Epoch 23/500\n", + "Epoch 24/500\n", + "Epoch 25/500\n", + "Epoch 26/500\n", + "Epoch 27/500\n", + "Epoch 28/500\n", + "Epoch 29/500\n", + "Epoch 30/500\n", + "Epoch 31/500\n", + "Epoch 32/500\n", + "Epoch 33/500\n", + "Epoch 34/500\n", + "Epoch 35/500\n", + "Epoch 36/500\n", + "Epoch 37/500\n", + "Epoch 38/500\n", + "Epoch 39/500\n", + "Epoch 40/500\n", + "Epoch 41/500\n", + "Epoch 42/500\n", + "Epoch 43/500\n", + "Epoch 44/500\n", + "Epoch 45/500\n", + "Epoch 46/500\n", + "Epoch 47/500\n", + "Epoch 48/500\n", + "Epoch 49/500\n", + "Epoch 50/500\n", + "Epoch 51/500\n", + "Epoch 52/500\n", + "Epoch 53/500\n", + "Epoch 54/500\n", + "Epoch 55/500\n", + "Epoch 56/500\n", + "Epoch 57/500\n", + "Epoch 58/500\n", + "Epoch 59/500\n", + "Epoch 60/500\n", + "Epoch 61/500\n", + "Epoch 62/500\n", + "Epoch 63/500\n", + "Epoch 64/500\n", + "Epoch 65/500\n", + "Epoch 66/500\n", + "Epoch 67/500\n", + "Epoch 68/500\n", + "Epoch 69/500\n", + "Epoch 70/500\n", + "Epoch 71/500\n", + "Epoch 72/500\n", + "Epoch 73/500\n", + "Epoch 74/500\n", + "Epoch 75/500\n", + "Epoch 76/500\n", + "Epoch 77/500\n", + "Epoch 78/500\n", + "Epoch 79/500\n", + "Epoch 80/500\n", + "Epoch 81/500\n", + "Epoch 82/500\n", + "Epoch 83/500\n", + "Epoch 84/500\n", + "Epoch 85/500\n", + "Epoch 86/500\n", + "Epoch 87/500\n", + "Epoch 88/500\n", + "Epoch 89/500\n", + "Epoch 90/500\n", + "Epoch 91/500\n", + "Epoch 92/500\n", + "Epoch 93/500\n", + "Epoch 94/500\n", + "Epoch 95/500\n", + "Epoch 96/500\n", + "Epoch 97/500\n", + "Epoch 98/500\n", + "Epoch 99/500\n", + "Epoch 100/500\n", + "Epoch 101/500\n", + "Epoch 102/500\n", + "Epoch 103/500\n", + "Epoch 104/500\n", + "Epoch 105/500\n", + "Epoch 106/500\n", + "Epoch 107/500\n", + "Epoch 108/500\n", + "Epoch 109/500\n", + "Epoch 110/500\n", + "Epoch 111/500\n", + "Epoch 112/500\n", + "Epoch 113/500\n", + "Epoch 114/500\n", + "Epoch 115/500\n", + "Epoch 116/500\n", + "Epoch 117/500\n", + "Epoch 118/500\n", + "Epoch 119/500\n", + "Epoch 120/500\n", + "Epoch 121/500\n", + "Epoch 122/500\n", + "Epoch 123/500\n", + "Epoch 124/500\n", + "Epoch 125/500\n", + "Epoch 126/500\n", + "Epoch 127/500\n", + "Epoch 128/500\n", + "Epoch 129/500\n", + "Epoch 130/500\n", + "Epoch 131/500\n", + "Epoch 132/500\n", + "Epoch 133/500\n", + "Epoch 134/500\n", + "Epoch 135/500\n", + "Epoch 136/500\n", + "Epoch 137/500\n", + "Epoch 138/500\n", + "Epoch 139/500\n", + "Epoch 140/500\n", + "Epoch 141/500\n", + "Epoch 142/500\n", + "Epoch 143/500\n", + "Epoch 144/500\n", + "Epoch 145/500\n", + "Epoch 146/500\n", + "Epoch 147/500\n", + "Epoch 148/500\n", + "Epoch 149/500\n", + "Epoch 150/500\n", + "Epoch 151/500\n", + "Epoch 152/500\n", + "Epoch 153/500\n", + "Epoch 154/500\n", + "Epoch 155/500\n", + "Epoch 156/500\n", + "Epoch 157/500\n", + "Epoch 158/500\n", + "Epoch 159/500\n", + "Epoch 160/500\n", + "Epoch 161/500\n", + "Epoch 162/500\n", + "Epoch 163/500\n", + "Epoch 164/500\n", + "Epoch 165/500\n", + "Epoch 166/500\n", + "Epoch 167/500\n", + "Epoch 168/500\n", + "Epoch 169/500\n", + "Epoch 170/500\n", + "Epoch 171/500\n", + "Epoch 172/500\n", + "Epoch 173/500\n", + "Epoch 174/500\n", + "Epoch 175/500\n", + "Epoch 176/500\n", + "Epoch 177/500\n", + "Epoch 178/500\n", + "Epoch 179/500\n", + "Epoch 180/500\n", + "Epoch 181/500\n", + "Epoch 182/500\n", + "Epoch 183/500\n", + "Epoch 184/500\n", + "Epoch 185/500\n", + "Epoch 186/500\n", + "Epoch 187/500\n", + "Epoch 188/500\n", + "Epoch 189/500\n", + "Epoch 190/500\n", + "Epoch 191/500\n", + "Epoch 192/500\n", + "Epoch 193/500\n", + "Epoch 194/500\n", + "Epoch 195/500\n", + "Epoch 196/500\n", + "Epoch 197/500\n", + "Epoch 198/500\n", + "Epoch 199/500\n", + "Epoch 200/500\n", + "Epoch 201/500\n", + "Epoch 202/500\n", + "Epoch 203/500\n", + "Epoch 204/500\n", + "Epoch 205/500\n", + "Epoch 206/500\n", + "Epoch 207/500\n", + "Epoch 208/500\n", + "Epoch 209/500\n", + "Epoch 210/500\n", + "Epoch 211/500\n", + "Epoch 212/500\n", + "Epoch 213/500\n", + "Epoch 214/500\n", + "Epoch 215/500\n", + "Epoch 216/500\n", + "Epoch 217/500\n", + "Epoch 218/500\n", + "Epoch 219/500\n", + "Epoch 220/500\n", + "Epoch 221/500\n", + "Epoch 222/500\n", + "Epoch 223/500\n", + "Epoch 224/500\n", + "Epoch 225/500\n", + "Epoch 226/500\n", + "Epoch 227/500\n", + "Epoch 228/500\n", + "Epoch 229/500\n", + "Epoch 230/500\n", + "Epoch 231/500\n", + "Epoch 232/500\n", + "Epoch 233/500\n", + "Epoch 234/500\n", + "Epoch 235/500\n", + "Epoch 236/500\n", + "Epoch 237/500\n", + "Epoch 238/500\n", + "Epoch 239/500\n", + "Epoch 240/500\n", + "Epoch 241/500\n", + "Epoch 242/500\n", + "Epoch 243/500\n", + "Epoch 244/500\n", + "Epoch 245/500\n", + "Epoch 246/500\n", + "Epoch 247/500\n", + "Epoch 248/500\n", + "Epoch 249/500\n", + "Epoch 250/500\n", + "Epoch 251/500\n", + "Epoch 252/500\n", + "Epoch 253/500\n", + "Epoch 254/500\n", + "Epoch 255/500\n", + "Epoch 256/500\n", + "Epoch 257/500\n", + "Epoch 258/500\n", + "Epoch 259/500\n", + "Epoch 260/500\n", + "Epoch 261/500\n", + "Epoch 262/500\n", + "Epoch 263/500\n", + "Epoch 264/500\n", + "Epoch 265/500\n", + "Epoch 266/500\n", + "Epoch 267/500\n", + "Epoch 268/500\n", + "Epoch 269/500\n", + "Epoch 270/500\n", + "Epoch 271/500\n", + "Epoch 272/500\n", + "Epoch 273/500\n", + "Epoch 274/500\n", + "Epoch 275/500\n", + "Epoch 276/500\n", + "Epoch 277/500\n", + "Epoch 278/500\n", + "Epoch 279/500\n", + "Epoch 280/500\n", + "Epoch 281/500\n", + "Epoch 282/500\n", + "Epoch 283/500\n", + "Epoch 284/500\n", + "Epoch 285/500\n", + "Epoch 286/500\n", + "Epoch 287/500\n", + "Epoch 288/500\n", + "Epoch 289/500\n", + "Epoch 290/500\n", + "Epoch 291/500\n", + "Epoch 292/500\n", + "Epoch 293/500\n", + "Epoch 294/500\n", + "Epoch 295/500\n", + "Epoch 296/500\n", + "Epoch 297/500\n", + "Epoch 298/500\n", + "Epoch 299/500\n", + "Epoch 300/500\n", + "Epoch 301/500\n", + "Epoch 302/500\n", + "Epoch 303/500\n", + "Epoch 304/500\n", + "Epoch 305/500\n", + "Epoch 306/500\n", + "Epoch 307/500\n", + "Epoch 308/500\n", + "Epoch 309/500\n", + "Epoch 310/500\n", + "Epoch 311/500\n", + "Epoch 312/500\n", + "Epoch 313/500\n", + "Epoch 314/500\n", + "Epoch 315/500\n", + "Epoch 316/500\n", + "Epoch 317/500\n", + "Epoch 318/500\n", + "Epoch 319/500\n", + "Epoch 320/500\n", + "Epoch 321/500\n", + "Epoch 322/500\n", + "Epoch 323/500\n", + "Epoch 324/500\n", + "Epoch 325/500\n", + "Epoch 326/500\n", + "Epoch 327/500\n", + "Epoch 328/500\n", + "Epoch 329/500\n", + "Epoch 330/500\n", + "Epoch 331/500\n", + "Epoch 332/500\n", + "Epoch 333/500\n", + "Epoch 334/500\n", + "Epoch 335/500\n", + "Epoch 336/500\n", + "Epoch 337/500\n", + "Epoch 338/500\n", + "Epoch 339/500\n", + "Epoch 340/500\n", + "Epoch 341/500\n", + "Epoch 342/500\n", + "Epoch 343/500\n", + "Epoch 344/500\n", + "Epoch 345/500\n", + "Epoch 346/500\n", + "Epoch 347/500\n", + "Epoch 348/500\n", + "Epoch 349/500\n", + "Epoch 350/500\n", + "Epoch 351/500\n", + "Epoch 352/500\n", + "Epoch 353/500\n", + "Epoch 354/500\n", + "Epoch 355/500\n", + "Epoch 356/500\n", + "Epoch 357/500\n", + "Epoch 358/500\n", + "Epoch 359/500\n", + "Epoch 360/500\n", + "Epoch 361/500\n", + "Epoch 362/500\n", + "Epoch 363/500\n", + "Epoch 364/500\n", + "Epoch 365/500\n", + "Epoch 366/500\n", + "Epoch 367/500\n", + "Epoch 368/500\n", + "Epoch 369/500\n", + "Epoch 370/500\n", + "Epoch 371/500\n", + "Epoch 372/500\n", + "Epoch 373/500\n", + "Epoch 374/500\n", + "Epoch 375/500\n", + "Epoch 376/500\n", + "Epoch 377/500\n", + "Epoch 378/500\n", + "Epoch 379/500\n", + "Epoch 380/500\n", + "Epoch 381/500\n", + "Epoch 382/500\n", + "Epoch 383/500\n", + "Epoch 384/500\n", + "Epoch 385/500\n", + "Epoch 386/500\n", + "Epoch 387/500\n", + "Epoch 388/500\n", + "Epoch 389/500\n", + "Epoch 390/500\n", + "Epoch 391/500\n", + "Epoch 392/500\n", + "Epoch 393/500\n", + "Epoch 394/500\n", + "Epoch 395/500\n", + "Epoch 396/500\n", + "Epoch 397/500\n", + "Epoch 398/500\n", + "Epoch 399/500\n", + "Epoch 400/500\n", + "Epoch 401/500\n", + "Epoch 402/500\n", + "Epoch 403/500\n", + "Epoch 404/500\n", + "Epoch 405/500\n", + "Epoch 406/500\n", + "Epoch 407/500\n", + "Epoch 408/500\n", + "Epoch 409/500\n", + "Epoch 410/500\n", + "Epoch 411/500\n", + "Epoch 412/500\n", + "Epoch 413/500\n", + "Epoch 414/500\n", + "Epoch 415/500\n", + "Epoch 416/500\n", + "Epoch 417/500\n", + "Epoch 418/500\n", + "Epoch 419/500\n", + "Epoch 420/500\n", + "Epoch 421/500\n", + "Epoch 422/500\n", + "Epoch 423/500\n", + "Epoch 424/500\n", + "Epoch 425/500\n", + "Epoch 426/500\n", + "Epoch 427/500\n", + "Epoch 428/500\n", + "Epoch 429/500\n", + "Epoch 430/500\n", + "Epoch 431/500\n", + "Epoch 432/500\n", + "Epoch 433/500\n", + "Epoch 434/500\n", + "Epoch 435/500\n", + "Epoch 436/500\n", + "Epoch 437/500\n", + "Epoch 438/500\n", + "Epoch 439/500\n", + "Epoch 440/500\n", + "Epoch 441/500\n", + "Epoch 442/500\n", + "Epoch 443/500\n", + "Epoch 444/500\n", + "Epoch 445/500\n", + "Epoch 446/500\n", + "Epoch 447/500\n", + "Epoch 448/500\n", + "Epoch 449/500\n", + "Epoch 450/500\n", + "Epoch 451/500\n", + "Epoch 452/500\n", + "Epoch 453/500\n", + "Epoch 454/500\n", + "Epoch 455/500\n", + "Epoch 456/500\n", + "Epoch 457/500\n", + "Epoch 458/500\n", + "Epoch 459/500\n", + "Epoch 460/500\n", + "Epoch 461/500\n", + "Epoch 462/500\n", + "Epoch 463/500\n", + "Epoch 464/500\n", + "Epoch 465/500\n", + "Epoch 466/500\n", + "Epoch 467/500\n", + "Epoch 468/500\n", + "Epoch 469/500\n", + "Epoch 470/500\n", + "Epoch 471/500\n", + "Epoch 472/500\n", + "Epoch 473/500\n", + "Epoch 474/500\n", + "Epoch 475/500\n", + "Epoch 476/500\n", + "Epoch 477/500\n", + "Epoch 478/500\n", + "Epoch 479/500\n", + "Epoch 480/500\n", + "Epoch 481/500\n", + "Epoch 482/500\n", + "Epoch 483/500\n", + "Epoch 484/500\n", + "Epoch 485/500\n", + "Epoch 486/500\n", + "Epoch 487/500\n", + "Epoch 488/500\n", + "Epoch 489/500\n", + "Epoch 490/500\n", + "Epoch 491/500\n", + "Epoch 492/500\n", + "Epoch 493/500\n", + "Epoch 494/500\n", + "Epoch 495/500\n", + "Epoch 496/500\n", + "Epoch 497/500\n", + "Epoch 498/500\n", + "Epoch 499/500\n", + "Epoch 500/500\n", + "Epoch 1: Loss = 102832000.0\n", + "Epoch 2: Loss = 28581594.0\n", + "Epoch 3: Loss = 38466356.0\n", + "Epoch 4: Loss = 11858119.0\n", + "Epoch 5: Loss = 28559066.0\n", + "Epoch 6: Loss = 8444905.0\n", + "Epoch 7: Loss = 20377050.0\n", + "Epoch 8: Loss = 9812851.0\n", + "Epoch 9: Loss = 29177000.0\n", + "Epoch 10: Loss = 8028653.5\n", + "Epoch 11: Loss = 13237634.0\n", + "Epoch 12: Loss = 22082724.0\n", + "Epoch 13: Loss = 124183480.0\n", + "Epoch 14: Loss = 139594432.0\n", + "Epoch 15: Loss = 28150334.0\n", + "Epoch 16: Loss = 62225272.0\n", + "Epoch 17: Loss = 58199332.0\n", + "Epoch 18: Loss = 65592624.0\n", + "Epoch 19: Loss = 43185248.0\n", + "Epoch 20: Loss = 1464006.5\n", + "Epoch 21: Loss = 48347900.0\n", + "Epoch 22: Loss = 64234732.0\n", + "Epoch 23: Loss = 52944504.0\n", + "Epoch 24: Loss = 28143280.0\n", + "Epoch 25: Loss = 107148008.0\n", + "Epoch 26: Loss = 246287232.0\n", + "Epoch 27: Loss = 362880256.0\n", + "Epoch 28: Loss = 94853680.0\n", + "Epoch 29: Loss = 360159104.0\n", + "Epoch 30: Loss = 323046208.0\n", + "Epoch 31: Loss = 451675040.0\n", + "Epoch 32: Loss = 464746720.0\n", + "Epoch 33: Loss = 181614256.0\n", + "Epoch 34: Loss = 1016295040.0\n", + "Epoch 35: Loss = 48944064.0\n", + "Epoch 36: Loss = 537670912.0\n", + "Epoch 37: Loss = 183015648.0\n", + "Epoch 38: Loss = 36896788.0\n", + "Epoch 39: Loss = 208437264.0\n", + "Epoch 40: Loss = 404825856.0\n", + "Epoch 41: Loss = 145038928.0\n", + "Epoch 42: Loss = 90906088.0\n", + "Epoch 43: Loss = 317433088.0\n", + "Epoch 44: Loss = 207606352.0\n", + "Epoch 45: Loss = 67569608.0\n", + "Epoch 46: Loss = 248813776.0\n", + "Epoch 47: Loss = 28989996.0\n", + "Epoch 48: Loss = 152745104.0\n", + "Epoch 49: Loss = 378671104.0\n", + "Epoch 50: Loss = 67719336.0\n", + "Epoch 51: Loss = 58827168.0\n", + "Epoch 52: Loss = 44643036.0\n", + "Epoch 53: Loss = 17336574.0\n", + "Epoch 54: Loss = 44304728.0\n", + "Epoch 55: Loss = 62798080.0\n", + "Epoch 56: Loss = 16528823.0\n", + "Epoch 57: Loss = 7602400.0\n", + "Epoch 58: Loss = 27509160.0\n", + "Epoch 59: Loss = 45870420.0\n", + "Epoch 60: Loss = 3016445.25\n", + "Epoch 61: Loss = 37617712.0\n", + "Epoch 62: Loss = 539786.4375\n", + "Epoch 63: Loss = 6469420.5\n", + "Epoch 64: Loss = 5883493.0\n", + "Epoch 65: Loss = 9921310.0\n", + "Epoch 66: Loss = 40837956.0\n", + "Epoch 67: Loss = 28660466.0\n", + "Epoch 68: Loss = 25806316.0\n", + "Epoch 69: Loss = 1407943.875\n", + "Epoch 70: Loss = 26945542.0\n", + "Epoch 71: Loss = 65294368.0\n", + "Epoch 72: Loss = 41522256.0\n", + "Epoch 73: Loss = 50687172.0\n", + "Epoch 74: Loss = 10233583.0\n", + "Epoch 75: Loss = 50585760.0\n", + "Epoch 76: Loss = 5199648.5\n", + "Epoch 77: Loss = 28636404.0\n", + "Epoch 78: Loss = 5874281.5\n", + "Epoch 79: Loss = 20629022.0\n", + "Epoch 80: Loss = 13411407.0\n", + "Epoch 81: Loss = 6462674.0\n", + "Epoch 82: Loss = 36192340.0\n", + "Epoch 83: Loss = 39421420.0\n", + "Epoch 84: Loss = 11029152.0\n", + "Epoch 85: Loss = 13814310.0\n", + "Epoch 86: Loss = 2058303.625\n", + "Epoch 87: Loss = 21444492.0\n", + "Epoch 88: Loss = 60458524.0\n", + "Epoch 89: Loss = 946386.125\n", + "Epoch 90: Loss = 727960.6875\n", + "Epoch 91: Loss = 4561388.0\n", + "Epoch 92: Loss = 11874139.0\n", + "Epoch 93: Loss = 32916434.0\n", + "Epoch 94: Loss = 58273708.0\n", + "Epoch 95: Loss = 170226112.0\n", + "Epoch 96: Loss = 25728500.0\n", + "Epoch 97: Loss = 14353096.0\n", + "Epoch 98: Loss = 29355582.0\n", + "Epoch 99: Loss = 9882171.0\n", + "Epoch 100: Loss = 21905370.0\n", + "Epoch 101: Loss = 9851736.0\n", + "Epoch 102: Loss = 41945844.0\n", + "Epoch 103: Loss = 7750540.0\n", + "Epoch 104: Loss = 14483188.0\n", + "Epoch 105: Loss = 24603462.0\n", + "Epoch 106: Loss = 10265312.0\n", + "Epoch 107: Loss = 14629091.0\n", + "Epoch 108: Loss = 13545599.0\n", + "Epoch 109: Loss = 89341056.0\n", + "Epoch 110: Loss = 131173144.0\n", + "Epoch 111: Loss = 124960984.0\n", + "Epoch 112: Loss = 10596631.0\n", + "Epoch 113: Loss = 31328620.0\n", + "Epoch 114: Loss = 23911078.0\n", + "Epoch 115: Loss = 508030592.0\n", + "Epoch 116: Loss = 4951201.5\n", + "Epoch 117: Loss = 161397488.0\n", + "Epoch 118: Loss = 165640304.0\n", + "Epoch 119: Loss = 1637081600.0\n", + "Epoch 120: Loss = 4162158592.0\n", + "Epoch 121: Loss = 103552992.0\n", + "Epoch 122: Loss = 1941750784.0\n", + "Epoch 123: Loss = 939500736.0\n", + "Epoch 124: Loss = 2160167936.0\n", + "Epoch 125: Loss = 504996992.0\n", + "Epoch 126: Loss = 1218859776.0\n", + "Epoch 127: Loss = 188687232.0\n", + "Epoch 128: Loss = 1326811264.0\n", + "Epoch 129: Loss = 546000000.0\n", + "Epoch 130: Loss = 652817216.0\n", + "Epoch 131: Loss = 798477184.0\n", + "Epoch 132: Loss = 385249184.0\n", + "Epoch 133: Loss = 293815104.0\n", + "Epoch 134: Loss = 876512448.0\n", + "Epoch 135: Loss = 2855535104.0\n", + "Epoch 136: Loss = 554518656.0\n", + "Epoch 137: Loss = 176193920.0\n", + "Epoch 138: Loss = 455097728.0\n", + "Epoch 139: Loss = 38599364.0\n", + "Epoch 140: Loss = 24551452.0\n", + "Epoch 141: Loss = 110513104.0\n", + "Epoch 142: Loss = 110353048.0\n", + "Epoch 143: Loss = 460856768.0\n", + "Epoch 144: Loss = 292320032.0\n", + "Epoch 145: Loss = 447717472.0\n", + "Epoch 146: Loss = 517735072.0\n", + "Epoch 147: Loss = 230246288.0\n", + "Epoch 148: Loss = 74563280.0\n", + "Epoch 149: Loss = 223070800.0\n", + "Epoch 150: Loss = 143589808.0\n", + "Epoch 151: Loss = 138108752.0\n", + "Epoch 152: Loss = 24285336.0\n", + "Epoch 153: Loss = 109380440.0\n", + "Epoch 154: Loss = 59204900.0\n", + "Epoch 155: Loss = 45474664.0\n", + "Epoch 156: Loss = 21519894.0\n", + "Epoch 157: Loss = 9749383.0\n", + "Epoch 158: Loss = 98707960.0\n", + "Epoch 159: Loss = 38516540.0\n", + "Epoch 160: Loss = 117907128.0\n", + "Epoch 161: Loss = 18668372.0\n", + "Epoch 162: Loss = 23324586.0\n", + "Epoch 163: Loss = 16186311.0\n", + "Epoch 164: Loss = 132299872.0\n", + "Epoch 165: Loss = 4137220.5\n", + "Epoch 166: Loss = 32669248.0\n", + "Epoch 167: Loss = 9175897.0\n", + "Epoch 168: Loss = 34163052.0\n", + "Epoch 169: Loss = 23097474.0\n", + "Epoch 170: Loss = 51617992.0\n", + "Epoch 171: Loss = 11813448.0\n", + "Epoch 172: Loss = 41611636.0\n", + "Epoch 173: Loss = 30317978.0\n", + "Epoch 174: Loss = 17387690.0\n", + "Epoch 175: Loss = 3900669.75\n", + "Epoch 176: Loss = 3561742.25\n", + "Epoch 177: Loss = 5969533.0\n", + "Epoch 178: Loss = 117700544.0\n", + "Epoch 179: Loss = 5149296.0\n", + "Epoch 180: Loss = 9947249.0\n", + "Epoch 181: Loss = 46528292.0\n", + "Epoch 182: Loss = 39733124.0\n", + "Epoch 183: Loss = 19441794.0\n", + "Epoch 184: Loss = 8988196.0\n", + "Epoch 185: Loss = 18157304.0\n", + "Epoch 186: Loss = 7252877.5\n", + "Epoch 187: Loss = 41503044.0\n", + "Epoch 188: Loss = 26564140.0\n", + "Epoch 189: Loss = 33145384.0\n", + "Epoch 190: Loss = 24849360.0\n", + "Epoch 191: Loss = 19266568.0\n", + "Epoch 192: Loss = 18558142.0\n", + "Epoch 193: Loss = 68987280.0\n", + "Epoch 194: Loss = 41996672.0\n", + "Epoch 195: Loss = 93667328.0\n", + "Epoch 196: Loss = 893685.625\n", + "Epoch 197: Loss = 67667520.0\n", + "Epoch 198: Loss = 66997572.0\n", + "Epoch 199: Loss = 71625176.0\n", + "Epoch 200: Loss = 95644632.0\n", + "Epoch 201: Loss = 50191872.0\n", + "Epoch 202: Loss = 34075780.0\n", + "Epoch 203: Loss = 73167832.0\n", + "Epoch 204: Loss = 27575636.0\n", + "Epoch 205: Loss = 35330876.0\n", + "Epoch 206: Loss = 22916410.0\n", + "Epoch 207: Loss = 24282562.0\n", + "Epoch 208: Loss = 49295748.0\n", + "Epoch 209: Loss = 47714040.0\n", + "Epoch 210: Loss = 45224276.0\n", + "Epoch 211: Loss = 101702608.0\n", + "Epoch 212: Loss = 60757964.0\n", + "Epoch 213: Loss = 99960848.0\n", + "Epoch 214: Loss = 14283336.0\n", + "Epoch 215: Loss = 16283412.0\n", + "Epoch 216: Loss = 9840116.0\n", + "Epoch 217: Loss = 14328882.0\n", + "Epoch 218: Loss = 118184336.0\n", + "Epoch 219: Loss = 84319664.0\n", + "Epoch 220: Loss = 45551916.0\n", + "Epoch 221: Loss = 235838464.0\n", + "Epoch 222: Loss = 172541184.0\n", + "Epoch 223: Loss = 7404227.5\n", + "Epoch 224: Loss = 6032476.0\n", + "Epoch 225: Loss = 33620356.0\n", + "Epoch 226: Loss = 58161032.0\n", + "Epoch 227: Loss = 6120454.0\n", + "Epoch 228: Loss = 2004220.875\n", + "Epoch 229: Loss = 657080.8125\n", + "Epoch 230: Loss = 5642705.0\n", + "Epoch 231: Loss = 4763228.0\n", + "Epoch 232: Loss = 31776292.0\n", + "Epoch 233: Loss = 65007488.0\n", + "Epoch 234: Loss = 77484584.0\n", + "Epoch 235: Loss = 3585655.25\n", + "Epoch 236: Loss = 17067364.0\n", + "Epoch 237: Loss = 9166650.0\n", + "Epoch 238: Loss = 8339791.0\n", + "Epoch 239: Loss = 14555955.0\n", + "Epoch 240: Loss = 40074312.0\n", + "Epoch 241: Loss = 23534336.0\n", + "Epoch 242: Loss = 4477015.0\n", + "Epoch 243: Loss = 31477884.0\n", + "Epoch 244: Loss = 10155824.0\n", + "Epoch 245: Loss = 11160846.0\n", + "Epoch 246: Loss = 13042034.0\n", + "Epoch 247: Loss = 2841601.75\n", + "Epoch 248: Loss = 43013616.0\n", + "Epoch 249: Loss = 7460937.0\n", + "Epoch 250: Loss = 30927802.0\n", + "Epoch 251: Loss = 12506443.0\n", + "Epoch 252: Loss = 15761238.0\n", + "Epoch 253: Loss = 9420556.0\n", + "Epoch 254: Loss = 10614524.0\n", + "Epoch 255: Loss = 41148184.0\n", + "Epoch 256: Loss = 9866906.0\n", + "Epoch 257: Loss = 6530872.0\n", + "Epoch 258: Loss = 5475881.5\n", + "Epoch 259: Loss = 4417406.5\n", + "Epoch 260: Loss = 8015231.5\n", + "Epoch 261: Loss = 19830106.0\n", + "Epoch 262: Loss = 34233740.0\n", + "Epoch 263: Loss = 33586196.0\n", + "Epoch 264: Loss = 56163200.0\n", + "Epoch 265: Loss = 72808664.0\n", + "Epoch 266: Loss = 37919452.0\n", + "Epoch 267: Loss = 90733528.0\n", + "Epoch 268: Loss = 3429886.25\n", + "Epoch 269: Loss = 44704472.0\n", + "Epoch 270: Loss = 15747013.0\n", + "Epoch 271: Loss = 28768746.0\n", + "Epoch 272: Loss = 32492992.0\n", + "Epoch 273: Loss = 27031230.0\n", + "Epoch 274: Loss = 21846418.0\n", + "Epoch 275: Loss = 4649849.0\n", + "Epoch 276: Loss = 7733873.5\n", + "Epoch 277: Loss = 13470125.0\n", + "Epoch 278: Loss = 10613280.0\n", + "Epoch 279: Loss = 36575448.0\n", + "Epoch 280: Loss = 19551678.0\n", + "Epoch 281: Loss = 17854220.0\n", + "Epoch 282: Loss = 15834977.0\n", + "Epoch 283: Loss = 32908400.0\n", + "Epoch 284: Loss = 13467092.0\n", + "Epoch 285: Loss = 14299426.0\n", + "Epoch 286: Loss = 10788824.0\n", + "Epoch 287: Loss = 10841810.0\n", + "Epoch 288: Loss = 58854748.0\n", + "Epoch 289: Loss = 60941764.0\n", + "Epoch 290: Loss = 61065320.0\n", + "Epoch 291: Loss = 33045146.0\n", + "Epoch 292: Loss = 32921238.0\n", + "Epoch 293: Loss = 34047964.0\n", + "Epoch 294: Loss = 35546632.0\n", + "Epoch 295: Loss = 33580868.0\n", + "Epoch 296: Loss = 31460306.0\n", + "Epoch 297: Loss = 48280976.0\n", + "Epoch 298: Loss = 12115497.0\n", + "Epoch 299: Loss = 7208291.5\n", + "Epoch 300: Loss = 1766983.0\n", + "Epoch 301: Loss = 6763603.0\n", + "Epoch 302: Loss = 11206675.0\n", + "Epoch 303: Loss = 9650744.0\n", + "Epoch 304: Loss = 25572510.0\n", + "Epoch 305: Loss = 9444142.0\n", + "Epoch 306: Loss = 11093033.0\n", + "Epoch 307: Loss = 10070954.0\n", + "Epoch 308: Loss = 59487976.0\n", + "Epoch 309: Loss = 41377592.0\n", + "Epoch 310: Loss = 27515682.0\n", + "Epoch 311: Loss = 63783832.0\n", + "Epoch 312: Loss = 19595784.0\n", + "Epoch 313: Loss = 4278891.5\n", + "Epoch 314: Loss = 7336858.5\n", + "Epoch 315: Loss = 124383816.0\n", + "Epoch 316: Loss = 21640474.0\n", + "Epoch 317: Loss = 176682096.0\n", + "Epoch 318: Loss = 169359104.0\n", + "Epoch 319: Loss = 217748176.0\n", + "Epoch 320: Loss = 213649504.0\n", + "Epoch 321: Loss = 11420248.0\n", + "Epoch 322: Loss = 20710246.0\n", + "Epoch 323: Loss = 28334560.0\n", + "Epoch 324: Loss = 31568188.0\n", + "Epoch 325: Loss = 82415568.0\n", + "Epoch 326: Loss = 105856440.0\n", + "Epoch 327: Loss = 43879480.0\n", + "Epoch 328: Loss = 27950824.0\n", + "Epoch 329: Loss = 10049555.0\n", + "Epoch 330: Loss = 17207532.0\n", + "Epoch 331: Loss = 15334850.0\n", + "Epoch 332: Loss = 75185920.0\n", + "Epoch 333: Loss = 2053800.125\n", + "Epoch 334: Loss = 3618750.25\n", + "Epoch 335: Loss = 27956748.0\n", + "Epoch 336: Loss = 12379736.0\n", + "Epoch 337: Loss = 12098196.0\n", + "Epoch 338: Loss = 7388391.5\n", + "Epoch 339: Loss = 6162855.5\n", + "Epoch 340: Loss = 5634845.0\n", + "Epoch 341: Loss = 3414655.0\n", + "Epoch 342: Loss = 2931523.0\n", + "Epoch 343: Loss = 17941050.0\n", + "Epoch 344: Loss = 25871864.0\n", + "Epoch 345: Loss = 37890684.0\n", + "Epoch 346: Loss = 13986114.0\n", + "Epoch 347: Loss = 13123363.0\n", + "Epoch 348: Loss = 11382073.0\n", + "Epoch 349: Loss = 31477172.0\n", + "Epoch 350: Loss = 7196466.0\n", + "Epoch 351: Loss = 18594956.0\n", + "Epoch 352: Loss = 23716518.0\n", + "Epoch 353: Loss = 16498504.0\n", + "Epoch 354: Loss = 30585646.0\n", + "Epoch 355: Loss = 37859912.0\n", + "Epoch 356: Loss = 8174270.0\n", + "Epoch 357: Loss = 18000748.0\n", + "Epoch 358: Loss = 6179393.5\n", + "Epoch 359: Loss = 9815300.0\n", + "Epoch 360: Loss = 13170956.0\n", + "Epoch 361: Loss = 34797720.0\n", + "Epoch 362: Loss = 14839481.0\n", + "Epoch 363: Loss = 11062543.0\n", + "Epoch 364: Loss = 1226162.125\n", + "Epoch 365: Loss = 1730673.0\n", + "Epoch 366: Loss = 2638962.25\n", + "Epoch 367: Loss = 3740686.5\n", + "Epoch 368: Loss = 2295863.0\n", + "Epoch 369: Loss = 7822918.5\n", + "Epoch 370: Loss = 6592415.5\n", + "Epoch 371: Loss = 5863917.0\n", + "Epoch 372: Loss = 3220520.25\n", + "Epoch 373: Loss = 3901127.75\n", + "Epoch 374: Loss = 7227896.5\n", + "Epoch 375: Loss = 4244708.0\n", + "Epoch 376: Loss = 1960855.5\n", + "Epoch 377: Loss = 44605084.0\n", + "Epoch 378: Loss = 37953028.0\n", + "Epoch 379: Loss = 38479128.0\n", + "Epoch 380: Loss = 1646036.25\n", + "Epoch 381: Loss = 1956850.375\n", + "Epoch 382: Loss = 1022255.125\n", + "Epoch 383: Loss = 17024442.0\n", + "Epoch 384: Loss = 18889852.0\n", + "Epoch 385: Loss = 13461972.0\n", + "Epoch 386: Loss = 82066912.0\n", + "Epoch 387: Loss = 6709552.0\n", + "Epoch 388: Loss = 23933834.0\n", + "Epoch 389: Loss = 14408879.0\n", + "Epoch 390: Loss = 21427828.0\n", + "Epoch 391: Loss = 40592940.0\n", + "Epoch 392: Loss = 27474848.0\n", + "Epoch 393: Loss = 18541048.0\n", + "Epoch 394: Loss = 6633277.5\n", + "Epoch 395: Loss = 7380019.5\n", + "Epoch 396: Loss = 12679058.0\n", + "Epoch 397: Loss = 25765614.0\n", + "Epoch 398: Loss = 24309706.0\n", + "Epoch 399: Loss = 8185821.0\n", + "Epoch 400: Loss = 13782796.0\n", + "Epoch 401: Loss = 20877706.0\n", + "Epoch 402: Loss = 10918741.0\n", + "Epoch 403: Loss = 12428180.0\n", + "Epoch 404: Loss = 12314490.0\n", + "Epoch 405: Loss = 9034409.0\n", + "Epoch 406: Loss = 11179762.0\n", + "Epoch 407: Loss = 1332685.75\n", + "Epoch 408: Loss = 8724377.0\n", + "Epoch 409: Loss = 4092440.5\n", + "Epoch 410: Loss = 7746171.0\n", + "Epoch 411: Loss = 3990658.0\n", + "Epoch 412: Loss = 9052532.0\n", + "Epoch 413: Loss = 5382648.5\n", + "Epoch 414: Loss = 6087593.0\n", + "Epoch 415: Loss = 10909400.0\n", + "Epoch 416: Loss = 13880742.0\n", + "Epoch 417: Loss = 10404677.0\n", + "Epoch 418: Loss = 22503978.0\n", + "Epoch 419: Loss = 30100348.0\n", + "Epoch 420: Loss = 4746040.5\n", + "Epoch 421: Loss = 5709309.0\n", + "Epoch 422: Loss = 5332604.0\n", + "Epoch 423: Loss = 6832333.0\n", + "Epoch 424: Loss = 7631865.0\n", + "Epoch 425: Loss = 3771762.75\n", + "Epoch 426: Loss = 18801092.0\n", + "Epoch 427: Loss = 55575752.0\n", + "Epoch 428: Loss = 97920264.0\n", + "Epoch 429: Loss = 61876276.0\n", + "Epoch 430: Loss = 29736144.0\n", + "Epoch 431: Loss = 40055184.0\n", + "Epoch 432: Loss = 28055472.0\n", + "Epoch 433: Loss = 12496342.0\n", + "Epoch 434: Loss = 18982382.0\n", + "Epoch 435: Loss = 10846186.0\n", + "Epoch 436: Loss = 14282407.0\n", + "Epoch 437: Loss = 37909076.0\n", + "Epoch 438: Loss = 20137116.0\n", + "Epoch 439: Loss = 9262172.0\n", + "Epoch 440: Loss = 3640067.0\n", + "Epoch 441: Loss = 10816868.0\n", + "Epoch 442: Loss = 18398186.0\n", + "Epoch 443: Loss = 3821556.5\n", + "Epoch 444: Loss = 12209163.0\n", + "Epoch 445: Loss = 9349880.0\n", + "Epoch 446: Loss = 5125670.5\n", + "Epoch 447: Loss = 37675156.0\n", + "Epoch 448: Loss = 18691106.0\n", + "Epoch 449: Loss = 9890120.0\n", + "Epoch 450: Loss = 8104408.0\n", + "Epoch 451: Loss = 10571805.0\n", + "Epoch 452: Loss = 4060703.75\n", + "Epoch 453: Loss = 6327300.0\n", + "Epoch 454: Loss = 5932917.0\n", + "Epoch 455: Loss = 11192619.0\n", + "Epoch 456: Loss = 14876193.0\n", + "Epoch 457: Loss = 10281366.0\n", + "Epoch 458: Loss = 5453881.0\n", + "Epoch 459: Loss = 13143906.0\n", + "Epoch 460: Loss = 20262672.0\n", + "Epoch 461: Loss = 7708167.0\n", + "Epoch 462: Loss = 17447026.0\n", + "Epoch 463: Loss = 1170099.125\n", + "Epoch 464: Loss = 14493766.0\n", + "Epoch 465: Loss = 3540527.75\n", + "Epoch 466: Loss = 4028082.0\n", + "Epoch 467: Loss = 8608558.0\n", + "Epoch 468: Loss = 10065666.0\n", + "Epoch 469: Loss = 8405355.0\n", + "Epoch 470: Loss = 12151652.0\n", + "Epoch 471: Loss = 16991180.0\n", + "Epoch 472: Loss = 9371812.0\n", + "Epoch 473: Loss = 19665128.0\n", + "Epoch 474: Loss = 5872520.0\n", + "Epoch 475: Loss = 13190856.0\n", + "Epoch 476: Loss = 7332938.0\n", + "Epoch 477: Loss = 6324096.5\n", + "Epoch 478: Loss = 6623219.0\n", + "Epoch 479: Loss = 6425566.0\n", + "Epoch 480: Loss = 9061003.0\n", + "Epoch 481: Loss = 3552659.5\n", + "Epoch 482: Loss = 4545801.5\n", + "Epoch 483: Loss = 2553218.75\n", + "Epoch 484: Loss = 821733.375\n", + "Epoch 485: Loss = 8598632.0\n", + "Epoch 486: Loss = 8665224.0\n", + "Epoch 487: Loss = 4746739.5\n", + "Epoch 488: Loss = 1781845.375\n", + "Epoch 489: Loss = 1323368.0\n", + "Epoch 490: Loss = 829634.375\n", + "Epoch 491: Loss = 1419806.125\n", + "Epoch 492: Loss = 20782330.0\n", + "Epoch 493: Loss = 11469326.0\n", + "Epoch 494: Loss = 14554182.0\n", + "Epoch 495: Loss = 12838631.0\n", + "Epoch 496: Loss = 11325082.0\n", + "Epoch 497: Loss = 13525978.0\n", + "Epoch 498: Loss = 27821814.0\n", + "Epoch 499: Loss = 9435000.0\n", + "Epoch 500: Loss = 20394206.0\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "loss_values = history.history['loss']\n", + "print(loss_values)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "My8by2_2DI_X", + "outputId": "f696d0f4-2591-4271-e7ce-719f7e48a721" + }, + "execution_count": 38, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[13978865.0, 13661791.0, 13745915.0, 14039383.0, 14036662.0, 13992389.0, 14043848.0, 13798370.0, 13376729.0, 13109994.0, 13637852.0, 13281099.0, 12732879.0, 11649245.0, 12006907.0, 10077946.0, 6745423.5, 8057920.0, 7560234.0, 10751578.0, 7243948.5, 7888572.0, 8588810.0, 8419626.0, 9516969.0, 7365000.0, 7175318.0, 9339095.0, 8668128.0, 7203061.5, 8713561.0, 9448430.0, 9513725.0, 6670869.5, 10145086.0, 6996037.5, 8719094.0, 9057428.0, 7909514.0, 10276208.0, 9739874.0, 10149930.0, 8913145.0, 10026408.0, 8749553.0, 9029780.0, 9004435.0, 9100776.0, 10185200.0, 10122906.0, 8880246.0, 8821126.0, 8521718.0, 8372325.5, 8121804.5, 8525467.0, 8518840.0, 8578520.0, 8065098.5, 7953030.5, 7886762.5, 7736829.5, 7885539.5, 8038061.0, 7792236.5, 7960796.0, 7895030.0, 7796317.5, 7477304.0, 8136023.0, 8435440.0, 8509963.0, 9771523.0, 10068050.0, 10016277.0, 10018746.0, 9927969.0, 9876155.0, 9829617.0, 9834552.0, 9743723.0, 9708187.0, 9673909.0, 9640575.0, 9607001.0, 9573277.0, 9538612.0, 9519751.0, 9463637.0, 9405359.0, 9351933.0, 9333471.0, 9251945.0, 9175816.0, 9133273.0, 9092211.0, 9026029.0, 8972206.0, 8917377.0, 8855146.0, 8817475.0, 8767893.0, 8704868.0, 8672368.0, 8623803.0, 8594071.0, 8551559.0, 8497334.0, 8350219.5, 8291855.0, 8181426.0, 8152970.0, 9679971.0, 9600615.0, 9520171.0, 8666106.0, 7868696.0, 8550929.0, 8475719.0, 8423616.0, 7516146.0, 8298322.0, 8117534.5, 8174611.5, 8131674.5, 8084244.5, 8049593.5, 7999823.5, 7967148.5, 7924028.0, 7876899.5, 7842282.0, 7801153.5, 7763562.5, 7723649.0, 7688537.5, 7653228.5, 7620349.5, 7590787.5, 7560942.0, 7530991.0, 7501377.0, 7471123.0, 7446005.5, 7411576.0, 7382610.0, 7355635.5, 7322470.5, 7322630.5, 7260817.0, 7230733.0, 7197820.0, 7166958.0, 7129025.5, 7092078.0, 7065559.0, 7030418.0, 6997822.5, 7857188.0, 6936069.0, 6907201.0, 6877264.5, 6851487.0, 6826318.0, 6801646.5, 6775227.5, 6749586.0, 6723898.5, 6692865.5, 6664151.0, 6631443.0, 6594502.5, 6556715.5, 6509205.5, 6480022.5, 6434694.0, 6394368.0, 6357692.5, 6316935.5, 6289429.5, 6248276.0, 6222152.5, 6186493.0, 6155007.5, 6119027.5, 6094129.0, 6062169.5, 6032828.5, 6004689.5, 5974583.5, 5951585.0, 5917849.5, 5894174.0, 5858341.0, 5828297.0, 5789473.5, 5757150.5, 5716894.5, 5683586.5, 5637409.5]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Escalar los datos entre 0 y 1scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_y = MinMaxScaler(feature_range=(0, 1))\n", + "train_X_scaled = scaler_X.fit_transform(train_X)\n", + "test_X_scaled = scaler_X.transform(test_X)\n", + "train_y_scaled = scaler_y.fit_transform(train_y.values.reshape(-1, 1))\n", + "test_y_scaled = scaler_y.transform(test_y.values.reshape(-1, 1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + }, + "id": "ji9qjt_SCrvY", + "outputId": "7610dff1-9cc5-4bba-92ea-a0b93fdf3a09" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mscaler_X\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mscaler_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mtrain_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mtest_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mtrain_y_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/_set_output.py\u001b[0m in \u001b[0;36mwrapped\u001b[0;34m(self, X, *args, **kwargs)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mdata_to_wrap\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_to_wrap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[0;31m# only wrap the first output for cross decomposition\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 876\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0my\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 877\u001b[0m \u001b[0;31m# fit method of arity 1 (unsupervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 878\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 879\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 880\u001b[0m \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 425\u001b[0m \u001b[0;31m# Reset internal state before fitting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 426\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 427\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 428\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mpartial_fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 464\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 465\u001b[0m \u001b[0mfirst_pass\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"n_samples_seen_\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 466\u001b[0;31m X = self._validate_data(\n\u001b[0m\u001b[1;32m 467\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[0mreset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfirst_pass\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36m_validate_data\u001b[0;34m(self, X, y, reset, validate_separately, **check_params)\u001b[0m\n\u001b[1;32m 563\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Validation should be done on X, y or both.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 564\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 565\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"X\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mcheck_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 566\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 567\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_array\u001b[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator, input_name)\u001b[0m\n\u001b[1;32m 776\u001b[0m )\n\u001b[1;32m 777\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtype_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdtype_iter\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 778\u001b[0;31m \u001b[0mdtype_orig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 779\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 780\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"iloc\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"dtype\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numpy/core/overrides.py\u001b[0m in \u001b[0;36mresult_type\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: at least one array or dtype is required" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Definir el modelo LSTM\n", + "model_lstm = Sequential()\n", + "model_lstm.add(LSTM(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "model_lstm.add(Dense(1))\n", + "model_lstm.compile(optimizer='adam', loss='mse')\n", + "\n", + "#/ Definir el modelo GRU\n", + "#model_gru = Sequential()\n", + "#model_gru.add(GRU(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "#model_gru.add(Dense(1))\n", + "#model_gru.compile(optimizer='adam', loss='mse')\n", + "#" + ], + "metadata": { + "id": "CaTJQmj33IvW" + }, + "execution_count": 16, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model_lstm.fit(train_X, train_y, epochs=10, verbose=0)\n", + "#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\n", + "\n", + "# Evaluar los modelos\n", + "mse_lstm = model_lstm.evaluate(test_X, test_y)\n", + "#mse_gru = model_gru.evaluate(test_X, test_y)\n", + "\n", + "print(f'Test MSE LSTM: {mse_lstm}')\n", + "#print(f'Test MSE GRU: {mse_gru}')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 245 + }, + "id": "3wBcalVC41ED", + "outputId": "671dcbb9-7d07-4da9-b9e3-1c52a5f16ef9" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;31m#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Evaluar los modelos\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mmse_lstm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'train_X' is not defined" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "hasta aca\n" + ], + "metadata": { + "id": "keXYd4TrurKV" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Convertir los datos a un formato largo usando melt de pandas\n", + "new_data = pd.melt(data, id_vars=['Country', 'Latitude', 'Longitude', 'Features', 'Region'], var_name='Year', value_name='Value')\n", + "\n", + "# Convertir las columnas al tipo de datos correcto\n", + "new_data['Year'] = new_data['Year'].astype(int)\n", + "new_data['Latitude'] = pd.to_numeric(new_data['Latitude'])\n", + "new_data['Longitude'] = pd.to_numeric(new_data['Longitude'])" + ], + "metadata": { + "id": "Xd6En43Apl_Z", + "outputId": "ff66b8ad-695e-4976-8859-ea466bc350cc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\"", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Convertir las columnas al tipo de datos correcto\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/tools/numeric.py\u001b[0m in \u001b[0;36mto_numeric\u001b[0;34m(arg, errors, downcast)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[0mcoerce_numeric\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0merrors\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"ignore\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"raise\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 184\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 185\u001b[0;31m values, _ = lib.maybe_convert_numeric(\n\u001b[0m\u001b[1;32m 186\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 187\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\" at position 161" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Reordenar los niveles de 'Features' en la secuencia deseada\n", + "feature_order = [\"imports\", \"exports\", \"net imports\", \"installed capacity\", \"net generation\", \"net consumption\", \"distribution losses\"]\n", + "new_data['Features'] = pd.Categorical(new_data['Features'], categories=feature_order, ordered=True)\n", + "\n", + "custom_palette = [\"red\", \"blue\", \"green\",\"purple\", \"#FF7F00\", \"cyan\", \"brown\"]\n", + "\n", + "# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\n", + "region_features = new_data.groupby(['Year', 'Region', 'Features']).agg(Total_Value=('Value', 'sum')).reset_index()\n", + "\n", + "# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "# Crear el gráfico de líneas con la paleta de colores personalizada\n", + "sns.lineplot(data=region_features, x='Year', y='Total_Value', hue='Region')\n", + "plt.title('Total Values by Region Over Time')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('Total')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 390 + }, + "id": "cYzGOiNeVfY7", + "outputId": "d3044941-773c-479f-a4bf-7e86be3e6785" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mregion_features\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Region'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0magg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTotal_Value\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Value'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sum'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36mgroupby\u001b[0;34m(self, by, axis, level, as_index, sort, group_keys, squeeze, observed, dropna)\u001b[0m\n\u001b[1;32m 8400\u001b[0m \u001b[0maxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_axis_number\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8401\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 8402\u001b[0;31m return DataFrameGroupBy(\n\u001b[0m\u001b[1;32m 8403\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8404\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/groupby.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, obj, keys, axis, level, grouper, exclusions, selection, as_index, sort, group_keys, squeeze, observed, mutated, dropna)\u001b[0m\n\u001b[1;32m 963\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrouper\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mget_grouper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 964\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 965\u001b[0;31m grouper, exclusions, obj = get_grouper(\n\u001b[0m\u001b[1;32m 966\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 967\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/grouper.py\u001b[0m in \u001b[0;36mget_grouper\u001b[0;34m(obj, key, axis, level, sort, observed, mutated, validate, dropna)\u001b[0m\n\u001b[1;32m 886\u001b[0m \u001b[0min_axis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 888\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 889\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGrouper\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkey\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 890\u001b[0m \u001b[0;31m# Add key to exclusions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "custom_palette = [\"#E41A1C\", \"#377EB8\", \"#4DAF4A\", \"#984EA3\", \"#FF7F00\", \"#FFFF33\", \"#A65628\"]\n", + "\n", + "# Filter the data for the past five years and 'exports'\n", + "export_data = new_data[(new_data['Features'] == \"exports\") & (new_data['Year'] >= (new_data['Year'].max() - 4))]\n", + "\n", + "# Group by 'Country' and calculate the total export value\n", + "top_exporting_countries = export_data.groupby('Country')['Value'].sum().reset_index().sort_values(by='Value', ascending=False).head(10)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(x='Value', y='Country', data=top_exporting_countries, palette=custom_palette)\n", + "print(top_exporting_countries)\n", + "\n", + "plt.xlabel('Total Exports')\n", + "plt.ylabel('Country')\n", + "plt.title('Exports - Last 5 Years - Top Ten Countries')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 512 + }, + "id": "pEGfENwGVhHK", + "outputId": "2dc0d837-10ef-4939-a46a-d36246f692a7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3801\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3802\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Filter the data for the past five years and 'exports'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mexport_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"exports\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# Group by 'Country' and calculate the total export value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3805\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3807\u001b[0;31m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3808\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3809\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3802\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3804\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3805\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;31m# If we have a listlike key, _check_indexing_error will raise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "RQfTp3HSXLqQ" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/proyectoIAPrediccion1CNNPrediccion.ipynb b/proyectoIAPrediccion1CNNPrediccion.ipynb new file mode 100644 index 0000000..f234ddb --- /dev/null +++ b/proyectoIAPrediccion1CNNPrediccion.ipynb @@ -0,0 +1,2789 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as mcolors\n", + "import matplotlib.cm as cm\n", + "import matplotlib\n", + "import seaborn as sns\n", + "import plotly.express as px\n", + "from wordcloud import WordCloud\n", + "import geopandas as gpd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from keras.models import Sequential\n", + "from keras.layers import LSTM, GRU, Conv1D, MaxPooling1D, Flatten, Dense\n", + "from keras.losses import MeanSquaredError\n", + "from keras.regularizers import l2\n", + "from sklearn.metrics import mean_squared_error\n", + "\n" + ], + "metadata": { + "id": "H7kZjC_GUZZd" + }, + "execution_count": 161, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": { + "id": "9_FId2wvQAgd" + }, + "outputs": [], + "source": [ + "# Leer los datos\n", + "GES_Data = \"global_electricity_statistics_cleaned.csv\"\n", + "df = pd.read_csv(GES_Data)" + ] + }, + { + "cell_type": "code", + "source": [ + "# Ver los primeros datos\n", + "print(df.head())\n", + "df[\"Features\"].value_counts()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lWY6qwmkQ2PL", + "outputId": "147427ad-532e-4c0d-8dcd-0e3aa47375fe" + }, + "execution_count": 163, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Country Features Region 1980 1981 1982 1983 \\\n", + "0 Algeria net generation Africa 6.683 7.65 8.824 9.615 \n", + "1 Angola net generation Africa 0.905 0.906 0.995 1.028 \n", + "2 Benin net generation Africa 0.005 0.005 0.005 0.005 \n", + "3 Botswana net generation Africa 0.443 0.502 0.489 0.434 \n", + "4 Burkina Faso net generation Africa 0.098 0.108 0.115 0.117 \n", + "\n", + " 1984 1985 1986 ... 2012 2013 2014 2015 \\\n", + "0 10.537 11.569 12.214 ... 53.9845 56.3134 60.39972 64.68244 \n", + "1 1.028 1.028 1.088 ... 6.03408 7.97606 9.21666 9.30914 \n", + "2 0.005 0.005 0.005 ... 0.04612 0.08848 0.22666 0.31056 \n", + "3 0.445 0.456 0.538 ... 0.33 0.86868 2.17628 2.79104 \n", + "4 0.113 0.115 0.122 ... 0.86834 0.98268 1.11808 1.43986 \n", + "\n", + " 2016 2017 2018 2019 2020 2021 \n", + "0 66.75504 71.49546 72.10903 76.685 72.73591277 77.53072719 \n", + "1 10.203511 10.67604 12.83194 15.4 16.6 16.429392 \n", + "2 0.26004 0.3115 0.19028 0.2017 0.22608 0.24109728 \n", + "3 2.52984 2.8438 2.97076 3.0469 2.05144 2.18234816 \n", + "4 1.5509 1.64602 1.6464 1.72552 1.647133174 1.761209666 \n", + "\n", + "[5 rows x 45 columns]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "net generation 230\n", + "net consumption 230\n", + "imports 230\n", + "exports 230\n", + "net imports 230\n", + "installed capacity 230\n", + "distribution losses 230\n", + "Name: Features, dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 163 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Convertir las columnas de los años a numéricas\n", + "cols = [str(year) for year in range(1980, 2022)]\n", + "df[cols] = df[cols].apply(pd.to_numeric, errors='coerce')\n", + "\n", + "# Calcular el promedio de cada fila (ignorando los valores NaN)\n", + "df['avg'] = df.loc[:, '1980':'2021'].mean(axis=1)\n", + "\n", + "# Rellenar los valores NaN con el promedio de la fila correspondiente\n", + "for col in cols:\n", + " df[col].fillna(df['avg'], inplace=True)\n", + "\n", + "# Eliminar la columna 'avg' ya que ya no es necesaria\n", + "df.drop('avg', axis=1, inplace=True)\n", + "\n", + "# Agregar la columna 'Total' que es la suma de las columnas desde 1980 hasta 2021\n", + "df['Total'] = df.loc[:, '1980':'2021'].sum(axis=1)\n", + "\n", + "# Agrupar por 'Region' y obtener la suma de los valores\n", + "df_grouped = df.groupby('Region', as_index=False).sum(numeric_only=True)\n" + ], + "metadata": { + "id": "9MZcbtw9t95l" + }, + "execution_count": 164, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df_grouped.describe().columns" + ], + "metadata": { + "id": "xegG-hIr9XGK", + "outputId": "599e12e1-fd76-445a-9d9f-14043e1fb785", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 165, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Index(['1980', '1981', '1982', '1983', '1984', '1985', '1986', '1987', '1988',\n", + " '1989', '1990', '1991', '1992', '1993', '1994', '1995', '1996', '1997',\n", + " '1998', '1999', '2000', '2001', '2002', '2003', '2004', '2005', '2006',\n", + " '2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015',\n", + " '2016', '2017', '2018', '2019', '2020', '2021', 'Total'],\n", + " dtype='object')" + ] + }, + "metadata": {}, + "execution_count": 165 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "base de datos lista con regiones y caracteristicas 1980 al 2021 abajo listo falta red neuronal y entrenamiento\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "_28HoIcVTX5H" + } + }, + { + "cell_type": "code", + "source": [ + "print(df_grouped)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6wZ4FIMSDhZH", + "outputId": "594e8826-4ecb-48f7-9bf5-e7b9ddd29ff1" + }, + "execution_count": 166, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Region 1980 1981 1982 \\\n", + "0 Africa 442.751613 470.995013 486.609413 \n", + "1 Asia & Oceania 2864.920423 2957.954923 3091.071601 \n", + "2 Central & South America 701.439239 723.419959 767.169799 \n", + "3 Eurasia 5956.246909 5880.536405 6119.223111 \n", + "4 Europe 7098.639233 7138.275233 7175.265233 \n", + "5 Middle East 228.045912 256.978912 301.258912 \n", + "6 North America 6172.234030 6282.965270 6205.586413 \n", + "\n", + " 1983 1984 1985 1986 1987 \\\n", + "0 505.565813 548.573213 584.582613 617.340013 640.229413 \n", + "1 3288.175590 3517.547039 3737.678238 3942.409483 4262.148408 \n", + "2 821.105839 882.052239 924.217679 1014.448560 1061.394480 \n", + "3 6224.347107 6384.761865 6497.913049 6433.159219 6555.257483 \n", + "4 7379.304233 7639.238233 7874.046233 7993.154233 8202.475233 \n", + "5 335.294912 370.548912 395.965912 416.267912 439.324912 \n", + "6 6399.484193 6703.205738 6894.759863 6963.126923 7235.631195 \n", + "\n", + " 1988 ... 2013 2014 2015 2016 \\\n", + "0 662.405813 ... 1677.718947 1737.628313 1787.300928 1817.971412 \n", + "1 4589.761222 ... 21303.566369 22255.187389 23001.975032 24277.047884 \n", + "2 1111.898820 ... 2880.299637 2874.232050 2956.475857 3010.131036 \n", + "3 6641.334325 ... 6588.899485 6601.562889 6568.729219 6619.157366 \n", + "4 8354.649233 ... 10857.743749 10724.724561 10972.003012 11045.824989 \n", + "5 491.155912 ... 2244.918531 2393.003912 2514.613376 2591.011451 \n", + "6 7502.085307 ... 11431.326082 11512.482997 11530.195877 11571.996896 \n", + "\n", + " 2017 2018 2019 2020 2021 \\\n", + "0 1893.433230 1939.653262 1964.909527 1927.467376 1997.010181 \n", + "1 25762.027981 27169.634214 28150.420606 28902.810243 30933.492914 \n", + "2 3029.476889 3080.027553 3085.916507 3087.128325 3238.838636 \n", + "3 6646.263342 6679.715937 6715.974792 6694.895904 6892.277529 \n", + "4 11104.506712 11096.788734 11080.544037 10985.140560 11273.946852 \n", + "5 2694.789331 2759.997855 2864.975233 2768.263372 2909.974107 \n", + "6 11504.857796 11858.463840 11735.104936 11547.486151 11829.410197 \n", + "\n", + " Total \n", + "0 47384.899885 \n", + "1 517723.280867 \n", + "2 80349.864723 \n", + "3 268660.517049 \n", + "4 396571.073559 \n", + "5 54238.932786 \n", + "6 404741.539017 \n", + "\n", + "[7 rows x 44 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(df_grouped.columns)" + ], + "metadata": { + "id": "y9YU2bOl_Cf6", + "outputId": "5ba173bb-6ae2-48e7-e236-10fac3cd12be", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 167, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Index(['Region', '1980', '1981', '1982', '1983', '1984', '1985', '1986',\n", + " '1987', '1988', '1989', '1990', '1991', '1992', '1993', '1994', '1995',\n", + " '1996', '1997', '1998', '1999', '2000', '2001', '2002', '2003', '2004',\n", + " '2005', '2006', '2007', '2008', '2009', '2010', '2011', '2012', '2013',\n", + " '2014', '2015', '2016', '2017', '2018', '2019', '2020', '2021',\n", + " 'Total'],\n", + " dtype='object')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Asegúrate de que 'Region' sea el índice del DataFrame\n", + "df_grouped.set_index('Region', inplace=True)\n", + "\n", + "# Elimina la columna 'Total'\n", + "df_groupedGraf = df_grouped.drop(columns=['Total'])\n", + "\n", + "# Convierte las columnas a un tipo numérico y maneja los NaNs\n", + "df_groupedGraf = df_groupedGraf.apply(pd.to_numeric, errors='coerce')\n", + "df_groupedGraf = df_groupedGraf.replace(np.nan, 0)\n", + "\n", + "# Transpone el DataFrame para que los años sean las filas y las regiones sean las columnas\n", + "df_groupedGraf = df_groupedGraf.transpose()\n", + "\n", + "# Crea el gráfico\n", + "plt.figure(figsize=(15, 10))\n", + "for region in df_groupedGraf.columns:\n", + " plt.plot(df_groupedGraf.index, df_groupedGraf[region], label=region)\n", + "\n", + "plt.xlabel('Año')\n", + "plt.ylabel('Valor')\n", + "plt.title('Valor por año por Contiente')\n", + "plt.legend()\n", + "\n", + "# Rota las etiquetas del eje x para evitar la superposición\n", + "plt.xticks(rotation=45)\n", + "\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 455 + }, + "id": "UAOFyFDLLMo-", + "outputId": "ab682b8d-f6b9-4736-8139-f8f85e6647fc" + }, + "execution_count": 168, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Guardar el dataframe agrupado\n", + "df_grouped.to_csv('global_electricity_statistics_by_region.csv')" + ], + "metadata": { + "id": "3HyCu76yuvpS" + }, + "execution_count": 169, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Supongamos que 'df_grouped' es tu DataFrame y quieres predecir la columna '2021'\n", + "df = df_grouped.drop('Total', axis=1) # Eliminar la columna 'Total'\n", + "\n", + "# Limpiar los datos: reemplazar los valores 'NaN' e infinitos por cero\n", + "df = df.replace([np.inf, -np.inf], np.nan).fillna(0)\n", + "\n", + "X = df.drop('2021', axis=1)\n", + "y = df['2021']\n", + "\n", + "# Dividir los datos en conjuntos de entrenamiento y prueba\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.42, random_state=45)\n", + "\n", + "# Convertir y_pred en una serie de pandas\n", + "y_pred_series = pd.Series(y_pred.flatten(), index=X_test.index)\n", + "\n", + "\n", + "# Guardar el índice de X_test antes de cambiar su forma\n", + "X_test_index = X_test.index\n", + "\n", + "# Cambiar la forma de los datos para que sean compatibles con CNN\n", + "X_train = np.expand_dims(X_train, axis=2)\n", + "X_test = np.expand_dims(X_test, axis=2)\n", + "\n", + "# Crear la red CNN\n", + "model = Sequential()\n", + "model.add(Conv1D(filters=64, kernel_size=9, activation='relu', input_shape=(X_train.shape[1], 1))) # Puedes cambiar el número de filtros (64 aquí), el tamaño del kernel (3 aquí) y la función de activación ('relu' aquí)\n", + "model.add(MaxPooling1D(pool_size=2)) # Puedes cambiar el tamaño del pool (2 aquí)\n", + "model.add(Flatten())\n", + "model.add(Dense(90, activation='relu')) # Puedes cambiar el número de neuronas (50 aquí) y la función de activación ('relu' aquí)\n", + "model.add(Dense(1))\n", + "\n", + "# Compilar el modelo\n", + "model.compile(optimizer='adam', loss=MeanSquaredError()) # Puedes cambiar el optimizador ('adam' aquí) y la función de pérdida (MeanSquaredError aquí)\n", + "\n", + "# Ajustar el modelo a los datos de entrenamiento\n", + "history = model.fit(X_train, y_train, epochs=2000, verbose=4) # Puedes cambiar el número de épocas (200 aquí)\n", + "\n", + "# Graficar la pérdida durante el entrenamiento\n", + "plt.plot(history.history['loss'])\n", + "plt.title('Model loss')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train'], loc='upper right')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "nfJrQD1i4qys", + "outputId": "d1713afc-7891-4e28-ed48-88397b52d758" + }, + "execution_count": 188, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/2000\n", + "Epoch 2/2000\n", + "Epoch 3/2000\n", + "Epoch 4/2000\n", + "Epoch 5/2000\n", + "Epoch 6/2000\n", + "Epoch 7/2000\n", + "Epoch 8/2000\n", + "Epoch 9/2000\n", + "Epoch 10/2000\n", + "Epoch 11/2000\n", + "Epoch 12/2000\n", + "Epoch 13/2000\n", + "Epoch 14/2000\n", + "Epoch 15/2000\n", + "Epoch 16/2000\n", + "Epoch 17/2000\n", + "Epoch 18/2000\n", + "Epoch 19/2000\n", + "Epoch 20/2000\n", + "Epoch 21/2000\n", + "Epoch 22/2000\n", + "Epoch 23/2000\n", + "Epoch 24/2000\n", + "Epoch 25/2000\n", + "Epoch 26/2000\n", + "Epoch 27/2000\n", + "Epoch 28/2000\n", + "Epoch 29/2000\n", + "Epoch 30/2000\n", + "Epoch 31/2000\n", + "Epoch 32/2000\n", + "Epoch 33/2000\n", + "Epoch 34/2000\n", + "Epoch 35/2000\n", + "Epoch 36/2000\n", + "Epoch 37/2000\n", + "Epoch 38/2000\n", + "Epoch 39/2000\n", + "Epoch 40/2000\n", + "Epoch 41/2000\n", + "Epoch 42/2000\n", + "Epoch 43/2000\n", + "Epoch 44/2000\n", + "Epoch 45/2000\n", + "Epoch 46/2000\n", + "Epoch 47/2000\n", + "Epoch 48/2000\n", + "Epoch 49/2000\n", + "Epoch 50/2000\n", + "Epoch 51/2000\n", + "Epoch 52/2000\n", + "Epoch 53/2000\n", + "Epoch 54/2000\n", + "Epoch 55/2000\n", + "Epoch 56/2000\n", + "Epoch 57/2000\n", + "Epoch 58/2000\n", + "Epoch 59/2000\n", + "Epoch 60/2000\n", + "Epoch 61/2000\n", + "Epoch 62/2000\n", + "Epoch 63/2000\n", + "Epoch 64/2000\n", + "Epoch 65/2000\n", + "Epoch 66/2000\n", + "Epoch 67/2000\n", + "Epoch 68/2000\n", + "Epoch 69/2000\n", + "Epoch 70/2000\n", + "Epoch 71/2000\n", + "Epoch 72/2000\n", + "Epoch 73/2000\n", + "Epoch 74/2000\n", + "Epoch 75/2000\n", + "Epoch 76/2000\n", + "Epoch 77/2000\n", + "Epoch 78/2000\n", + "Epoch 79/2000\n", + "Epoch 80/2000\n", + "Epoch 81/2000\n", + "Epoch 82/2000\n", + "Epoch 83/2000\n", + "Epoch 84/2000\n", + "Epoch 85/2000\n", + "Epoch 86/2000\n", + "Epoch 87/2000\n", + "Epoch 88/2000\n", + "Epoch 89/2000\n", + "Epoch 90/2000\n", + "Epoch 91/2000\n", + "Epoch 92/2000\n", + "Epoch 93/2000\n", + "Epoch 94/2000\n", + "Epoch 95/2000\n", + "Epoch 96/2000\n", + "Epoch 97/2000\n", + "Epoch 98/2000\n", + "Epoch 99/2000\n", + "Epoch 100/2000\n", + "Epoch 101/2000\n", + "Epoch 102/2000\n", + "Epoch 103/2000\n", + "Epoch 104/2000\n", + "Epoch 105/2000\n", + "Epoch 106/2000\n", + "Epoch 107/2000\n", + "Epoch 108/2000\n", + "Epoch 109/2000\n", + "Epoch 110/2000\n", + "Epoch 111/2000\n", + "Epoch 112/2000\n", + "Epoch 113/2000\n", + "Epoch 114/2000\n", + "Epoch 115/2000\n", + "Epoch 116/2000\n", + "Epoch 117/2000\n", + "Epoch 118/2000\n", + "Epoch 119/2000\n", + "Epoch 120/2000\n", + "Epoch 121/2000\n", + "Epoch 122/2000\n", + "Epoch 123/2000\n", + "Epoch 124/2000\n", + "Epoch 125/2000\n", + "Epoch 126/2000\n", + "Epoch 127/2000\n", + "Epoch 128/2000\n", + "Epoch 129/2000\n", + "Epoch 130/2000\n", + "Epoch 131/2000\n", + "Epoch 132/2000\n", + "Epoch 133/2000\n", + "Epoch 134/2000\n", + "Epoch 135/2000\n", + "Epoch 136/2000\n", + "Epoch 137/2000\n", + "Epoch 138/2000\n", + "Epoch 139/2000\n", + "Epoch 140/2000\n", + "Epoch 141/2000\n", + "Epoch 142/2000\n", + "Epoch 143/2000\n", + "Epoch 144/2000\n", + "Epoch 145/2000\n", + "Epoch 146/2000\n", + "Epoch 147/2000\n", + "Epoch 148/2000\n", + "Epoch 149/2000\n", + "Epoch 150/2000\n", + "Epoch 151/2000\n", + "Epoch 152/2000\n", + "Epoch 153/2000\n", + "Epoch 154/2000\n", + "Epoch 155/2000\n", + "Epoch 156/2000\n", + "Epoch 157/2000\n", + "Epoch 158/2000\n", + "Epoch 159/2000\n", + "Epoch 160/2000\n", + "Epoch 161/2000\n", + "Epoch 162/2000\n", + "Epoch 163/2000\n", + "Epoch 164/2000\n", + "Epoch 165/2000\n", + "Epoch 166/2000\n", + "Epoch 167/2000\n", + "Epoch 168/2000\n", + "Epoch 169/2000\n", + "Epoch 170/2000\n", + "Epoch 171/2000\n", + "Epoch 172/2000\n", + "Epoch 173/2000\n", + "Epoch 174/2000\n", + "Epoch 175/2000\n", + "Epoch 176/2000\n", + "Epoch 177/2000\n", + "Epoch 178/2000\n", + "Epoch 179/2000\n", + "Epoch 180/2000\n", + "Epoch 181/2000\n", + "Epoch 182/2000\n", + "Epoch 183/2000\n", + "Epoch 184/2000\n", + "Epoch 185/2000\n", + "Epoch 186/2000\n", + "Epoch 187/2000\n", + "Epoch 188/2000\n", + "Epoch 189/2000\n", + "Epoch 190/2000\n", + "Epoch 191/2000\n", + "Epoch 192/2000\n", + "Epoch 193/2000\n", + "Epoch 194/2000\n", + "Epoch 195/2000\n", + "Epoch 196/2000\n", + "Epoch 197/2000\n", + "Epoch 198/2000\n", + "Epoch 199/2000\n", + "Epoch 200/2000\n", + "Epoch 201/2000\n", + "Epoch 202/2000\n", + "Epoch 203/2000\n", + "Epoch 204/2000\n", + "Epoch 205/2000\n", + "Epoch 206/2000\n", + "Epoch 207/2000\n", + "Epoch 208/2000\n", + "Epoch 209/2000\n", + "Epoch 210/2000\n", + "Epoch 211/2000\n", + "Epoch 212/2000\n", + "Epoch 213/2000\n", + "Epoch 214/2000\n", + "Epoch 215/2000\n", + "Epoch 216/2000\n", + "Epoch 217/2000\n", + "Epoch 218/2000\n", + "Epoch 219/2000\n", + "Epoch 220/2000\n", + "Epoch 221/2000\n", + "Epoch 222/2000\n", + "Epoch 223/2000\n", + "Epoch 224/2000\n", + "Epoch 225/2000\n", + "Epoch 226/2000\n", + "Epoch 227/2000\n", + "Epoch 228/2000\n", + "Epoch 229/2000\n", + "Epoch 230/2000\n", + "Epoch 231/2000\n", + "Epoch 232/2000\n", + "Epoch 233/2000\n", + "Epoch 234/2000\n", + "Epoch 235/2000\n", + "Epoch 236/2000\n", + "Epoch 237/2000\n", + "Epoch 238/2000\n", + "Epoch 239/2000\n", + "Epoch 240/2000\n", + "Epoch 241/2000\n", + "Epoch 242/2000\n", + "Epoch 243/2000\n", + "Epoch 244/2000\n", + "Epoch 245/2000\n", + "Epoch 246/2000\n", + "Epoch 247/2000\n", + "Epoch 248/2000\n", + "Epoch 249/2000\n", + "Epoch 250/2000\n", + "Epoch 251/2000\n", + "Epoch 252/2000\n", + "Epoch 253/2000\n", + "Epoch 254/2000\n", + "Epoch 255/2000\n", + "Epoch 256/2000\n", + "Epoch 257/2000\n", + "Epoch 258/2000\n", + "Epoch 259/2000\n", + "Epoch 260/2000\n", + "Epoch 261/2000\n", + "Epoch 262/2000\n", + "Epoch 263/2000\n", + "Epoch 264/2000\n", + "Epoch 265/2000\n", + "Epoch 266/2000\n", + "Epoch 267/2000\n", + "Epoch 268/2000\n", + "Epoch 269/2000\n", + "Epoch 270/2000\n", + "Epoch 271/2000\n", + "Epoch 272/2000\n", + "Epoch 273/2000\n", + "Epoch 274/2000\n", + "Epoch 275/2000\n", + "Epoch 276/2000\n", + "Epoch 277/2000\n", + "Epoch 278/2000\n", + "Epoch 279/2000\n", + "Epoch 280/2000\n", + "Epoch 281/2000\n", + "Epoch 282/2000\n", + "Epoch 283/2000\n", + "Epoch 284/2000\n", + "Epoch 285/2000\n", + "Epoch 286/2000\n", + "Epoch 287/2000\n", + "Epoch 288/2000\n", + "Epoch 289/2000\n", + "Epoch 290/2000\n", + "Epoch 291/2000\n", + "Epoch 292/2000\n", + "Epoch 293/2000\n", + "Epoch 294/2000\n", + "Epoch 295/2000\n", + "Epoch 296/2000\n", + "Epoch 297/2000\n", + "Epoch 298/2000\n", + "Epoch 299/2000\n", + "Epoch 300/2000\n", + "Epoch 301/2000\n", + "Epoch 302/2000\n", + "Epoch 303/2000\n", + "Epoch 304/2000\n", + "Epoch 305/2000\n", + "Epoch 306/2000\n", + "Epoch 307/2000\n", + "Epoch 308/2000\n", + "Epoch 309/2000\n", + "Epoch 310/2000\n", + "Epoch 311/2000\n", + "Epoch 312/2000\n", + "Epoch 313/2000\n", + "Epoch 314/2000\n", + "Epoch 315/2000\n", + "Epoch 316/2000\n", + "Epoch 317/2000\n", + "Epoch 318/2000\n", + "Epoch 319/2000\n", + "Epoch 320/2000\n", + "Epoch 321/2000\n", + "Epoch 322/2000\n", + "Epoch 323/2000\n", + "Epoch 324/2000\n", + "Epoch 325/2000\n", + "Epoch 326/2000\n", + "Epoch 327/2000\n", + "Epoch 328/2000\n", + "Epoch 329/2000\n", + "Epoch 330/2000\n", + "Epoch 331/2000\n", + "Epoch 332/2000\n", + "Epoch 333/2000\n", + "Epoch 334/2000\n", + "Epoch 335/2000\n", + "Epoch 336/2000\n", + "Epoch 337/2000\n", + "Epoch 338/2000\n", + "Epoch 339/2000\n", + "Epoch 340/2000\n", + "Epoch 341/2000\n", + "Epoch 342/2000\n", + "Epoch 343/2000\n", + "Epoch 344/2000\n", + "Epoch 345/2000\n", + "Epoch 346/2000\n", + "Epoch 347/2000\n", + "Epoch 348/2000\n", + "Epoch 349/2000\n", + "Epoch 350/2000\n", + "Epoch 351/2000\n", + "Epoch 352/2000\n", + "Epoch 353/2000\n", + "Epoch 354/2000\n", + "Epoch 355/2000\n", + "Epoch 356/2000\n", + "Epoch 357/2000\n", + "Epoch 358/2000\n", + "Epoch 359/2000\n", + "Epoch 360/2000\n", + "Epoch 361/2000\n", + "Epoch 362/2000\n", + "Epoch 363/2000\n", + "Epoch 364/2000\n", + "Epoch 365/2000\n", + "Epoch 366/2000\n", + "Epoch 367/2000\n", + "Epoch 368/2000\n", + "Epoch 369/2000\n", + "Epoch 370/2000\n", + "Epoch 371/2000\n", + "Epoch 372/2000\n", + "Epoch 373/2000\n", + "Epoch 374/2000\n", + "Epoch 375/2000\n", + "Epoch 376/2000\n", + "Epoch 377/2000\n", + "Epoch 378/2000\n", + "Epoch 379/2000\n", + "Epoch 380/2000\n", + "Epoch 381/2000\n", + "Epoch 382/2000\n", + "Epoch 383/2000\n", + "Epoch 384/2000\n", + "Epoch 385/2000\n", + "Epoch 386/2000\n", + "Epoch 387/2000\n", + "Epoch 388/2000\n", + "Epoch 389/2000\n", + "Epoch 390/2000\n", + "Epoch 391/2000\n", + "Epoch 392/2000\n", + "Epoch 393/2000\n", + "Epoch 394/2000\n", + "Epoch 395/2000\n", + "Epoch 396/2000\n", + "Epoch 397/2000\n", + "Epoch 398/2000\n", + "Epoch 399/2000\n", + "Epoch 400/2000\n", + "Epoch 401/2000\n", + "Epoch 402/2000\n", + "Epoch 403/2000\n", + "Epoch 404/2000\n", + "Epoch 405/2000\n", + "Epoch 406/2000\n", + "Epoch 407/2000\n", + "Epoch 408/2000\n", + "Epoch 409/2000\n", + "Epoch 410/2000\n", + "Epoch 411/2000\n", + "Epoch 412/2000\n", + "Epoch 413/2000\n", + "Epoch 414/2000\n", + "Epoch 415/2000\n", + "Epoch 416/2000\n", + "Epoch 417/2000\n", + "Epoch 418/2000\n", + "Epoch 419/2000\n", + "Epoch 420/2000\n", + "Epoch 421/2000\n", + "Epoch 422/2000\n", + "Epoch 423/2000\n", + "Epoch 424/2000\n", + "Epoch 425/2000\n", + "Epoch 426/2000\n", + "Epoch 427/2000\n", + "Epoch 428/2000\n", + "Epoch 429/2000\n", + "Epoch 430/2000\n", + "Epoch 431/2000\n", + "Epoch 432/2000\n", + "Epoch 433/2000\n", + "Epoch 434/2000\n", + "Epoch 435/2000\n", + "Epoch 436/2000\n", + "Epoch 437/2000\n", + "Epoch 438/2000\n", + "Epoch 439/2000\n", + "Epoch 440/2000\n", + "Epoch 441/2000\n", + "Epoch 442/2000\n", + "Epoch 443/2000\n", + "Epoch 444/2000\n", + "Epoch 445/2000\n", + "Epoch 446/2000\n", + "Epoch 447/2000\n", + "Epoch 448/2000\n", + "Epoch 449/2000\n", + "Epoch 450/2000\n", + "Epoch 451/2000\n", + "Epoch 452/2000\n", + "Epoch 453/2000\n", + "Epoch 454/2000\n", + "Epoch 455/2000\n", + "Epoch 456/2000\n", + "Epoch 457/2000\n", + "Epoch 458/2000\n", + "Epoch 459/2000\n", + "Epoch 460/2000\n", + "Epoch 461/2000\n", + "Epoch 462/2000\n", + "Epoch 463/2000\n", + "Epoch 464/2000\n", + "Epoch 465/2000\n", + "Epoch 466/2000\n", + "Epoch 467/2000\n", + "Epoch 468/2000\n", + "Epoch 469/2000\n", + "Epoch 470/2000\n", + "Epoch 471/2000\n", + "Epoch 472/2000\n", + "Epoch 473/2000\n", + "Epoch 474/2000\n", + "Epoch 475/2000\n", + "Epoch 476/2000\n", + "Epoch 477/2000\n", + "Epoch 478/2000\n", + "Epoch 479/2000\n", + "Epoch 480/2000\n", + "Epoch 481/2000\n", + "Epoch 482/2000\n", + "Epoch 483/2000\n", + "Epoch 484/2000\n", + "Epoch 485/2000\n", + "Epoch 486/2000\n", + "Epoch 487/2000\n", + "Epoch 488/2000\n", + "Epoch 489/2000\n", + "Epoch 490/2000\n", + "Epoch 491/2000\n", + "Epoch 492/2000\n", + "Epoch 493/2000\n", + "Epoch 494/2000\n", + "Epoch 495/2000\n", + "Epoch 496/2000\n", + "Epoch 497/2000\n", + "Epoch 498/2000\n", + "Epoch 499/2000\n", + "Epoch 500/2000\n", + "Epoch 501/2000\n", + "Epoch 502/2000\n", + "Epoch 503/2000\n", + "Epoch 504/2000\n", + "Epoch 505/2000\n", + "Epoch 506/2000\n", + "Epoch 507/2000\n", + "Epoch 508/2000\n", + "Epoch 509/2000\n", + "Epoch 510/2000\n", + "Epoch 511/2000\n", + "Epoch 512/2000\n", + "Epoch 513/2000\n", + "Epoch 514/2000\n", + "Epoch 515/2000\n", + "Epoch 516/2000\n", + "Epoch 517/2000\n", + "Epoch 518/2000\n", + "Epoch 519/2000\n", + "Epoch 520/2000\n", + "Epoch 521/2000\n", + "Epoch 522/2000\n", + "Epoch 523/2000\n", + "Epoch 524/2000\n", + "Epoch 525/2000\n", + "Epoch 526/2000\n", + "Epoch 527/2000\n", + "Epoch 528/2000\n", + "Epoch 529/2000\n", + "Epoch 530/2000\n", + "Epoch 531/2000\n", + "Epoch 532/2000\n", + "Epoch 533/2000\n", + "Epoch 534/2000\n", + "Epoch 535/2000\n", + "Epoch 536/2000\n", + "Epoch 537/2000\n", + "Epoch 538/2000\n", + "Epoch 539/2000\n", + "Epoch 540/2000\n", + "Epoch 541/2000\n", + "Epoch 542/2000\n", + "Epoch 543/2000\n", + "Epoch 544/2000\n", + "Epoch 545/2000\n", + "Epoch 546/2000\n", + "Epoch 547/2000\n", + "Epoch 548/2000\n", + "Epoch 549/2000\n", + "Epoch 550/2000\n", + "Epoch 551/2000\n", + "Epoch 552/2000\n", + "Epoch 553/2000\n", + "Epoch 554/2000\n", + "Epoch 555/2000\n", + "Epoch 556/2000\n", + "Epoch 557/2000\n", + "Epoch 558/2000\n", + "Epoch 559/2000\n", + "Epoch 560/2000\n", + "Epoch 561/2000\n", + "Epoch 562/2000\n", + "Epoch 563/2000\n", + "Epoch 564/2000\n", + "Epoch 565/2000\n", + "Epoch 566/2000\n", + "Epoch 567/2000\n", + "Epoch 568/2000\n", + "Epoch 569/2000\n", + "Epoch 570/2000\n", + "Epoch 571/2000\n", + "Epoch 572/2000\n", + "Epoch 573/2000\n", + "Epoch 574/2000\n", + "Epoch 575/2000\n", + "Epoch 576/2000\n", + "Epoch 577/2000\n", + "Epoch 578/2000\n", + "Epoch 579/2000\n", + "Epoch 580/2000\n", + "Epoch 581/2000\n", + "Epoch 582/2000\n", + "Epoch 583/2000\n", + "Epoch 584/2000\n", + "Epoch 585/2000\n", + "Epoch 586/2000\n", + "Epoch 587/2000\n", + "Epoch 588/2000\n", + "Epoch 589/2000\n", + "Epoch 590/2000\n", + "Epoch 591/2000\n", + "Epoch 592/2000\n", + "Epoch 593/2000\n", + "Epoch 594/2000\n", + "Epoch 595/2000\n", + "Epoch 596/2000\n", + "Epoch 597/2000\n", + "Epoch 598/2000\n", + "Epoch 599/2000\n", + "Epoch 600/2000\n", + "Epoch 601/2000\n", + "Epoch 602/2000\n", + "Epoch 603/2000\n", + "Epoch 604/2000\n", + "Epoch 605/2000\n", + "Epoch 606/2000\n", + "Epoch 607/2000\n", + "Epoch 608/2000\n", + "Epoch 609/2000\n", + "Epoch 610/2000\n", + "Epoch 611/2000\n", + "Epoch 612/2000\n", + "Epoch 613/2000\n", + "Epoch 614/2000\n", + "Epoch 615/2000\n", + "Epoch 616/2000\n", + "Epoch 617/2000\n", + "Epoch 618/2000\n", + "Epoch 619/2000\n", + "Epoch 620/2000\n", + "Epoch 621/2000\n", + "Epoch 622/2000\n", + "Epoch 623/2000\n", + "Epoch 624/2000\n", + "Epoch 625/2000\n", + "Epoch 626/2000\n", + "Epoch 627/2000\n", + "Epoch 628/2000\n", + "Epoch 629/2000\n", + "Epoch 630/2000\n", + "Epoch 631/2000\n", + "Epoch 632/2000\n", + "Epoch 633/2000\n", + "Epoch 634/2000\n", + "Epoch 635/2000\n", + "Epoch 636/2000\n", + "Epoch 637/2000\n", + "Epoch 638/2000\n", + "Epoch 639/2000\n", + "Epoch 640/2000\n", + "Epoch 641/2000\n", + "Epoch 642/2000\n", + "Epoch 643/2000\n", + "Epoch 644/2000\n", + "Epoch 645/2000\n", + "Epoch 646/2000\n", + "Epoch 647/2000\n", + "Epoch 648/2000\n", + "Epoch 649/2000\n", + "Epoch 650/2000\n", + "Epoch 651/2000\n", + "Epoch 652/2000\n", + "Epoch 653/2000\n", + "Epoch 654/2000\n", + "Epoch 655/2000\n", + "Epoch 656/2000\n", + "Epoch 657/2000\n", + "Epoch 658/2000\n", + "Epoch 659/2000\n", + "Epoch 660/2000\n", + "Epoch 661/2000\n", + "Epoch 662/2000\n", + "Epoch 663/2000\n", + "Epoch 664/2000\n", + "Epoch 665/2000\n", + "Epoch 666/2000\n", + "Epoch 667/2000\n", + "Epoch 668/2000\n", + "Epoch 669/2000\n", + "Epoch 670/2000\n", + "Epoch 671/2000\n", + "Epoch 672/2000\n", + "Epoch 673/2000\n", + "Epoch 674/2000\n", + "Epoch 675/2000\n", + "Epoch 676/2000\n", + "Epoch 677/2000\n", + "Epoch 678/2000\n", + "Epoch 679/2000\n", + "Epoch 680/2000\n", + "Epoch 681/2000\n", + "Epoch 682/2000\n", + "Epoch 683/2000\n", + "Epoch 684/2000\n", + "Epoch 685/2000\n", + "Epoch 686/2000\n", + "Epoch 687/2000\n", + "Epoch 688/2000\n", + "Epoch 689/2000\n", + "Epoch 690/2000\n", + "Epoch 691/2000\n", + "Epoch 692/2000\n", + "Epoch 693/2000\n", + "Epoch 694/2000\n", + "Epoch 695/2000\n", + "Epoch 696/2000\n", + "Epoch 697/2000\n", + "Epoch 698/2000\n", + "Epoch 699/2000\n", + "Epoch 700/2000\n", + "Epoch 701/2000\n", + "Epoch 702/2000\n", + "Epoch 703/2000\n", + "Epoch 704/2000\n", + "Epoch 705/2000\n", + "Epoch 706/2000\n", + "Epoch 707/2000\n", + "Epoch 708/2000\n", + "Epoch 709/2000\n", + "Epoch 710/2000\n", + "Epoch 711/2000\n", + "Epoch 712/2000\n", + "Epoch 713/2000\n", + "Epoch 714/2000\n", + "Epoch 715/2000\n", + "Epoch 716/2000\n", + "Epoch 717/2000\n", + "Epoch 718/2000\n", + "Epoch 719/2000\n", + "Epoch 720/2000\n", + "Epoch 721/2000\n", + "Epoch 722/2000\n", + "Epoch 723/2000\n", + "Epoch 724/2000\n", + "Epoch 725/2000\n", + "Epoch 726/2000\n", + "Epoch 727/2000\n", + "Epoch 728/2000\n", + "Epoch 729/2000\n", + "Epoch 730/2000\n", + "Epoch 731/2000\n", + "Epoch 732/2000\n", + "Epoch 733/2000\n", + "Epoch 734/2000\n", + "Epoch 735/2000\n", + "Epoch 736/2000\n", + "Epoch 737/2000\n", + "Epoch 738/2000\n", + "Epoch 739/2000\n", + "Epoch 740/2000\n", + "Epoch 741/2000\n", + "Epoch 742/2000\n", + "Epoch 743/2000\n", + "Epoch 744/2000\n", + "Epoch 745/2000\n", + "Epoch 746/2000\n", + "Epoch 747/2000\n", + "Epoch 748/2000\n", + "Epoch 749/2000\n", + "Epoch 750/2000\n", + "Epoch 751/2000\n", + "Epoch 752/2000\n", + "Epoch 753/2000\n", + "Epoch 754/2000\n", + "Epoch 755/2000\n", + "Epoch 756/2000\n", + "Epoch 757/2000\n", + "Epoch 758/2000\n", + "Epoch 759/2000\n", + "Epoch 760/2000\n", + "Epoch 761/2000\n", + "Epoch 762/2000\n", + "Epoch 763/2000\n", + "Epoch 764/2000\n", + "Epoch 765/2000\n", + "Epoch 766/2000\n", + "Epoch 767/2000\n", + "Epoch 768/2000\n", + "Epoch 769/2000\n", + "Epoch 770/2000\n", + "Epoch 771/2000\n", + "Epoch 772/2000\n", + "Epoch 773/2000\n", + "Epoch 774/2000\n", + "Epoch 775/2000\n", + "Epoch 776/2000\n", + "Epoch 777/2000\n", + "Epoch 778/2000\n", + "Epoch 779/2000\n", + "Epoch 780/2000\n", + "Epoch 781/2000\n", + "Epoch 782/2000\n", + "Epoch 783/2000\n", + "Epoch 784/2000\n", + "Epoch 785/2000\n", + "Epoch 786/2000\n", + "Epoch 787/2000\n", + "Epoch 788/2000\n", + "Epoch 789/2000\n", + "Epoch 790/2000\n", + "Epoch 791/2000\n", + "Epoch 792/2000\n", + "Epoch 793/2000\n", + "Epoch 794/2000\n", + "Epoch 795/2000\n", + "Epoch 796/2000\n", + "Epoch 797/2000\n", + "Epoch 798/2000\n", + "Epoch 799/2000\n", + "Epoch 800/2000\n", + "Epoch 801/2000\n", + "Epoch 802/2000\n", + "Epoch 803/2000\n", + "Epoch 804/2000\n", + "Epoch 805/2000\n", + "Epoch 806/2000\n", + "Epoch 807/2000\n", + "Epoch 808/2000\n", + "Epoch 809/2000\n", + "Epoch 810/2000\n", + "Epoch 811/2000\n", + "Epoch 812/2000\n", + "Epoch 813/2000\n", + "Epoch 814/2000\n", + "Epoch 815/2000\n", + "Epoch 816/2000\n", + "Epoch 817/2000\n", + "Epoch 818/2000\n", + "Epoch 819/2000\n", + "Epoch 820/2000\n", + "Epoch 821/2000\n", + "Epoch 822/2000\n", + "Epoch 823/2000\n", + "Epoch 824/2000\n", + "Epoch 825/2000\n", + "Epoch 826/2000\n", + "Epoch 827/2000\n", + "Epoch 828/2000\n", + "Epoch 829/2000\n", + "Epoch 830/2000\n", + "Epoch 831/2000\n", + "Epoch 832/2000\n", + "Epoch 833/2000\n", + "Epoch 834/2000\n", + "Epoch 835/2000\n", + "Epoch 836/2000\n", + "Epoch 837/2000\n", + "Epoch 838/2000\n", + "Epoch 839/2000\n", + "Epoch 840/2000\n", + "Epoch 841/2000\n", + "Epoch 842/2000\n", + "Epoch 843/2000\n", + "Epoch 844/2000\n", + "Epoch 845/2000\n", + "Epoch 846/2000\n", + "Epoch 847/2000\n", + "Epoch 848/2000\n", + "Epoch 849/2000\n", + "Epoch 850/2000\n", + "Epoch 851/2000\n", + "Epoch 852/2000\n", + "Epoch 853/2000\n", + "Epoch 854/2000\n", + "Epoch 855/2000\n", + "Epoch 856/2000\n", + "Epoch 857/2000\n", + "Epoch 858/2000\n", + "Epoch 859/2000\n", + "Epoch 860/2000\n", + "Epoch 861/2000\n", + "Epoch 862/2000\n", + "Epoch 863/2000\n", + "Epoch 864/2000\n", + "Epoch 865/2000\n", + "Epoch 866/2000\n", + "Epoch 867/2000\n", + "Epoch 868/2000\n", + "Epoch 869/2000\n", + "Epoch 870/2000\n", + "Epoch 871/2000\n", + "Epoch 872/2000\n", + "Epoch 873/2000\n", + "Epoch 874/2000\n", + "Epoch 875/2000\n", + "Epoch 876/2000\n", + "Epoch 877/2000\n", + "Epoch 878/2000\n", + "Epoch 879/2000\n", + "Epoch 880/2000\n", + "Epoch 881/2000\n", + "Epoch 882/2000\n", + "Epoch 883/2000\n", + "Epoch 884/2000\n", + "Epoch 885/2000\n", + "Epoch 886/2000\n", + "Epoch 887/2000\n", + "Epoch 888/2000\n", + "Epoch 889/2000\n", + "Epoch 890/2000\n", + "Epoch 891/2000\n", + "Epoch 892/2000\n", + "Epoch 893/2000\n", + "Epoch 894/2000\n", + "Epoch 895/2000\n", + "Epoch 896/2000\n", + "Epoch 897/2000\n", + "Epoch 898/2000\n", + "Epoch 899/2000\n", + "Epoch 900/2000\n", + "Epoch 901/2000\n", + "Epoch 902/2000\n", + "Epoch 903/2000\n", + "Epoch 904/2000\n", + "Epoch 905/2000\n", + "Epoch 906/2000\n", + "Epoch 907/2000\n", + "Epoch 908/2000\n", + "Epoch 909/2000\n", + "Epoch 910/2000\n", + "Epoch 911/2000\n", + "Epoch 912/2000\n", + "Epoch 913/2000\n", + "Epoch 914/2000\n", + "Epoch 915/2000\n", + "Epoch 916/2000\n", + "Epoch 917/2000\n", + "Epoch 918/2000\n", + "Epoch 919/2000\n", + "Epoch 920/2000\n", + "Epoch 921/2000\n", + "Epoch 922/2000\n", + "Epoch 923/2000\n", + "Epoch 924/2000\n", + "Epoch 925/2000\n", + "Epoch 926/2000\n", + "Epoch 927/2000\n", + "Epoch 928/2000\n", + "Epoch 929/2000\n", + "Epoch 930/2000\n", + "Epoch 931/2000\n", + "Epoch 932/2000\n", + "Epoch 933/2000\n", + "Epoch 934/2000\n", + "Epoch 935/2000\n", + "Epoch 936/2000\n", + "Epoch 937/2000\n", + "Epoch 938/2000\n", + "Epoch 939/2000\n", + "Epoch 940/2000\n", + "Epoch 941/2000\n", + "Epoch 942/2000\n", + "Epoch 943/2000\n", + "Epoch 944/2000\n", + "Epoch 945/2000\n", + "Epoch 946/2000\n", + "Epoch 947/2000\n", + "Epoch 948/2000\n", + "Epoch 949/2000\n", + "Epoch 950/2000\n", + "Epoch 951/2000\n", + "Epoch 952/2000\n", + "Epoch 953/2000\n", + "Epoch 954/2000\n", + "Epoch 955/2000\n", + "Epoch 956/2000\n", + "Epoch 957/2000\n", + "Epoch 958/2000\n", + "Epoch 959/2000\n", + "Epoch 960/2000\n", + "Epoch 961/2000\n", + "Epoch 962/2000\n", + "Epoch 963/2000\n", + "Epoch 964/2000\n", + "Epoch 965/2000\n", + "Epoch 966/2000\n", + "Epoch 967/2000\n", + "Epoch 968/2000\n", + "Epoch 969/2000\n", + "Epoch 970/2000\n", + "Epoch 971/2000\n", + "Epoch 972/2000\n", + "Epoch 973/2000\n", + "Epoch 974/2000\n", + "Epoch 975/2000\n", + "Epoch 976/2000\n", + "Epoch 977/2000\n", + "Epoch 978/2000\n", + "Epoch 979/2000\n", + "Epoch 980/2000\n", + "Epoch 981/2000\n", + "Epoch 982/2000\n", + "Epoch 983/2000\n", + "Epoch 984/2000\n", + "Epoch 985/2000\n", + "Epoch 986/2000\n", + "Epoch 987/2000\n", + "Epoch 988/2000\n", + "Epoch 989/2000\n", + "Epoch 990/2000\n", + "Epoch 991/2000\n", + "Epoch 992/2000\n", + "Epoch 993/2000\n", + "Epoch 994/2000\n", + "Epoch 995/2000\n", + "Epoch 996/2000\n", + "Epoch 997/2000\n", + "Epoch 998/2000\n", + "Epoch 999/2000\n", + "Epoch 1000/2000\n", + "Epoch 1001/2000\n", + "Epoch 1002/2000\n", + "Epoch 1003/2000\n", + "Epoch 1004/2000\n", + "Epoch 1005/2000\n", + "Epoch 1006/2000\n", + "Epoch 1007/2000\n", + "Epoch 1008/2000\n", + "Epoch 1009/2000\n", + "Epoch 1010/2000\n", + "Epoch 1011/2000\n", + "Epoch 1012/2000\n", + "Epoch 1013/2000\n", + "Epoch 1014/2000\n", + "Epoch 1015/2000\n", + "Epoch 1016/2000\n", + "Epoch 1017/2000\n", + "Epoch 1018/2000\n", + "Epoch 1019/2000\n", + "Epoch 1020/2000\n", + "Epoch 1021/2000\n", + "Epoch 1022/2000\n", + "Epoch 1023/2000\n", + "Epoch 1024/2000\n", + "Epoch 1025/2000\n", + "Epoch 1026/2000\n", + "Epoch 1027/2000\n", + "Epoch 1028/2000\n", + "Epoch 1029/2000\n", + "Epoch 1030/2000\n", + "Epoch 1031/2000\n", + "Epoch 1032/2000\n", + "Epoch 1033/2000\n", + "Epoch 1034/2000\n", + "Epoch 1035/2000\n", + "Epoch 1036/2000\n", + "Epoch 1037/2000\n", + "Epoch 1038/2000\n", + "Epoch 1039/2000\n", + "Epoch 1040/2000\n", + "Epoch 1041/2000\n", + "Epoch 1042/2000\n", + "Epoch 1043/2000\n", + "Epoch 1044/2000\n", + "Epoch 1045/2000\n", + "Epoch 1046/2000\n", + "Epoch 1047/2000\n", + "Epoch 1048/2000\n", + "Epoch 1049/2000\n", + "Epoch 1050/2000\n", + "Epoch 1051/2000\n", + "Epoch 1052/2000\n", + "Epoch 1053/2000\n", + "Epoch 1054/2000\n", + "Epoch 1055/2000\n", + "Epoch 1056/2000\n", + "Epoch 1057/2000\n", + "Epoch 1058/2000\n", + "Epoch 1059/2000\n", + "Epoch 1060/2000\n", + "Epoch 1061/2000\n", + "Epoch 1062/2000\n", + "Epoch 1063/2000\n", + "Epoch 1064/2000\n", + "Epoch 1065/2000\n", + "Epoch 1066/2000\n", + "Epoch 1067/2000\n", + "Epoch 1068/2000\n", + "Epoch 1069/2000\n", + "Epoch 1070/2000\n", + "Epoch 1071/2000\n", + "Epoch 1072/2000\n", + "Epoch 1073/2000\n", + "Epoch 1074/2000\n", + "Epoch 1075/2000\n", + "Epoch 1076/2000\n", + "Epoch 1077/2000\n", + "Epoch 1078/2000\n", + "Epoch 1079/2000\n", + "Epoch 1080/2000\n", + "Epoch 1081/2000\n", + "Epoch 1082/2000\n", + "Epoch 1083/2000\n", + "Epoch 1084/2000\n", + "Epoch 1085/2000\n", + "Epoch 1086/2000\n", + "Epoch 1087/2000\n", + "Epoch 1088/2000\n", + "Epoch 1089/2000\n", + "Epoch 1090/2000\n", + "Epoch 1091/2000\n", + "Epoch 1092/2000\n", + "Epoch 1093/2000\n", + "Epoch 1094/2000\n", + "Epoch 1095/2000\n", + "Epoch 1096/2000\n", + "Epoch 1097/2000\n", + "Epoch 1098/2000\n", + "Epoch 1099/2000\n", + "Epoch 1100/2000\n", + "Epoch 1101/2000\n", + "Epoch 1102/2000\n", + "Epoch 1103/2000\n", + "Epoch 1104/2000\n", + "Epoch 1105/2000\n", + "Epoch 1106/2000\n", + "Epoch 1107/2000\n", + "Epoch 1108/2000\n", + "Epoch 1109/2000\n", + "Epoch 1110/2000\n", + "Epoch 1111/2000\n", + "Epoch 1112/2000\n", + "Epoch 1113/2000\n", + "Epoch 1114/2000\n", + "Epoch 1115/2000\n", + "Epoch 1116/2000\n", + "Epoch 1117/2000\n", + "Epoch 1118/2000\n", + "Epoch 1119/2000\n", + "Epoch 1120/2000\n", + "Epoch 1121/2000\n", + "Epoch 1122/2000\n", + "Epoch 1123/2000\n", + "Epoch 1124/2000\n", + "Epoch 1125/2000\n", + "Epoch 1126/2000\n", + "Epoch 1127/2000\n", + "Epoch 1128/2000\n", + "Epoch 1129/2000\n", + "Epoch 1130/2000\n", + "Epoch 1131/2000\n", + "Epoch 1132/2000\n", + "Epoch 1133/2000\n", + "Epoch 1134/2000\n", + "Epoch 1135/2000\n", + "Epoch 1136/2000\n", + "Epoch 1137/2000\n", + "Epoch 1138/2000\n", + "Epoch 1139/2000\n", + "Epoch 1140/2000\n", + "Epoch 1141/2000\n", + "Epoch 1142/2000\n", + "Epoch 1143/2000\n", + "Epoch 1144/2000\n", + "Epoch 1145/2000\n", + "Epoch 1146/2000\n", + "Epoch 1147/2000\n", + "Epoch 1148/2000\n", + "Epoch 1149/2000\n", + "Epoch 1150/2000\n", + "Epoch 1151/2000\n", + "Epoch 1152/2000\n", + "Epoch 1153/2000\n", + "Epoch 1154/2000\n", + "Epoch 1155/2000\n", + "Epoch 1156/2000\n", + "Epoch 1157/2000\n", + "Epoch 1158/2000\n", + "Epoch 1159/2000\n", + "Epoch 1160/2000\n", + "Epoch 1161/2000\n", + "Epoch 1162/2000\n", + "Epoch 1163/2000\n", + "Epoch 1164/2000\n", + "Epoch 1165/2000\n", + "Epoch 1166/2000\n", + "Epoch 1167/2000\n", + "Epoch 1168/2000\n", + "Epoch 1169/2000\n", + "Epoch 1170/2000\n", + "Epoch 1171/2000\n", + "Epoch 1172/2000\n", + "Epoch 1173/2000\n", + "Epoch 1174/2000\n", + "Epoch 1175/2000\n", + "Epoch 1176/2000\n", + "Epoch 1177/2000\n", + "Epoch 1178/2000\n", + "Epoch 1179/2000\n", + "Epoch 1180/2000\n", + "Epoch 1181/2000\n", + "Epoch 1182/2000\n", + "Epoch 1183/2000\n", + "Epoch 1184/2000\n", + "Epoch 1185/2000\n", + "Epoch 1186/2000\n", + "Epoch 1187/2000\n", + "Epoch 1188/2000\n", + "Epoch 1189/2000\n", + "Epoch 1190/2000\n", + "Epoch 1191/2000\n", + "Epoch 1192/2000\n", + "Epoch 1193/2000\n", + "Epoch 1194/2000\n", + "Epoch 1195/2000\n", + "Epoch 1196/2000\n", + "Epoch 1197/2000\n", + "Epoch 1198/2000\n", + "Epoch 1199/2000\n", + "Epoch 1200/2000\n", + "Epoch 1201/2000\n", + "Epoch 1202/2000\n", + "Epoch 1203/2000\n", + "Epoch 1204/2000\n", + "Epoch 1205/2000\n", + "Epoch 1206/2000\n", + "Epoch 1207/2000\n", + "Epoch 1208/2000\n", + "Epoch 1209/2000\n", + "Epoch 1210/2000\n", + "Epoch 1211/2000\n", + "Epoch 1212/2000\n", + "Epoch 1213/2000\n", + "Epoch 1214/2000\n", + "Epoch 1215/2000\n", + "Epoch 1216/2000\n", + "Epoch 1217/2000\n", + "Epoch 1218/2000\n", + "Epoch 1219/2000\n", + "Epoch 1220/2000\n", + "Epoch 1221/2000\n", + "Epoch 1222/2000\n", + "Epoch 1223/2000\n", + "Epoch 1224/2000\n", + "Epoch 1225/2000\n", + "Epoch 1226/2000\n", + "Epoch 1227/2000\n", + "Epoch 1228/2000\n", + "Epoch 1229/2000\n", + "Epoch 1230/2000\n", + "Epoch 1231/2000\n", + "Epoch 1232/2000\n", + "Epoch 1233/2000\n", + "Epoch 1234/2000\n", + "Epoch 1235/2000\n", + "Epoch 1236/2000\n", + "Epoch 1237/2000\n", + "Epoch 1238/2000\n", + "Epoch 1239/2000\n", + "Epoch 1240/2000\n", + "Epoch 1241/2000\n", + "Epoch 1242/2000\n", + "Epoch 1243/2000\n", + "Epoch 1244/2000\n", + "Epoch 1245/2000\n", + "Epoch 1246/2000\n", + "Epoch 1247/2000\n", + "Epoch 1248/2000\n", + "Epoch 1249/2000\n", + "Epoch 1250/2000\n", + "Epoch 1251/2000\n", + "Epoch 1252/2000\n", + "Epoch 1253/2000\n", + "Epoch 1254/2000\n", + "Epoch 1255/2000\n", + "Epoch 1256/2000\n", + "Epoch 1257/2000\n", + "Epoch 1258/2000\n", + "Epoch 1259/2000\n", + "Epoch 1260/2000\n", + "Epoch 1261/2000\n", + "Epoch 1262/2000\n", + "Epoch 1263/2000\n", + "Epoch 1264/2000\n", + "Epoch 1265/2000\n", + "Epoch 1266/2000\n", + "Epoch 1267/2000\n", + "Epoch 1268/2000\n", + "Epoch 1269/2000\n", + "Epoch 1270/2000\n", + "Epoch 1271/2000\n", + "Epoch 1272/2000\n", + "Epoch 1273/2000\n", + "Epoch 1274/2000\n", + "Epoch 1275/2000\n", + "Epoch 1276/2000\n", + "Epoch 1277/2000\n", + "Epoch 1278/2000\n", + "Epoch 1279/2000\n", + "Epoch 1280/2000\n", + "Epoch 1281/2000\n", + "Epoch 1282/2000\n", + "Epoch 1283/2000\n", + "Epoch 1284/2000\n", + "Epoch 1285/2000\n", + "Epoch 1286/2000\n", + "Epoch 1287/2000\n", + "Epoch 1288/2000\n", + "Epoch 1289/2000\n", + "Epoch 1290/2000\n", + "Epoch 1291/2000\n", + "Epoch 1292/2000\n", + "Epoch 1293/2000\n", + "Epoch 1294/2000\n", + "Epoch 1295/2000\n", + "Epoch 1296/2000\n", + "Epoch 1297/2000\n", + "Epoch 1298/2000\n", + "Epoch 1299/2000\n", + "Epoch 1300/2000\n", + "Epoch 1301/2000\n", + "Epoch 1302/2000\n", + "Epoch 1303/2000\n", + "Epoch 1304/2000\n", + "Epoch 1305/2000\n", + "Epoch 1306/2000\n", + "Epoch 1307/2000\n", + "Epoch 1308/2000\n", + "Epoch 1309/2000\n", + "Epoch 1310/2000\n", + "Epoch 1311/2000\n", + "Epoch 1312/2000\n", + "Epoch 1313/2000\n", + "Epoch 1314/2000\n", + "Epoch 1315/2000\n", + "Epoch 1316/2000\n", + "Epoch 1317/2000\n", + "Epoch 1318/2000\n", + "Epoch 1319/2000\n", + "Epoch 1320/2000\n", + "Epoch 1321/2000\n", + "Epoch 1322/2000\n", + "Epoch 1323/2000\n", + "Epoch 1324/2000\n", + "Epoch 1325/2000\n", + "Epoch 1326/2000\n", + "Epoch 1327/2000\n", + "Epoch 1328/2000\n", + "Epoch 1329/2000\n", + "Epoch 1330/2000\n", + "Epoch 1331/2000\n", + "Epoch 1332/2000\n", + "Epoch 1333/2000\n", + "Epoch 1334/2000\n", + "Epoch 1335/2000\n", + "Epoch 1336/2000\n", + "Epoch 1337/2000\n", + "Epoch 1338/2000\n", + "Epoch 1339/2000\n", + "Epoch 1340/2000\n", + "Epoch 1341/2000\n", + "Epoch 1342/2000\n", + "Epoch 1343/2000\n", + "Epoch 1344/2000\n", + "Epoch 1345/2000\n", + "Epoch 1346/2000\n", + "Epoch 1347/2000\n", + "Epoch 1348/2000\n", + "Epoch 1349/2000\n", + "Epoch 1350/2000\n", + "Epoch 1351/2000\n", + "Epoch 1352/2000\n", + "Epoch 1353/2000\n", + "Epoch 1354/2000\n", + "Epoch 1355/2000\n", + "Epoch 1356/2000\n", + "Epoch 1357/2000\n", + "Epoch 1358/2000\n", + "Epoch 1359/2000\n", + "Epoch 1360/2000\n", + "Epoch 1361/2000\n", + "Epoch 1362/2000\n", + "Epoch 1363/2000\n", + "Epoch 1364/2000\n", + "Epoch 1365/2000\n", + "Epoch 1366/2000\n", + "Epoch 1367/2000\n", + "Epoch 1368/2000\n", + "Epoch 1369/2000\n", + "Epoch 1370/2000\n", + "Epoch 1371/2000\n", + "Epoch 1372/2000\n", + "Epoch 1373/2000\n", + "Epoch 1374/2000\n", + "Epoch 1375/2000\n", + "Epoch 1376/2000\n", + "Epoch 1377/2000\n", + "Epoch 1378/2000\n", + "Epoch 1379/2000\n", + "Epoch 1380/2000\n", + "Epoch 1381/2000\n", + "Epoch 1382/2000\n", + "Epoch 1383/2000\n", + "Epoch 1384/2000\n", + "Epoch 1385/2000\n", + "Epoch 1386/2000\n", + "Epoch 1387/2000\n", + "Epoch 1388/2000\n", + "Epoch 1389/2000\n", + "Epoch 1390/2000\n", + "Epoch 1391/2000\n", + "Epoch 1392/2000\n", + "Epoch 1393/2000\n", + "Epoch 1394/2000\n", + "Epoch 1395/2000\n", + "Epoch 1396/2000\n", + "Epoch 1397/2000\n", + "Epoch 1398/2000\n", + "Epoch 1399/2000\n", + "Epoch 1400/2000\n", + "Epoch 1401/2000\n", + "Epoch 1402/2000\n", + "Epoch 1403/2000\n", + "Epoch 1404/2000\n", + "Epoch 1405/2000\n", + "Epoch 1406/2000\n", + "Epoch 1407/2000\n", + "Epoch 1408/2000\n", + "Epoch 1409/2000\n", + "Epoch 1410/2000\n", + "Epoch 1411/2000\n", + "Epoch 1412/2000\n", + "Epoch 1413/2000\n", + "Epoch 1414/2000\n", + "Epoch 1415/2000\n", + "Epoch 1416/2000\n", + "Epoch 1417/2000\n", + "Epoch 1418/2000\n", + "Epoch 1419/2000\n", + "Epoch 1420/2000\n", + "Epoch 1421/2000\n", + "Epoch 1422/2000\n", + "Epoch 1423/2000\n", + "Epoch 1424/2000\n", + "Epoch 1425/2000\n", + "Epoch 1426/2000\n", + "Epoch 1427/2000\n", + "Epoch 1428/2000\n", + "Epoch 1429/2000\n", + "Epoch 1430/2000\n", + "Epoch 1431/2000\n", + "Epoch 1432/2000\n", + "Epoch 1433/2000\n", + "Epoch 1434/2000\n", + "Epoch 1435/2000\n", + "Epoch 1436/2000\n", + "Epoch 1437/2000\n", + "Epoch 1438/2000\n", + "Epoch 1439/2000\n", + "Epoch 1440/2000\n", + "Epoch 1441/2000\n", + "Epoch 1442/2000\n", + "Epoch 1443/2000\n", + "Epoch 1444/2000\n", + "Epoch 1445/2000\n", + "Epoch 1446/2000\n", + "Epoch 1447/2000\n", + "Epoch 1448/2000\n", + "Epoch 1449/2000\n", + "Epoch 1450/2000\n", + "Epoch 1451/2000\n", + "Epoch 1452/2000\n", + "Epoch 1453/2000\n", + "Epoch 1454/2000\n", + "Epoch 1455/2000\n", + "Epoch 1456/2000\n", + "Epoch 1457/2000\n", + "Epoch 1458/2000\n", + "Epoch 1459/2000\n", + "Epoch 1460/2000\n", + "Epoch 1461/2000\n", + "Epoch 1462/2000\n", + "Epoch 1463/2000\n", + "Epoch 1464/2000\n", + "Epoch 1465/2000\n", + "Epoch 1466/2000\n", + "Epoch 1467/2000\n", + "Epoch 1468/2000\n", + "Epoch 1469/2000\n", + "Epoch 1470/2000\n", + "Epoch 1471/2000\n", + "Epoch 1472/2000\n", + "Epoch 1473/2000\n", + "Epoch 1474/2000\n", + "Epoch 1475/2000\n", + "Epoch 1476/2000\n", + "Epoch 1477/2000\n", + "Epoch 1478/2000\n", + "Epoch 1479/2000\n", + "Epoch 1480/2000\n", + "Epoch 1481/2000\n", + "Epoch 1482/2000\n", + "Epoch 1483/2000\n", + "Epoch 1484/2000\n", + "Epoch 1485/2000\n", + "Epoch 1486/2000\n", + "Epoch 1487/2000\n", + "Epoch 1488/2000\n", + "Epoch 1489/2000\n", + "Epoch 1490/2000\n", + "Epoch 1491/2000\n", + "Epoch 1492/2000\n", + "Epoch 1493/2000\n", + "Epoch 1494/2000\n", + "Epoch 1495/2000\n", + "Epoch 1496/2000\n", + "Epoch 1497/2000\n", + "Epoch 1498/2000\n", + "Epoch 1499/2000\n", + "Epoch 1500/2000\n", + "Epoch 1501/2000\n", + "Epoch 1502/2000\n", + "Epoch 1503/2000\n", + "Epoch 1504/2000\n", + "Epoch 1505/2000\n", + "Epoch 1506/2000\n", + "Epoch 1507/2000\n", + "Epoch 1508/2000\n", + "Epoch 1509/2000\n", + "Epoch 1510/2000\n", + "Epoch 1511/2000\n", + "Epoch 1512/2000\n", + "Epoch 1513/2000\n", + "Epoch 1514/2000\n", + "Epoch 1515/2000\n", + "Epoch 1516/2000\n", + "Epoch 1517/2000\n", + "Epoch 1518/2000\n", + "Epoch 1519/2000\n", + "Epoch 1520/2000\n", + "Epoch 1521/2000\n", + "Epoch 1522/2000\n", + "Epoch 1523/2000\n", + "Epoch 1524/2000\n", + "Epoch 1525/2000\n", + "Epoch 1526/2000\n", + "Epoch 1527/2000\n", + "Epoch 1528/2000\n", + "Epoch 1529/2000\n", + "Epoch 1530/2000\n", + "Epoch 1531/2000\n", + "Epoch 1532/2000\n", + "Epoch 1533/2000\n", + "Epoch 1534/2000\n", + "Epoch 1535/2000\n", + "Epoch 1536/2000\n", + "Epoch 1537/2000\n", + "Epoch 1538/2000\n", + "Epoch 1539/2000\n", + "Epoch 1540/2000\n", + "Epoch 1541/2000\n", + "Epoch 1542/2000\n", + "Epoch 1543/2000\n", + "Epoch 1544/2000\n", + "Epoch 1545/2000\n", + "Epoch 1546/2000\n", + "Epoch 1547/2000\n", + "Epoch 1548/2000\n", + "Epoch 1549/2000\n", + "Epoch 1550/2000\n", + "Epoch 1551/2000\n", + "Epoch 1552/2000\n", + "Epoch 1553/2000\n", + "Epoch 1554/2000\n", + "Epoch 1555/2000\n", + "Epoch 1556/2000\n", + "Epoch 1557/2000\n", + "Epoch 1558/2000\n", + "Epoch 1559/2000\n", + "Epoch 1560/2000\n", + "Epoch 1561/2000\n", + "Epoch 1562/2000\n", + "Epoch 1563/2000\n", + "Epoch 1564/2000\n", + "Epoch 1565/2000\n", + "Epoch 1566/2000\n", + "Epoch 1567/2000\n", + "Epoch 1568/2000\n", + "Epoch 1569/2000\n", + "Epoch 1570/2000\n", + "Epoch 1571/2000\n", + "Epoch 1572/2000\n", + "Epoch 1573/2000\n", + "Epoch 1574/2000\n", + "Epoch 1575/2000\n", + "Epoch 1576/2000\n", + "Epoch 1577/2000\n", + "Epoch 1578/2000\n", + "Epoch 1579/2000\n", + "Epoch 1580/2000\n", + "Epoch 1581/2000\n", + "Epoch 1582/2000\n", + "Epoch 1583/2000\n", + "Epoch 1584/2000\n", + "Epoch 1585/2000\n", + "Epoch 1586/2000\n", + "Epoch 1587/2000\n", + "Epoch 1588/2000\n", + "Epoch 1589/2000\n", + "Epoch 1590/2000\n", + "Epoch 1591/2000\n", + "Epoch 1592/2000\n", + "Epoch 1593/2000\n", + "Epoch 1594/2000\n", + "Epoch 1595/2000\n", + "Epoch 1596/2000\n", + "Epoch 1597/2000\n", + "Epoch 1598/2000\n", + "Epoch 1599/2000\n", + "Epoch 1600/2000\n", + "Epoch 1601/2000\n", + "Epoch 1602/2000\n", + "Epoch 1603/2000\n", + "Epoch 1604/2000\n", + "Epoch 1605/2000\n", + "Epoch 1606/2000\n", + "Epoch 1607/2000\n", + "Epoch 1608/2000\n", + "Epoch 1609/2000\n", + "Epoch 1610/2000\n", + "Epoch 1611/2000\n", + "Epoch 1612/2000\n", + "Epoch 1613/2000\n", + "Epoch 1614/2000\n", + "Epoch 1615/2000\n", + "Epoch 1616/2000\n", + "Epoch 1617/2000\n", + "Epoch 1618/2000\n", + "Epoch 1619/2000\n", + "Epoch 1620/2000\n", + "Epoch 1621/2000\n", + "Epoch 1622/2000\n", + "Epoch 1623/2000\n", + "Epoch 1624/2000\n", + "Epoch 1625/2000\n", + "Epoch 1626/2000\n", + "Epoch 1627/2000\n", + "Epoch 1628/2000\n", + "Epoch 1629/2000\n", + "Epoch 1630/2000\n", + "Epoch 1631/2000\n", + "Epoch 1632/2000\n", + "Epoch 1633/2000\n", + "Epoch 1634/2000\n", + "Epoch 1635/2000\n", + "Epoch 1636/2000\n", + "Epoch 1637/2000\n", + "Epoch 1638/2000\n", + "Epoch 1639/2000\n", + "Epoch 1640/2000\n", + "Epoch 1641/2000\n", + "Epoch 1642/2000\n", + "Epoch 1643/2000\n", + "Epoch 1644/2000\n", + "Epoch 1645/2000\n", + "Epoch 1646/2000\n", + "Epoch 1647/2000\n", + "Epoch 1648/2000\n", + "Epoch 1649/2000\n", + "Epoch 1650/2000\n", + "Epoch 1651/2000\n", + "Epoch 1652/2000\n", + "Epoch 1653/2000\n", + "Epoch 1654/2000\n", + "Epoch 1655/2000\n", + "Epoch 1656/2000\n", + "Epoch 1657/2000\n", + "Epoch 1658/2000\n", + "Epoch 1659/2000\n", + "Epoch 1660/2000\n", + "Epoch 1661/2000\n", + "Epoch 1662/2000\n", + "Epoch 1663/2000\n", + "Epoch 1664/2000\n", + "Epoch 1665/2000\n", + "Epoch 1666/2000\n", + "Epoch 1667/2000\n", + "Epoch 1668/2000\n", + "Epoch 1669/2000\n", + "Epoch 1670/2000\n", + "Epoch 1671/2000\n", + "Epoch 1672/2000\n", + "Epoch 1673/2000\n", + "Epoch 1674/2000\n", + "Epoch 1675/2000\n", + "Epoch 1676/2000\n", + "Epoch 1677/2000\n", + "Epoch 1678/2000\n", + "Epoch 1679/2000\n", + "Epoch 1680/2000\n", + "Epoch 1681/2000\n", + "Epoch 1682/2000\n", + "Epoch 1683/2000\n", + "Epoch 1684/2000\n", + "Epoch 1685/2000\n", + "Epoch 1686/2000\n", + "Epoch 1687/2000\n", + "Epoch 1688/2000\n", + "Epoch 1689/2000\n", + "Epoch 1690/2000\n", + "Epoch 1691/2000\n", + "Epoch 1692/2000\n", + "Epoch 1693/2000\n", + "Epoch 1694/2000\n", + "Epoch 1695/2000\n", + "Epoch 1696/2000\n", + "Epoch 1697/2000\n", + "Epoch 1698/2000\n", + "Epoch 1699/2000\n", + "Epoch 1700/2000\n", + "Epoch 1701/2000\n", + "Epoch 1702/2000\n", + "Epoch 1703/2000\n", + "Epoch 1704/2000\n", + "Epoch 1705/2000\n", + "Epoch 1706/2000\n", + "Epoch 1707/2000\n", + "Epoch 1708/2000\n", + "Epoch 1709/2000\n", + "Epoch 1710/2000\n", + "Epoch 1711/2000\n", + "Epoch 1712/2000\n", + "Epoch 1713/2000\n", + "Epoch 1714/2000\n", + "Epoch 1715/2000\n", + "Epoch 1716/2000\n", + "Epoch 1717/2000\n", + "Epoch 1718/2000\n", + "Epoch 1719/2000\n", + "Epoch 1720/2000\n", + "Epoch 1721/2000\n", + "Epoch 1722/2000\n", + "Epoch 1723/2000\n", + "Epoch 1724/2000\n", + "Epoch 1725/2000\n", + "Epoch 1726/2000\n", + "Epoch 1727/2000\n", + "Epoch 1728/2000\n", + "Epoch 1729/2000\n", + "Epoch 1730/2000\n", + "Epoch 1731/2000\n", + "Epoch 1732/2000\n", + "Epoch 1733/2000\n", + "Epoch 1734/2000\n", + "Epoch 1735/2000\n", + "Epoch 1736/2000\n", + "Epoch 1737/2000\n", + "Epoch 1738/2000\n", + "Epoch 1739/2000\n", + "Epoch 1740/2000\n", + "Epoch 1741/2000\n", + "Epoch 1742/2000\n", + "Epoch 1743/2000\n", + "Epoch 1744/2000\n", + "Epoch 1745/2000\n", + "Epoch 1746/2000\n", + "Epoch 1747/2000\n", + "Epoch 1748/2000\n", + "Epoch 1749/2000\n", + "Epoch 1750/2000\n", + "Epoch 1751/2000\n", + "Epoch 1752/2000\n", + "Epoch 1753/2000\n", + "Epoch 1754/2000\n", + "Epoch 1755/2000\n", + "Epoch 1756/2000\n", + "Epoch 1757/2000\n", + "Epoch 1758/2000\n", + "Epoch 1759/2000\n", + "Epoch 1760/2000\n", + "Epoch 1761/2000\n", + "Epoch 1762/2000\n", + "Epoch 1763/2000\n", + "Epoch 1764/2000\n", + "Epoch 1765/2000\n", + "Epoch 1766/2000\n", + "Epoch 1767/2000\n", + "Epoch 1768/2000\n", + "Epoch 1769/2000\n", + "Epoch 1770/2000\n", + "Epoch 1771/2000\n", + "Epoch 1772/2000\n", + "Epoch 1773/2000\n", + "Epoch 1774/2000\n", + "Epoch 1775/2000\n", + "Epoch 1776/2000\n", + "Epoch 1777/2000\n", + "Epoch 1778/2000\n", + "Epoch 1779/2000\n", + "Epoch 1780/2000\n", + "Epoch 1781/2000\n", + "Epoch 1782/2000\n", + "Epoch 1783/2000\n", + "Epoch 1784/2000\n", + "Epoch 1785/2000\n", + "Epoch 1786/2000\n", + "Epoch 1787/2000\n", + "Epoch 1788/2000\n", + "Epoch 1789/2000\n", + "Epoch 1790/2000\n", + "Epoch 1791/2000\n", + "Epoch 1792/2000\n", + "Epoch 1793/2000\n", + "Epoch 1794/2000\n", + "Epoch 1795/2000\n", + "Epoch 1796/2000\n", + "Epoch 1797/2000\n", + "Epoch 1798/2000\n", + "Epoch 1799/2000\n", + "Epoch 1800/2000\n", + "Epoch 1801/2000\n", + "Epoch 1802/2000\n", + "Epoch 1803/2000\n", + "Epoch 1804/2000\n", + "Epoch 1805/2000\n", + "Epoch 1806/2000\n", + "Epoch 1807/2000\n", + "Epoch 1808/2000\n", + "Epoch 1809/2000\n", + "Epoch 1810/2000\n", + "Epoch 1811/2000\n", + "Epoch 1812/2000\n", + "Epoch 1813/2000\n", + "Epoch 1814/2000\n", + "Epoch 1815/2000\n", + "Epoch 1816/2000\n", + "Epoch 1817/2000\n", + "Epoch 1818/2000\n", + "Epoch 1819/2000\n", + "Epoch 1820/2000\n", + "Epoch 1821/2000\n", + "Epoch 1822/2000\n", + "Epoch 1823/2000\n", + "Epoch 1824/2000\n", + "Epoch 1825/2000\n", + "Epoch 1826/2000\n", + "Epoch 1827/2000\n", + "Epoch 1828/2000\n", + "Epoch 1829/2000\n", + "Epoch 1830/2000\n", + "Epoch 1831/2000\n", + "Epoch 1832/2000\n", + "Epoch 1833/2000\n", + "Epoch 1834/2000\n", + "Epoch 1835/2000\n", + "Epoch 1836/2000\n", + "Epoch 1837/2000\n", + "Epoch 1838/2000\n", + "Epoch 1839/2000\n", + "Epoch 1840/2000\n", + "Epoch 1841/2000\n", + "Epoch 1842/2000\n", + "Epoch 1843/2000\n", + "Epoch 1844/2000\n", + "Epoch 1845/2000\n", + "Epoch 1846/2000\n", + "Epoch 1847/2000\n", + "Epoch 1848/2000\n", + "Epoch 1849/2000\n", + "Epoch 1850/2000\n", + "Epoch 1851/2000\n", + "Epoch 1852/2000\n", + "Epoch 1853/2000\n", + "Epoch 1854/2000\n", + "Epoch 1855/2000\n", + "Epoch 1856/2000\n", + "Epoch 1857/2000\n", + "Epoch 1858/2000\n", + "Epoch 1859/2000\n", + "Epoch 1860/2000\n", + "Epoch 1861/2000\n", + "Epoch 1862/2000\n", + "Epoch 1863/2000\n", + "Epoch 1864/2000\n", + "Epoch 1865/2000\n", + "Epoch 1866/2000\n", + "Epoch 1867/2000\n", + "Epoch 1868/2000\n", + "Epoch 1869/2000\n", + "Epoch 1870/2000\n", + "Epoch 1871/2000\n", + "Epoch 1872/2000\n", + "Epoch 1873/2000\n", + "Epoch 1874/2000\n", + "Epoch 1875/2000\n", + "Epoch 1876/2000\n", + "Epoch 1877/2000\n", + "Epoch 1878/2000\n", + "Epoch 1879/2000\n", + "Epoch 1880/2000\n", + "Epoch 1881/2000\n", + "Epoch 1882/2000\n", + "Epoch 1883/2000\n", + "Epoch 1884/2000\n", + "Epoch 1885/2000\n", + "Epoch 1886/2000\n", + "Epoch 1887/2000\n", + "Epoch 1888/2000\n", + "Epoch 1889/2000\n", + "Epoch 1890/2000\n", + "Epoch 1891/2000\n", + "Epoch 1892/2000\n", + "Epoch 1893/2000\n", + "Epoch 1894/2000\n", + "Epoch 1895/2000\n", + "Epoch 1896/2000\n", + "Epoch 1897/2000\n", + "Epoch 1898/2000\n", + "Epoch 1899/2000\n", + "Epoch 1900/2000\n", + "Epoch 1901/2000\n", + "Epoch 1902/2000\n", + "Epoch 1903/2000\n", + "Epoch 1904/2000\n", + "Epoch 1905/2000\n", + "Epoch 1906/2000\n", + "Epoch 1907/2000\n", + "Epoch 1908/2000\n", + "Epoch 1909/2000\n", + "Epoch 1910/2000\n", + "Epoch 1911/2000\n", + "Epoch 1912/2000\n", + "Epoch 1913/2000\n", + "Epoch 1914/2000\n", + "Epoch 1915/2000\n", + "Epoch 1916/2000\n", + "Epoch 1917/2000\n", + "Epoch 1918/2000\n", + "Epoch 1919/2000\n", + "Epoch 1920/2000\n", + "Epoch 1921/2000\n", + "Epoch 1922/2000\n", + "Epoch 1923/2000\n", + "Epoch 1924/2000\n", + "Epoch 1925/2000\n", + "Epoch 1926/2000\n", + "Epoch 1927/2000\n", + "Epoch 1928/2000\n", + "Epoch 1929/2000\n", + "Epoch 1930/2000\n", + "Epoch 1931/2000\n", + "Epoch 1932/2000\n", + "Epoch 1933/2000\n", + "Epoch 1934/2000\n", + "Epoch 1935/2000\n", + "Epoch 1936/2000\n", + "Epoch 1937/2000\n", + "Epoch 1938/2000\n", + "Epoch 1939/2000\n", + "Epoch 1940/2000\n", + "Epoch 1941/2000\n", + "Epoch 1942/2000\n", + "Epoch 1943/2000\n", + "Epoch 1944/2000\n", + "Epoch 1945/2000\n", + "Epoch 1946/2000\n", + "Epoch 1947/2000\n", + "Epoch 1948/2000\n", + "Epoch 1949/2000\n", + "Epoch 1950/2000\n", + "Epoch 1951/2000\n", + "Epoch 1952/2000\n", + "Epoch 1953/2000\n", + "Epoch 1954/2000\n", + "Epoch 1955/2000\n", + "Epoch 1956/2000\n", + "Epoch 1957/2000\n", + "Epoch 1958/2000\n", + "Epoch 1959/2000\n", + "Epoch 1960/2000\n", + "Epoch 1961/2000\n", + "Epoch 1962/2000\n", + "Epoch 1963/2000\n", + "Epoch 1964/2000\n", + "Epoch 1965/2000\n", + "Epoch 1966/2000\n", + "Epoch 1967/2000\n", + "Epoch 1968/2000\n", + "Epoch 1969/2000\n", + "Epoch 1970/2000\n", + "Epoch 1971/2000\n", + "Epoch 1972/2000\n", + "Epoch 1973/2000\n", + "Epoch 1974/2000\n", + "Epoch 1975/2000\n", + "Epoch 1976/2000\n", + "Epoch 1977/2000\n", + "Epoch 1978/2000\n", + "Epoch 1979/2000\n", + "Epoch 1980/2000\n", + "Epoch 1981/2000\n", + "Epoch 1982/2000\n", + "Epoch 1983/2000\n", + "Epoch 1984/2000\n", + "Epoch 1985/2000\n", + "Epoch 1986/2000\n", + "Epoch 1987/2000\n", + "Epoch 1988/2000\n", + "Epoch 1989/2000\n", + "Epoch 1990/2000\n", + "Epoch 1991/2000\n", + "Epoch 1992/2000\n", + "Epoch 1993/2000\n", + "Epoch 1994/2000\n", + "Epoch 1995/2000\n", + "Epoch 1996/2000\n", + "Epoch 1997/2000\n", + "Epoch 1998/2000\n", + "Epoch 1999/2000\n", + "Epoch 2000/2000\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(df_grouped.columns)" + ], + "metadata": { + "id": "qIb-HBQV3mri", + "outputId": "fd886769-a0f8-487e-dfe6-7957f3c4df6e", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 189, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Index(['1980', '1981', '1982', '1983', '1984', '1985', '1986', '1987', '1988',\n", + " '1989', '1990', '1991', '1992', '1993', '1994', '1995', '1996', '1997',\n", + " '1998', '1999', '2000', '2001', '2002', '2003', '2004', '2005', '2006',\n", + " '2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015',\n", + " '2016', '2017', '2018', '2019', '2020', '2021', 'Total'],\n", + " dtype='object')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Convertir X_test en un DataFrame de pandas\n", + "X_test_df = pd.DataFrame(X_test, columns=df.columns[:-1])\n", + "\n", + "# Supongamos que 'region' es la columna con la información de la región\n", + "X_test_with_region = X_test_df.copy()\n", + "\n", + "# Convertir y_pred en una serie de pandas\n", + "y_pred_series = pd.Series(y_pred.flatten(), index=X_test_df.index)\n", + "\n", + "X_test_with_region['Predicciones'] = y_pred_series\n", + "X_test_with_region['Real'] = y_test\n", + "\n", + "# Ahora puedes graficar los resultados por región\n", + "regiones = X_test_with_region['Region'].unique()\n", + "\n", + "for region in regiones:\n", + " data_region = X_test_with_region[X_test_with_region['Region'] == region]\n", + " plt.figure(figsize=(10,6))\n", + " plt.plot(data_region['Real'], color='blue', label='Real')\n", + " plt.plot(data_region['Predicciones'], color='red', label='Predicho')\n", + " plt.title(f'Valores reales vs predichos para {region}')\n", + " plt.xlabel('Observaciones')\n", + " plt.ylabel('Valor')\n", + " plt.legend()\n", + " plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 685 + }, + "id": "My8by2_2DI_X", + "outputId": "f19d7910-aca2-4805-afbe-ff191d55535d" + }, + "execution_count": 192, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Convertir X_test en un DataFrame de pandas\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mX_test_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolumns\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Supongamos que 'region' es la columna con la información de la región\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mX_test_with_region\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX_test_df\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, data, index, columns, dtype, copy)\u001b[0m\n\u001b[1;32m 720\u001b[0m )\n\u001b[1;32m 721\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 722\u001b[0;31m mgr = ndarray_to_mgr(\n\u001b[0m\u001b[1;32m 723\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 724\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/internals/construction.py\u001b[0m in \u001b[0;36mndarray_to_mgr\u001b[0;34m(values, index, columns, dtype, copy, typ)\u001b[0m\n\u001b[1;32m 327\u001b[0m \u001b[0;31m# by definition an array here\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 328\u001b[0m \u001b[0;31m# the dtypes will be coerced to a single dtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 329\u001b[0;31m \u001b[0mvalues\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_prep_ndarraylike\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcopy_on_sanitize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 330\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 331\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdtype\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mis_dtype_equal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/internals/construction.py\u001b[0m in \u001b[0;36m_prep_ndarraylike\u001b[0;34m(values, copy)\u001b[0m\n\u001b[1;32m 581\u001b[0m \u001b[0mvalues\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 582\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 583\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Must pass 2-d input. shape={values.shape}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 584\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 585\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Must pass 2-d input. shape=(3, 41, 1)" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "2\n", + "# Escalar los datos entre 0 y 1scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_y = MinMaxScaler(feature_range=(0, 1))\n", + "train_X_scaled = scaler_X.fit_transform(train_X)\n", + "test_X_scaled = scaler_X.transform(test_X)\n", + "train_y_scaled = scaler_y.fit_transform(train_y.values.reshape(-1, 1))\n", + "test_y_scaled = scaler_y.transform(test_y.values.reshape(-1, 1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + }, + "id": "ji9qjt_SCrvY", + "outputId": "7610dff1-9cc5-4bba-92ea-a0b93fdf3a09" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mscaler_X\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mscaler_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mtrain_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mtest_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mtrain_y_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/_set_output.py\u001b[0m in \u001b[0;36mwrapped\u001b[0;34m(self, X, *args, **kwargs)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mdata_to_wrap\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_to_wrap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[0;31m# only wrap the first output for cross decomposition\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 876\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0my\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 877\u001b[0m \u001b[0;31m# fit method of arity 1 (unsupervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 878\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 879\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 880\u001b[0m \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 425\u001b[0m \u001b[0;31m# Reset internal state before fitting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 426\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 427\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 428\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mpartial_fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 464\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 465\u001b[0m \u001b[0mfirst_pass\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"n_samples_seen_\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 466\u001b[0;31m X = self._validate_data(\n\u001b[0m\u001b[1;32m 467\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[0mreset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfirst_pass\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36m_validate_data\u001b[0;34m(self, X, y, reset, validate_separately, **check_params)\u001b[0m\n\u001b[1;32m 563\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Validation should be done on X, y or both.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 564\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 565\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"X\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mcheck_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 566\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 567\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_array\u001b[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator, input_name)\u001b[0m\n\u001b[1;32m 776\u001b[0m )\n\u001b[1;32m 777\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtype_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdtype_iter\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 778\u001b[0;31m \u001b[0mdtype_orig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 779\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 780\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"iloc\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"dtype\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numpy/core/overrides.py\u001b[0m in \u001b[0;36mresult_type\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: at least one array or dtype is required" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Definir el modelo LSTM\n", + "model_lstm = Sequential()\n", + "model_lstm.add(LSTM(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "model_lstm.add(Dense(1))\n", + "model_lstm.compile(optimizer='adam', loss='mse')\n", + "\n", + "#/ Definir el modelo GRU\n", + "#model_gru = Sequential()\n", + "#model_gru.add(GRU(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "#model_gru.add(Dense(1))\n", + "#model_gru.compile(optimizer='adam', loss='mse')\n", + "#" + ], + "metadata": { + "id": "CaTJQmj33IvW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model_lstm.fit(train_X, train_y, epochs=10, verbose=0)\n", + "#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\n", + "\n", + "# Evaluar los modelos\n", + "mse_lstm = model_lstm.evaluate(test_X, test_y)\n", + "#mse_gru = model_gru.evaluate(test_X, test_y)\n", + "\n", + "print(f'Test MSE LSTM: {mse_lstm}')\n", + "#print(f'Test MSE GRU: {mse_gru}')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 245 + }, + "id": "3wBcalVC41ED", + "outputId": "671dcbb9-7d07-4da9-b9e3-1c52a5f16ef9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;31m#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Evaluar los modelos\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mmse_lstm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'train_X' is not defined" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "hasta aca\n" + ], + "metadata": { + "id": "keXYd4TrurKV" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Convertir los datos a un formato largo usando melt de pandas\n", + "new_data = pd.melt(data, id_vars=['Country', 'Latitude', 'Longitude', 'Features', 'Region'], var_name='Year', value_name='Value')\n", + "\n", + "# Convertir las columnas al tipo de datos correcto\n", + "new_data['Year'] = new_data['Year'].astype(int)\n", + "new_data['Latitude'] = pd.to_numeric(new_data['Latitude'])\n", + "new_data['Longitude'] = pd.to_numeric(new_data['Longitude'])" + ], + "metadata": { + "id": "Xd6En43Apl_Z", + "outputId": "ff66b8ad-695e-4976-8859-ea466bc350cc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\"", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Convertir las columnas al tipo de datos correcto\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/tools/numeric.py\u001b[0m in \u001b[0;36mto_numeric\u001b[0;34m(arg, errors, downcast)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[0mcoerce_numeric\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0merrors\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"ignore\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"raise\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 184\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 185\u001b[0;31m values, _ = lib.maybe_convert_numeric(\n\u001b[0m\u001b[1;32m 186\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 187\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\" at position 161" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Reordenar los niveles de 'Features' en la secuencia deseada\n", + "feature_order = [\"imports\", \"exports\", \"net imports\", \"installed capacity\", \"net generation\", \"net consumption\", \"distribution losses\"]\n", + "new_data['Features'] = pd.Categorical(new_data['Features'], categories=feature_order, ordered=True)\n", + "\n", + "custom_palette = [\"red\", \"blue\", \"green\",\"purple\", \"#FF7F00\", \"cyan\", \"brown\"]\n", + "\n", + "# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\n", + "region_features = new_data.groupby(['Year', 'Region', 'Features']).agg(Total_Value=('Value', 'sum')).reset_index()\n", + "\n", + "# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "# Crear el gráfico de líneas con la paleta de colores personalizada\n", + "sns.lineplot(data=region_features, x='Year', y='Total_Value', hue='Region')\n", + "plt.title('Total Values by Region Over Time')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('Total')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 390 + }, + "id": "cYzGOiNeVfY7", + "outputId": "d3044941-773c-479f-a4bf-7e86be3e6785" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mregion_features\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Region'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0magg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTotal_Value\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Value'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sum'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36mgroupby\u001b[0;34m(self, by, axis, level, as_index, sort, group_keys, squeeze, observed, dropna)\u001b[0m\n\u001b[1;32m 8400\u001b[0m \u001b[0maxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_axis_number\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8401\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 8402\u001b[0;31m return DataFrameGroupBy(\n\u001b[0m\u001b[1;32m 8403\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8404\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/groupby.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, obj, keys, axis, level, grouper, exclusions, selection, as_index, sort, group_keys, squeeze, observed, mutated, dropna)\u001b[0m\n\u001b[1;32m 963\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrouper\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mget_grouper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 964\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 965\u001b[0;31m grouper, exclusions, obj = get_grouper(\n\u001b[0m\u001b[1;32m 966\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 967\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/grouper.py\u001b[0m in \u001b[0;36mget_grouper\u001b[0;34m(obj, key, axis, level, sort, observed, mutated, validate, dropna)\u001b[0m\n\u001b[1;32m 886\u001b[0m \u001b[0min_axis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 888\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 889\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGrouper\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkey\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 890\u001b[0m \u001b[0;31m# Add key to exclusions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "custom_palette = [\"#E41A1C\", \"#377EB8\", \"#4DAF4A\", \"#984EA3\", \"#FF7F00\", \"#FFFF33\", \"#A65628\"]\n", + "\n", + "# Filter the data for the past five years and 'exports'\n", + "export_data = new_data[(new_data['Features'] == \"exports\") & (new_data['Year'] >= (new_data['Year'].max() - 4))]\n", + "\n", + "# Group by 'Country' and calculate the total export value\n", + "top_exporting_countries = export_data.groupby('Country')['Value'].sum().reset_index().sort_values(by='Value', ascending=False).head(10)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(x='Value', y='Country', data=top_exporting_countries, palette=custom_palette)\n", + "print(top_exporting_countries)\n", + "\n", + "plt.xlabel('Total Exports')\n", + "plt.ylabel('Country')\n", + "plt.title('Exports - Last 5 Years - Top Ten Countries')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 512 + }, + "id": "pEGfENwGVhHK", + "outputId": "2dc0d837-10ef-4939-a46a-d36246f692a7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3801\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3802\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Filter the data for the past five years and 'exports'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mexport_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"exports\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# Group by 'Country' and calculate the total export value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3805\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3807\u001b[0;31m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3808\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3809\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3802\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3804\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3805\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;31m# If we have a listlike key, _check_indexing_error will raise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "RQfTp3HSXLqQ" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/proyectoIAPrediccion1CNNPrediccion0.1.ipynb b/proyectoIAPrediccion1CNNPrediccion0.1.ipynb new file mode 100644 index 0000000..86a4e7c --- /dev/null +++ b/proyectoIAPrediccion1CNNPrediccion0.1.ipynb @@ -0,0 +1,967 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as mcolors\n", + "import matplotlib.cm as cm\n", + "import matplotlib\n", + "import seaborn as sns\n", + "import plotly.express as px\n", + "from wordcloud import WordCloud\n", + "import geopandas as gpd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from keras.models import Sequential\n", + "from keras.layers import LSTM, GRU, Conv1D, MaxPooling1D, Flatten, Dense\n", + "from keras.losses import MeanSquaredError\n", + "from keras.regularizers import l2\n", + "from sklearn.metrics import mean_squared_error\n", + "from math import sqrt\n" + ], + "metadata": { + "id": "H7kZjC_GUZZd" + }, + "execution_count": 145, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": { + "id": "9_FId2wvQAgd" + }, + "outputs": [], + "source": [ + "# Leer los datos\n", + "GES_Data = \"global_electricity_statistics_cleaned.csv\"\n", + "dfread = pd.read_csv(GES_Data)" + ] + }, + { + "cell_type": "code", + "source": [ + "# Ver los primeros datos\n", + "print(dfread.head())\n", + "dfread[\"Features\"].value_counts()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lWY6qwmkQ2PL", + "outputId": "da98030e-ee6e-4dd5-e7ac-42be995ab92e" + }, + "execution_count": 160, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Country Features Region 1980 1981 1982 1983 \\\n", + "0 Algeria net generation Africa 6.683 7.65 8.824 9.615 \n", + "1 Angola net generation Africa 0.905 0.906 0.995 1.028 \n", + "2 Benin net generation Africa 0.005 0.005 0.005 0.005 \n", + "3 Botswana net generation Africa 0.443 0.502 0.489 0.434 \n", + "4 Burkina Faso net generation Africa 0.098 0.108 0.115 0.117 \n", + "\n", + " 1984 1985 1986 ... 2012 2013 2014 2015 \\\n", + "0 10.537 11.569 12.214 ... 53.9845 56.3134 60.39972 64.68244 \n", + "1 1.028 1.028 1.088 ... 6.03408 7.97606 9.21666 9.30914 \n", + "2 0.005 0.005 0.005 ... 0.04612 0.08848 0.22666 0.31056 \n", + "3 0.445 0.456 0.538 ... 0.33 0.86868 2.17628 2.79104 \n", + "4 0.113 0.115 0.122 ... 0.86834 0.98268 1.11808 1.43986 \n", + "\n", + " 2016 2017 2018 2019 2020 2021 \n", + "0 66.75504 71.49546 72.10903 76.685 72.73591277 77.53072719 \n", + "1 10.203511 10.67604 12.83194 15.4 16.6 16.429392 \n", + "2 0.26004 0.3115 0.19028 0.2017 0.22608 0.24109728 \n", + "3 2.52984 2.8438 2.97076 3.0469 2.05144 2.18234816 \n", + "4 1.5509 1.64602 1.6464 1.72552 1.647133174 1.761209666 \n", + "\n", + "[5 rows x 45 columns]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "net generation 230\n", + "net consumption 230\n", + "imports 230\n", + "exports 230\n", + "net imports 230\n", + "installed capacity 230\n", + "distribution losses 230\n", + "Name: Features, dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 160 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Convertir las columnas de los años a numéricas\n", + "cols = [str(year) for year in range(1980, 2022)]\n", + "dfread[cols] = dfread[cols].apply(pd.to_numeric, errors='coerce')\n", + "\n", + "# Calcular el promedio de cada fila (ignorando los valores NaN)\n", + "dfread['avg'] = dfread.loc[:, '1980':'2021'].mean(axis=1)\n", + "\n", + "# Rellenar los valores NaN con el promedio de la fila correspondiente\n", + "for col in cols:\n", + " dfread[col].fillna(dfread['avg'], inplace=True)\n", + "\n", + "# Eliminar la columna 'avg' ya que ya no es necesaria\n", + "dfread.drop('avg', axis=1, inplace=True)\n", + "\n", + "# Agregar la columna 'Total' que es la suma de las columnas desde 1980 hasta 2021\n", + "dfread['Total'] = dfread.loc[:, '1980':'2021'].sum(axis=1)\n", + "\n", + "# Agrupar por 'Region' y obtener la suma de los valores\n", + "dfread_grouped = dfread.groupby('Region', as_index=False).sum(numeric_only=True)\n" + ], + "metadata": { + "id": "9MZcbtw9t95l" + }, + "execution_count": 161, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "dfread_grouped.describe().columns" + ], + "metadata": { + "id": "xegG-hIr9XGK", + "outputId": "a938e42a-23e5-4856-8dc7-aa1161e1cd4e", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 162, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Index(['1980', '1981', '1982', '1983', '1984', '1985', '1986', '1987', '1988',\n", + " '1989', '1990', '1991', '1992', '1993', '1994', '1995', '1996', '1997',\n", + " '1998', '1999', '2000', '2001', '2002', '2003', '2004', '2005', '2006',\n", + " '2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015',\n", + " '2016', '2017', '2018', '2019', '2020', '2021', 'Total'],\n", + " dtype='object')" + ] + }, + "metadata": {}, + "execution_count": 162 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "base de datos lista con regiones y caracteristicas 1980 al 2021 abajo listo falta red neuronal y entrenamiento\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "_28HoIcVTX5H" + } + }, + { + "cell_type": "code", + "source": [ + "print(dfread_grouped)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6wZ4FIMSDhZH", + "outputId": "d156f24c-6279-40b4-fd9c-76ca9d2037f6" + }, + "execution_count": 163, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Region 1980 1981 1982 \\\n", + "0 Africa 442.751613 470.995013 486.609413 \n", + "1 Asia & Oceania 2864.920423 2957.954923 3091.071601 \n", + "2 Central & South America 701.439239 723.419959 767.169799 \n", + "3 Eurasia 5956.246909 5880.536405 6119.223111 \n", + "4 Europe 7098.639233 7138.275233 7175.265233 \n", + "5 Middle East 228.045912 256.978912 301.258912 \n", + "6 North America 6172.234030 6282.965270 6205.586413 \n", + "\n", + " 1983 1984 1985 1986 1987 \\\n", + "0 505.565813 548.573213 584.582613 617.340013 640.229413 \n", + "1 3288.175590 3517.547039 3737.678238 3942.409483 4262.148408 \n", + "2 821.105839 882.052239 924.217679 1014.448560 1061.394480 \n", + "3 6224.347107 6384.761865 6497.913049 6433.159219 6555.257483 \n", + "4 7379.304233 7639.238233 7874.046233 7993.154233 8202.475233 \n", + "5 335.294912 370.548912 395.965912 416.267912 439.324912 \n", + "6 6399.484193 6703.205738 6894.759863 6963.126923 7235.631195 \n", + "\n", + " 1988 ... 2013 2014 2015 2016 \\\n", + "0 662.405813 ... 1677.718947 1737.628313 1787.300928 1817.971412 \n", + "1 4589.761222 ... 21303.566369 22255.187389 23001.975032 24277.047884 \n", + "2 1111.898820 ... 2880.299637 2874.232050 2956.475857 3010.131036 \n", + "3 6641.334325 ... 6588.899485 6601.562889 6568.729219 6619.157366 \n", + "4 8354.649233 ... 10857.743749 10724.724561 10972.003012 11045.824989 \n", + "5 491.155912 ... 2244.918531 2393.003912 2514.613376 2591.011451 \n", + "6 7502.085307 ... 11431.326082 11512.482997 11530.195877 11571.996896 \n", + "\n", + " 2017 2018 2019 2020 2021 \\\n", + "0 1893.433230 1939.653262 1964.909527 1927.467376 1997.010181 \n", + "1 25762.027981 27169.634214 28150.420606 28902.810243 30933.492914 \n", + "2 3029.476889 3080.027553 3085.916507 3087.128325 3238.838636 \n", + "3 6646.263342 6679.715937 6715.974792 6694.895904 6892.277529 \n", + "4 11104.506712 11096.788734 11080.544037 10985.140560 11273.946852 \n", + "5 2694.789331 2759.997855 2864.975233 2768.263372 2909.974107 \n", + "6 11504.857796 11858.463840 11735.104936 11547.486151 11829.410197 \n", + "\n", + " Total \n", + "0 47384.899885 \n", + "1 517723.280867 \n", + "2 80349.864723 \n", + "3 268660.517049 \n", + "4 396571.073559 \n", + "5 54238.932786 \n", + "6 404741.539017 \n", + "\n", + "[7 rows x 44 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(dfread_grouped.columns)" + ], + "metadata": { + "id": "y9YU2bOl_Cf6", + "outputId": "c76d30f2-c40c-43c9-97be-7efe97d27a0f", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 164, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Index(['Region', '1980', '1981', '1982', '1983', '1984', '1985', '1986',\n", + " '1987', '1988', '1989', '1990', '1991', '1992', '1993', '1994', '1995',\n", + " '1996', '1997', '1998', '1999', '2000', '2001', '2002', '2003', '2004',\n", + " '2005', '2006', '2007', '2008', '2009', '2010', '2011', '2012', '2013',\n", + " '2014', '2015', '2016', '2017', '2018', '2019', '2020', '2021',\n", + " 'Total'],\n", + " dtype='object')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Elimina la columna 'Total'\n", + "df_groupedGraf = dfread_grouped.drop(columns=['Total'])\n", + "df_groupedGraf.set_index('Region', inplace=True)" + ], + "metadata": { + "id": "CV7jvrdZ-uZT" + }, + "execution_count": 178, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(df_groupedGraf.columns)" + ], + "metadata": { + "id": "aOlLupUN-veI", + "outputId": "760ab5f8-ad09-4ed8-bade-2d70e626da6f", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 180, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Index(['1980', '1981', '1982', '1983', '1984', '1985', '1986', '1987', '1988',\n", + " '1989', '1990', '1991', '1992', '1993', '1994', '1995', '1996', '1997',\n", + " '1998', '1999', '2000', '2001', '2002', '2003', '2004', '2005', '2006',\n", + " '2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015',\n", + " '2016', '2017', '2018', '2019', '2020', '2021'],\n", + " dtype='object')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Convierte las columnas a un tipo numérico y maneja los NaNs\n", + "df_groupedGraf = df_groupedGraf.apply(pd.to_numeric, errors='coerce')\n", + "df_groupedGraf = df_groupedGraf.replace(np.nan, 0)\n", + "\n", + "# Transpone el DataFrame para que los años sean las filas y las regiones sean las columnas\n", + "df_groupedGraf = df_groupedGraf.transpose()" + ], + "metadata": { + "id": "mKuAxW4R9sQB" + }, + "execution_count": 181, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(df_groupedGraf.columns)" + ], + "metadata": { + "id": "PD_9dnmbDWuD", + "outputId": "2113b511-38a3-4fcd-c4f4-7039b20a22d5", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 182, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Index(['Africa', 'Asia & Oceania', 'Central & South America', 'Eurasia',\n", + " 'Europe', 'Middle East', 'North America'],\n", + " dtype='object', name='Region')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Crea el gráfico\n", + "plt.figure(figsize=(10, 6))\n", + "for region in df_groupedGraf.columns:\n", + " plt.plot(df_groupedGraf.index, df_groupedGraf[region], label=region)\n", + "\n", + "plt.title('Datos por Región desde 1980 hasta 2020')\n", + "plt.xlabel('Año')\n", + "plt.ylabel('Valor')\n", + "plt.legend()\n", + "\n", + "\n", + "# Rota las etiquetas del eje x para evitar la superposición\n", + "plt.xticks(rotation=45)\n", + "\n", + "plt.show()" + ], + "metadata": { + "id": "fHn2FqgZ9SUS", + "outputId": "c6ffc741-a545-43e1-89a5-7a8d76a395a8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 502 + } + }, + "execution_count": 183, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Guardar el dataframe agrupado\n", + "dfread_grouped.to_csv('global_electricity_statistics_by_region.csv')" + ], + "metadata": { + "id": "3HyCu76yuvpS" + }, + "execution_count": 185, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(dfread_grouped.columns)" + ], + "metadata": { + "id": "3la7bU_N8K4i", + "outputId": "0593528b-5d1d-4f34-ba1f-c7b979037b78", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 186, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Index(['Region', '1980', '1981', '1982', '1983', '1984', '1985', '1986',\n", + " '1987', '1988', '1989', '1990', '1991', '1992', '1993', '1994', '1995',\n", + " '1996', '1997', '1998', '1999', '2000', '2001', '2002', '2003', '2004',\n", + " '2005', '2006', '2007', '2008', '2009', '2010', '2011', '2012', '2013',\n", + " '2014', '2015', '2016', '2017', '2018', '2019', '2020', '2021',\n", + " 'Total'],\n", + " dtype='object')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "X = dfread_grouped.drop('2021', axis=1)\n", + "y = dfread_grouped['2021']\n", + "\n", + "# Dividir los datos en conjuntos de entrenamiento y prueba\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.42, random_state=45)\n", + "\n", + "\n", + "# Guardar el índice de X_test antes de cambiar su forma\n", + "X_test_index = X_test.index\n", + "\n", + "# Identifica las columnas numéricas (todas excepto 'Region')\n", + "num_cols = [col for col in X_train.columns if col != 'Region']\n", + "\n", + "# Cambia la forma de los datos numéricos para que sean compatibles con CNN\n", + "X_train_num = np.expand_dims(X_train[num_cols], axis=2).astype('float32')\n", + "X_test_num = np.expand_dims(X_test[num_cols], axis=2).astype('float32')\n", + "\n", + "# Asegúrate de que y_train y y_test también sean float32\n", + "y_train = y_train.astype('float32')\n", + "y_test = y_test.astype('float32')\n", + "\n" + ], + "metadata": { + "id": "nfJrQD1i4qys" + }, + "execution_count": 205, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "error de tenserflow preguntar al profe\n" + ], + "metadata": { + "id": "qsv2yFlkG7bx" + } + }, + { + "cell_type": "code", + "source": [ + "# Crear la red CNN\n", + "model = Sequential()\n", + "model.add(Conv1D(filters=64, kernel_size=9, activation='relu', input_shape=(X_train.shape[1], 1))) # Puedes cambiar el número de filtros (64 aquí), el tamaño del kernel (3 aquí) y la función de activación ('relu' aquí)\n", + "model.add(MaxPooling1D(pool_size=2)) # Puedes cambiar el tamaño del pool (2 aquí)\n", + "model.add(Flatten())\n", + "model.add(Dense(90, activation='relu')) # Puedes cambiar el número de neuronas (50 aquí) y la función de activación ('relu' aquí)\n", + "model.add(Dense(1))\n", + "\n", + "# Compilar el modelo\n", + "model.compile(optimizer='adam', loss=MeanSquaredError()) # Puedes cambiar el optimizador ('adam' aquí) y la función de pérdida (MeanSquaredError aquí)\n", + "\n", + "# Ajustar el modelo a los datos de entrenamiento\n", + "history = model.fit(X_train, y_train, epochs=200, verbose=4) # Puedes cambiar el número de épocas (200 aquí)\n", + "\n", + "# Graficar la pérdida durante el entrenamiento\n", + "plt.plot(history.history['loss'])\n", + "plt.title('Model loss')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train'], loc='upper right')\n", + "plt.show()" + ], + "metadata": { + "id": "P0LByrb1780L", + "outputId": "d96fb1f2-0970-4f4e-9642-41540f59898b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 442 + } + }, + "execution_count": 206, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;31m# Ajustar el modelo a los datos de entrenamiento\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mhistory\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Puedes cambiar el número de épocas (200 aquí)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;31m# Graficar la pérdida durante el entrenamiento\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/keras/src/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;31m# To get the full stack trace, call:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[0;31m# `tf.debugging.disable_traceback_filtering()`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 71\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 72\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/framework/constant_op.py\u001b[0m in \u001b[0;36mconvert_to_eager_tensor\u001b[0;34m(value, ctx, dtype)\u001b[0m\n\u001b[1;32m 100\u001b[0m \u001b[0mdtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_datatype_enum\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mEagerTensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 104\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Failed to convert a NumPy array to a Tensor (Unsupported object type float)." + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(dfread_grouped.columns)" + ], + "metadata": { + "id": "qIb-HBQV3mri", + "outputId": "dc17f94b-734a-4b78-8c9f-a7f5ab1250b3", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 196, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Index(['Region', '1980', '1981', '1982', '1983', '1984', '1985', '1986',\n", + " '1987', '1988', '1989', '1990', '1991', '1992', '1993', '1994', '1995',\n", + " '1996', '1997', '1998', '1999', '2000', '2001', '2002', '2003', '2004',\n", + " '2005', '2006', '2007', '2008', '2009', '2010', '2011', '2012', '2013',\n", + " '2014', '2015', '2016', '2017', '2018', '2019', '2020', '2021',\n", + " 'Total'],\n", + " dtype='object')\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "preguntar al profe sobre datos Tabla \"Total\" y otras cosas\n" + ], + "metadata": { + "id": "Mau8HCYfZdVO" + } + }, + { + "cell_type": "code", + "source": [ + "print(y_test)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "My8by2_2DI_X", + "outputId": "9da389df-0e18-45e1-c40b-22ef5cdedf24" + }, + "execution_count": 197, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "5 2909.974107\n", + "2 3238.838636\n", + "1 30933.492914\n", + "Name: 2021, dtype: float64\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "print(y_train)" + ], + "metadata": { + "id": "LKSqeON6YN7Y", + "outputId": "a6c85a83-da6b-46c3-ad7f-b6c548df445a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 198, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0 1997.010181\n", + "4 11273.946852\n", + "6 11829.410197\n", + "3 6892.277529\n", + "Name: 2021, dtype: float64\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Asegúrate de que 'Region' es una columna en tu DataFrame\n", + "region = dfread_grouped.loc[X_test_index]['Region']\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(years, y_test, label='Datos Reales', marker='o')\n", + "plt.plot(years, y_train, label='Predicciones', marker='x')\n", + "plt.plot(years, region, label='Region', marker='s') # Agrega la columna 'Region' al gráfico\n", + "plt.title('Predicciones vs. Datos Reales')\n", + "plt.xlabel('Año')\n", + "plt.ylabel('Valor')\n", + "plt.xticks(years, rotation=45) # Rotar etiquetas del eje x para que se vean mejor\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n" + ], + "metadata": { + "id": "2Y5furXoWET-", + "outputId": "35156ef1-e6f0-4a8a-cd67-039a2644653c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 814 + } + }, + "execution_count": 195, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myears\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Datos Reales'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'o'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myears\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Predicciones'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'x'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myears\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mregion\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Region'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m's'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Agrega la columna 'Region' al gráfico\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Predicciones vs. Datos Reales'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mplot\u001b[0;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2810\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0m_copy_docstring_and_deprecators\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mAxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2811\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscalex\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscaley\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2812\u001b[0;31m return gca().plot(\n\u001b[0m\u001b[1;32m 2813\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscalex\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mscalex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscaley\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mscaley\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2814\u001b[0m **({\"data\": data} if data is not None else {}), **kwargs)\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mplot\u001b[0;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1686\u001b[0m \"\"\"\n\u001b[1;32m 1687\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormalize_kwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmlines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLine2D\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1688\u001b[0;31m \u001b[0mlines\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_lines\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1689\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlines\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1690\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[0mthis\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 310\u001b[0m \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 311\u001b[0;31m yield from self._plot_args(\n\u001b[0m\u001b[1;32m 312\u001b[0m this, kwargs, ambiguous_fmt_datakey=ambiguous_fmt_datakey)\n\u001b[1;32m 313\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m_plot_args\u001b[0;34m(self, tup, kwargs, return_kwargs, ambiguous_fmt_datakey)\u001b[0m\n\u001b[1;32m 502\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 503\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 504\u001b[0;31m raise ValueError(f\"x and y must have same first dimension, but \"\n\u001b[0m\u001b[1;32m 505\u001b[0m f\"have shapes {x.shape} and {y.shape}\")\n\u001b[1;32m 506\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: x and y must have same first dimension, but have shapes (3,) and (4,)" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+sAAAH5CAYAAAD5ga/wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABoL0lEQVR4nO39eXiVhZ3//z/PyUqAJAQIYQlrFkRwQ4Wo4EJIbNGp1U7VWotLa1GkstY6Y+s4n89v7FfBfaH92EqnrbXaqXbUKgQQcEFUFAGXhH1PWLOwZD337w+GjKkbKHCyPB/XdS5z7vt97vM6uW5DXrnPue9QEAQBkiRJkiSp2QhHO4AkSZIkSWrKsi5JkiRJUjNjWZckSZIkqZmxrEuSJEmS1MxY1iVJkiRJamYs65IkSZIkNTOWdUmSJEmSmpnYaAeIpkgkwtatW+nYsSOhUCjacSRJkiRJrVwQBFRVVdGjRw/C4c8/ft6my/rWrVvJzMyMdgxJkiRJUhuzadMmevXq9bnr23RZ79ixI3Dwm5ScnBzlNJIkSZKk1q6yspLMzMzGPvp52nRZP/TW9+TkZMu6JEmSJOm4+bKPYnuCOUmSJEmSmhnLuiRJkiRJzYxlXZIkSZKkZsayLkmSJElSM2NZlyRJkiSpmbGsS5IkSZLUzFjWJUmSJElqZizrkiRJkiQ1M5Z1SZIkSZKaGcu6JEmSJEnNjGVdkiRJkqRmxrIuSZIkSVIzY1mXJEmSJKmZiY12AEmSJEmSvqqGSMBb63azvaqa9I6JnNkvjZhwKNqxvjbLuiRJkiSpRXp55TbufP5DtlVUNy7rnpLIHRcP4sLB3aOY7OvzbfCSJEmSpBbn5ZXbuPEP7zYp6gClFdXc+Id3eXnltiglOzos65IkSZKkFqUhEnDn8x8SfMa6Q8vufP5DGiKfNdEyWNYlSZIkSS3KW+t2f+qI+icFwLaKat5at/v4hTrKLOuSJEmSpBZle9XnF/WvMtccWdYlSZIkSS1GXUOElVsqDms2vWPiMU5z7Hg2eEmSJElSsxeJBDy/fCv3FZWwftf+L5wNARkpBy/j1lJZ1iVJkiRJzVYQBBR9WMaMOSUUl1UBkNY+ngtyu/Jf7245OPOJ+UNXWL/j4kEt+nrrlnVJkiRJUrMTBAGvrd7J9DklvL+pHICOibHcMKI/157Tjw4JseQP6vap66xntJLrrFvWJUmSJEnNyjvrd3PP7GKW/M/Z3NvFxXDt2X25YWR/UpPiG+cuHNyd0YMyeGvdbrZXVZPe8eBb31vyEfVDLOuSJEmSpGZh5ZYKZswp5pXiHQDEx4T53rDejD8/i64dEz7zMTHhEHkDOh/PmMeFZV2SJEmSFFWrt1dxb1EJf19RChws4P88tBcTRmXTM7VdlNNFh2VdkiRJkhQVG3ft5/55JTz33hYiAYRC8E8n92Bifg79urSPdryosqxLkiRJko6r0opqHpq/ij+/vYn6yMFzuRcM6sbkghwGZiRHOV3zED6S4ccee4yTTjqJ5ORkkpOTycvL46WXXmpcX11dzfjx4+ncuTMdOnTgsssuo6ysrMk2Nm7cyJgxY0hKSiI9PZ1p06ZRX1/fZGbBggWcdtppJCQkkJWVxaxZsz6V5ZFHHqFv374kJiYybNgw3nrrrSN5KZIkSZKk42z3vlr+fy9+yLn3vMIfl2ykPhIwIrsLz40/m1//4HSL+iccUVnv1asXv/zlL1m6dCnvvPMOF1xwAd/61rf44IMPAJg0aRLPP/88zzzzDAsXLmTr1q1ceumljY9vaGhgzJgx1NbW8sYbb/C73/2OWbNm8Ytf/KJxZt26dYwZM4bzzz+fZcuWMXHiRH74wx8ye/bsxpk///nPTJ48mTvuuIN3332Xk08+mcLCQrZv3/51vx+SJEmSpKOssrqOe+cUM+L/m8//e3UdNfURTu/TiaduGM7vrx/GKZmp0Y7Y7ISCIAi+fOzzpaWlcc899/Cd73yHrl278uSTT/Kd73wHgI8//pgTTjiBxYsXM3z4cF566SUuuugitm7dSrdu3QCYOXMmt956Kzt27CA+Pp5bb72VF198kZUrVzY+xxVXXEF5eTkvv/wyAMOGDeOMM87g4YcfBiASiZCZmcmECRP42c9+dtjZKysrSUlJoaKiguRk/4IjSZIkSUfT/tp6Zr2xnl8tXEvFgToATuyRzNTCXM7L6Uoo1PIvsXakDreHHtGR9U9qaGjgqaeeYt++feTl5bF06VLq6urIz89vnBk4cCC9e/dm8eLFACxevJghQ4Y0FnWAwsJCKisrG4/OL168uMk2Ds0c2kZtbS1Lly5tMhMOh8nPz2+c+Tw1NTVUVlY2uUmSJEmSjq6a+gZmvb6OkXcv4O6Xi6k4UEdWegceveo0nr/5HM7PTW+TRf1IHPEJ5lasWEFeXh7V1dV06NCBZ599lkGDBrFs2TLi4+NJTU1tMt+tWzdKSw+efr+0tLRJUT+0/tC6L5qprKzkwIED7Nmzh4aGhs+c+fjjj78w+1133cWdd955pC9ZkiRJknQY6hsi/Ne7m3lw3mq2lB8AIDOtHRNH5XDJqT2JCVvQD9cRl/Xc3FyWLVtGRUUFf/nLXxg7diwLFy48FtmOuttuu43Jkyc33q+srCQzMzOKiSRJkiSp5YtEAl5YsY37ikpYt3MfAN2SE5hwQTbfPT2T+Niv/KbuNuuIy3p8fDxZWVkADB06lLfffpsHHniAyy+/nNraWsrLy5scXS8rKyMjIwOAjIyMT521/dDZ4j85849nkC8rKyM5OZl27doRExNDTEzMZ84c2sbnSUhIICEh4UhfsiRJkiTpMwRBwNyPtjNjTjEfl1YB0CkpjpvOy+LqvD4kxsVEOWHL9bX/vBGJRKipqWHo0KHExcUxb968xnXFxcVs3LiRvLw8APLy8lixYkWTs7YXFRWRnJzMoEGDGmc+uY1DM4e2ER8fz9ChQ5vMRCIR5s2b1zgjSZIkSTq2Xl+9k28/+gY/+s93+Li0io4JsUwencOrt17Aj0b2t6h/TUd0ZP22227jG9/4Br1796aqqoonn3ySBQsWMHv2bFJSUrj++uuZPHkyaWlpJCcnM2HCBPLy8hg+fDgABQUFDBo0iKuvvpq7776b0tJSbr/9dsaPH994xHvcuHE8/PDD/PSnP+W6665j/vz5PP3007z44ouNOSZPnszYsWM5/fTTOfPMM7n//vvZt28f11577VH81kiSJEmS/tHSDXuYPruYxWt3AZAYF+aas/ox7tz+pCbFRzld63FEZX379u384Ac/YNu2baSkpHDSSScxe/ZsRo8eDcB9991HOBzmsssuo6amhsLCQh599NHGx8fExPDCCy9w4403kpeXR/v27Rk7diz//u//3jjTr18/XnzxRSZNmsQDDzxAr169ePzxxyksLGycufzyy9mxYwe/+MUvKC0t5ZRTTuHll1/+1EnnJEmSJElHxwdbK5gxp4T5Hx98p3R8TJjvDevNTecPIL1jYpTTtT5f+zrrLZnXWZckSZKkL7Z6+17um1vCi8u3ARATDnHZaT35yahsenVKinK6ludwe+gRn2BOkiRJktT6bdq9nwfmreKv724m8j+HeC8+uQeT8rPp37VDdMO1AZZ1SZIkSVKjsspqHp6/mqfe3khdw8GWnn9CN6YU5HBCd9+RfLxY1iVJkiRJ7N5Xy8yFa/jdG+upqY8AcE5WF6YU5HBq705RTtf2WNYlSZIkqQ2rqq7j8VfX8ZvX1rG3ph6A03qnMrUwl7MGdIlyurbLsi5JkiRJbdCB2gZ+t3g9MxeuoXx/HQCDuicztTCH83PTCYVCUU7YtlnWJUmSJKkNqalv4Km3NvHwK6vZUVUDwICu7Zk8OpdvDM4gHLakNweWdUmSJElqA+obIvz1vS08MHcVW8oPANCrUztuGZXNt0/tSWxMOMoJ9UmWdUmSJElqxSKRgBdXbOO+uSWs3bEPgPSOCUy4IIvLz+hNfKwlvTmyrEuSJElSKxQEAfM/3s70OSV8tK0SgNSkOG46bwBXD+9Lu/iYKCfUF7GsS5IkSVIr88bqndwzp5j3NpYD0CEhlh+O6Mf15/SjY2JcdMPpsFjWJUmSJKmVeHfjHqbPLuaNNbsASIwLM/asvowbOYBO7eOjnE5HwrIuSZIkSS3ch1srubeomLkfbQcgLibElWf25ubzs0hPToxyOn0VlnVJkiRJaqHW7NjLfUUlvLB8GwDhEFx2Wi9+MiqbzLSkKKfT12FZlyRJkqQWZvOe/TwwdxX/9e5mIsHBZRed1J1Jo3MY0LVDdMPpqLCsS5IkSVILsb2qmkfmr+bJtzZS13CwpY8amM7kghxO7JES5XQ6mizrkiRJktTM7dlXy8xFa/jdG+uprosAcNaAzkwpyGVon05RTqdjwbIuSZIkSc1UVXUdv3ltHb95dR1VNfUAnNo7lWkFuZyV1SXK6XQsWdYlSZIkqZmprmvgPxev57EFa9izvw6AgRkdmVaYywUD0wmFQlFOqGPNsi5JkiRJzURtfYQ/v72Rh+avZntVDQD9u7Rn0ugcxgzpTjhsSW8rLOuSJEmSFGX1DRGefW8LD8xbxeY9BwDomdqOW/KzufTUnsTGhKOcUMebZV2SJEmSoiQSCXhpZSn3FhWzZsc+ALp2TODm87O44sxMEmJjopxQ0WJZlyRJkqTjLAgCXinezvTZJXy4rRKA1KQ4xp07gLF5fWkXb0lv6yzrkiRJknQcLV6zi+lzilm6YQ8A7eNj+OGI/lw/oh/JiXFRTqfmwrIuSZIkScfBsk3lTJ9dzGurdwKQEBtm7Fl9GXfuANLax0c5nZoby7okSZIkHUMfbatkxpwS5n5UBkBcTIgrzujNzRdk0S05Mcrp1FxZ1iVJkiTpGFi3cx/3FZXw/PKtBAGEQ/DtU3sxMT+bzLSkaMdTM2dZlyRJkqSjaEv5AR6cu4q/vLuZhkgAwJgh3Zk0Opus9I5RTqeWwrIuSZIkSUfB9qpqHn1lDU8u2UhtQwSACwamM3l0DoN7pkQ5nVoay7okSZIkfQ3l+2v51aK1zHp9PQfqGgAY3j+NaYW5DO2TFuV0aqks65IkSZL0Feytqee3r63j/y1aS1VNPQAnZ6YyrSCXs7M6EwqFopxQLZllXZIkSZKOQHVdA79fvIHHFq5h975aAAZmdGRKQS75J6Rb0nVUWNYlSZIk6TDU1kd4+p1NPDR/FWWVNQD069KeSaNzuGhId8JhS7qOHsu6JEmSJH2BhkjAc+9t4f55JWzafQCAHimJ3JKfzWWn9SI2JhzlhGqNLOuSJEmS9BkikYCXPyjl3qISVm/fC0CXDgncfP4ArhzWm4TYmCgnVGtmWZckSZKkTwiCgAUlO5gxp5iVWyoBSGkXx4/P7c81Z/UlKd4apWPPvUySJEmS/seba3cxfXYx72zYA0D7+BiuP6cf14/oT0q7uCinU1tiWZckSZLU5r2/qZzpc4p5ddVOAOJjw4zN68O4cwfQuUNClNOpLbKsS5IkSWqzikurmDGnmDkflgEQGw5x+RmZTLggm4yUxCinU1tmWZckSZLU5qzfuY/75pbw3+9vJQggHIJLTu3JxFE59O6cFO14kmVdkiRJUtuxtfwAD81fxdPvbKYhEgDwjcEZTB6dQ3a3jlFOJ/0vy7okSZKkVm9HVQ2PLljNH9/cSG1DBIDzcrsytSCXwT1TopxO+jTLuiRJkqRWq2J/Hb9atIYnXl/PgboGAM7sl8a0wlzO6JsW5XTS57OsS5IkSWp19tXU88Tr6/jVorVUVdcDcFKvFKYW5DIiuwuhUCjKCaUvZlmXJEmS1GpU1zXwhzc38NiCNezaVwtAbreOTC7IoWBQN0u6WgzLuiRJkqQWr64hwjPvbObBeasorawGoG/nJCaNzuGik3oQE7akq2WxrEuSJElqsRoiAf/9/hbun7uKDbv2A9A9JZFbRmVz2dBexMWEo5xQ+mos65IkSZJanCAImP1BKTPmlLBq+14AunSI56bzsvjesN4kxsVEOaH09VjWJUmSJLUYQRCwsGQHM+aUsGJLBQDJibH8+NwBXHNWX9onWHHUOrgnS5IkSWoR3lq3m+mzi3lr/W4AkuJjuO7sfvxoZH9S2sVFOZ10dFnWJUmSJDVryzeXM31OCYtKdgAQHxvm6uF9uPG8AXTpkBDldNKxYVmXJEmS1CyVlFUxY04xsz8oAyA2HOK7Z2Qy4YIsuqe0i3I66diyrEuSJElqVjbs2sf9c1fx3LItBAGEQnDJKT2ZmJ9Nn87tox1POi4s65IkSZKahW0VB3hw3mqeeWcT9ZEAgAtPzGByQQ453TpGOZ10fFnWJUmSJEXVzr01PLZgDb9/cwO19REARuZ0ZWpBDif1So1uOClKLOuSJEmSoqLiQB3/b9Fafvv6OvbXNgBwZt80phbmcma/tCink6LLsi5JkiTpuNpXU8+sN9bzq4VrqKyuB2BIzxSmFuYyMrsLoVAoygml6LOsS5IkSTouqusaeHLJRh5dsJqde2sByE7vwJSCHApPzLCkS59gWZckSZJ0TNU1RPjL0s08OG8V2yqqAeidlsSk0dn808k9iQlb0qV/ZFmXJEmSdExEIgHPL9/KfUUlrN+1H4CM5ER+Miqbfz69F3Ex4SgnlJovy7okSZKkoyoIAuZ8WMa9c0ooLqsCoHP7eG48bwDfH96HxLiYKCeUmj/LuiRJkqSjIggCXl21kxlzinl/cwUAHRNj+fHI/lx7dj/aJ1g/pMPl/y2SJEmSvra31+/mntnFvLVuNwBJ8TFce3ZfbhgxgJSkuCink1oey7okSZKkr2zllgqmzylmQfEOAOJjwlw1vDc3nZdF144JUU4ntVyWdUmSJElHbFVZFfcWlfDSylIAYsIhvnt6LyZckE2P1HZRTie1fEd0+sW77rqLM844g44dO5Kens4ll1xCcXFxk5nzzjuPUCjU5DZu3LgmMxs3bmTMmDEkJSWRnp7OtGnTqK+vbzKzYMECTjvtNBISEsjKymLWrFmfyvPII4/Qt29fEhMTGTZsGG+99daRvBxJkiRJR2jjrv1M/vMyCu9fxEsrSwmF4JJTejBv8rncdelJFnXpKDmiI+sLFy5k/PjxnHHGGdTX1/Mv//IvFBQU8OGHH9K+ffvGuR/96Ef8+7//e+P9pKSkxq8bGhoYM2YMGRkZvPHGG2zbto0f/OAHxMXF8R//8R8ArFu3jjFjxjBu3Dj++Mc/Mm/ePH74wx/SvXt3CgsLAfjzn//M5MmTmTlzJsOGDeP++++nsLCQ4uJi0tPTv9Y3RZIkSVJTpRXVPDR/FX9+exP1kQCAgkHdmFKQS25Gxyink1qfUBAEwVd98I4dO0hPT2fhwoWMHDkSOHhk/ZRTTuH+++//zMe89NJLXHTRRWzdupVu3boBMHPmTG699VZ27NhBfHw8t956Ky+++CIrV65sfNwVV1xBeXk5L7/8MgDDhg3jjDPO4OGHHwYgEomQmZnJhAkT+NnPfnZY+SsrK0lJSaGiooLk5OSv+m2QJEmSWq1de2t4bMEafv/mBmrqIwCMyO7C1IJcTs5MjW44qQU63B56RG+D/0cVFQcvx5CWltZk+R//+Ee6dOnC4MGDue2229i/f3/jusWLFzNkyJDGog5QWFhIZWUlH3zwQeNMfn5+k20WFhayePFiAGpra1m6dGmTmXA4TH5+fuPMZ6mpqaGysrLJTZIkSdKnVVbXce+cYkbe/QqPv7aOmvoIp/fpxFM3DOf31w+zqEvH2Fc+wVwkEmHixImcffbZDB48uHH59773Pfr06UOPHj1Yvnw5t956K8XFxfz1r38FoLS0tElRBxrvl5aWfuFMZWUlBw4cYM+ePTQ0NHzmzMcff/y5me+66y7uvPPOr/qSJUmSpFZvf209s95Yz68WrqXiQB0Ag3smM6Ugl/NyuhIKhaKcUGobvnJZHz9+PCtXruS1115rsvyGG25o/HrIkCF0796dUaNGsWbNGgYMGPDVkx4Ft912G5MnT268X1lZSWZmZhQTSZIkSc1DTX0DTy7ZyCOvrGHn3hoAstI7MGV0DhcOzrCkS8fZVyrrN998My+88AKLFi2iV69eXzg7bNgwAFavXs2AAQPIyMj41Fnby8rKAMjIyGj876Fln5xJTk6mXbt2xMTEEBMT85kzh7bxWRISEkhI8FqPkiRJ0iH1DRH+693NPDhvNVvKDwCQmdaOiaNyuOTUnsSELelSNBzRZ9aDIODmm2/m2WefZf78+fTr1+9LH7Ns2TIAunfvDkBeXh4rVqxg+/btjTNFRUUkJyczaNCgxpl58+Y12U5RURF5eXkAxMfHM3To0CYzkUiEefPmNc5IkiRJ+nyRSMDflm1h9H2LuPW/VrCl/ADdkhP4v5cMZt7k87hsaC+LuhRFR3Rkffz48Tz55JP87W9/o2PHjo2fMU9JSaFdu3asWbOGJ598km9+85t07tyZ5cuXM2nSJEaOHMlJJ50EQEFBAYMGDeLqq6/m7rvvprS0lNtvv53x48c3HvUeN24cDz/8MD/96U+57rrrmD9/Pk8//TQvvvhiY5bJkyczduxYTj/9dM4880zuv/9+9u3bx7XXXnu0vjeSJElSqxMEAXM/2s6MOcV8XFoFQFr7eG46bwDfH96HxLiYKCeUBEd46bbP+5zKE088wTXXXMOmTZv4/ve/z8qVK9m3bx+ZmZl8+9vf5vbbb29ySvoNGzZw4403smDBAtq3b8/YsWP55S9/SWzs//7tYMGCBUyaNIkPP/yQXr168fOf/5xrrrmmyfM+/PDD3HPPPZSWlnLKKafw4IMPNr7t/nB46TZJkiS1FUEQ8PrqXdwzp5j3N5UD0DEhlh+N7M915/SjQ8JXPp2VpCNwuD30a11nvaWzrEuSJKktWLphN/fMLubNtbsBaBcXwzVn9+XHI/uTmhQf5XRS23K4PdQ/n0mSJEmt1MotFcyYU8wrxTsAiI8J871hvbnp/AGkd0yMcjpJX8SyLkmSJLUyq7dXcW9RCX9fcfAcUzHhEP88tBcTRmXTM7VdlNNJOhyWdUmSJKmV2LR7P/fPXcWz720mEkAoBBef1INJo3Po16V9tONJOgKWdUmSJKmFK6us5qH5q/jz25uoazh4SqrRg7oxpSCHgRmem0lqiSzrkiRJUgu1e18tMxeu4XdvrKemPgLAOVldmFKQw6m9O0U5naSvw7IuSZIktTCV1XU8/uo6fvvaOvbW1AMwtE8nphbkkjegc5TTSToaLOuSJElSC3GgtoHfLV7PzIVrKN9fB8Cg7slMK8zlvNyuhEKhKCeUdLRY1iVJkqRmrqa+gafe2sTDr6xmR1UNAAO6tmfy6Fy+MTiDcNiSLrU2lnVJkiSpmapviPDXd7fwwLxVbCk/AECvTu2YmJ/DJaf0IDYmHOWEko4Vy7okSZLUzEQiAS+u2MZ9RSWs3bkPgPSOCUy4IIvLz+hNfKwlXWrtLOuSJElSMxEEAfM+2s6MohI+2lYJQKekOG48bwBXD+9Lu/iYKCeUdLxY1iVJkqRm4I3VO7lnTjHvbSwHoENCLD8a0Z/rzulLx8S46IaTdNxZ1iVJkqQoenfjHqbPLuaNNbsASIwLM/asvowbOYBO7eOjnE5StFjWJUmSpCj4cGslM+YUM+/j7QDExYT43pm9GX9+FunJiVFOJynaLOuSJEnScbRmx17uLSrhxeXbAAiH4DtDe/GTUdn06pQU5XSSmgvLuiRJknQcbNq9nwfmreKv724mEhxcdvHJPZiUn03/rh2iG05Ss2NZlyRJko6h7ZXVPPzKav701kbqGg629PwT0pk8OpdBPZKjnE5Sc2VZlyRJko6BPftqmblwDb9bvJ7quggAZ2d1ZkpBLqf17hTldJKaO8u6JEmSdBRVVdfxm9fW8fir69hbUw/Aqb1TmVaQy1lZXaKcTlJLYVmXJEmSjoIDtQ385+L1zFy4hj376wA4oXsyUwtyuGBgOqFQKMoJJbUklnVJkiTpa6itj/DU2xt5eP5qtlfVANC/a3smj87hm4O7Ew5b0iUdOcu6JEmS9BXUN0R49r0tPDBvFZv3HACgZ2o7bsnP5tJTexIbE45yQkktmWVdkiRJOgKRSMDfV27j3qIS1u7YB0DXjglMuCCLy8/IJCE2JsoJJbUGlnVJkiTpMARBwCvF25k+u4QPt1UCkJoUx43nDuAHeX1pF29Jl3T0WNYlSZKkL/HGmp1Mn13MuxvLAeiQEMv15/Tj+hH9SE6Mi244Sa2SZV2SJEn6HO9t3MP0OcW8vnoXAAmxYa45qy8/PncAae3jo5xOUmtmWZckSZL+wUfbKpkxp4S5H5UBEBcT4oozenPzBVl0S06McjpJbYFlXZIkSfofa3fs5b65q3hh+VaCAMIhuPS0XtwyKpvMtKRox5PUhljWJUmS1OZtKT/Ag3NX8Zd3N9MQCQAYc1J3JuXnkJXeIcrpJLVFlnVJkiS1Wdurqnn0lTU8uWQjtQ0RAEYNTGdyQQ4n9kiJcjpJbZllXZIkSW1O+f5aZi5cy6w31lFdd7Ck5/XvzNTCXIb26RTldJJkWZckSVIbsremnt+8uo7HX11LVU09AKdkpjKtMJezs7pEOZ0k/S/LuiRJklq96roGfr94A48uWM2e/XUADMzoyNSCXEadkE4oFIpyQklqyrIuSZKkVqu2PsKf39nEw/NXUVZZA0C/Lu2ZNDqHi4Z0Jxy2pEtqnizrkiRJanUaIgHPvreFB+aVsGn3AQB6prbjllHZXHpaT2JjwlFOKElfzLIuSZKkViMSCXj5g1LuLSph9fa9AHTpkMDN5w/gymG9SYiNiXJCSTo8lnVJkiS1eEEQsKB4B9PnFPPB1koAUtrFMe7cAYw9qw9J8f7aK6ll8aeWJEmSWrQ31+5i+uxi3tmwB4D28TFcP6I/PxzRj+TEuCink6SvxrIuSZKkFun9TeVMn1PMq6t2ApAQG+YHeX0Yd+4AOndIiHI6Sfp6LOuSJElqUT4urWTGnBKKPiwDIDYc4oozM7n5/GwyUhKjnE6Sjg7LuiRJklqE9Tv3cd/cEv77/a0EAYRDcMmpPZk4KofenZOiHU+SjirLuiRJkpq1reUHeHDeKp5ZupmGSADAN4dkMHl0DlnpHaOcTpKODcu6JEmSmqUdVTU88spqnlyykdqGCADn53ZlSkEug3umRDmdJB1blnVJkiQ1KxX76/jVojU88fp6DtQ1ADCsXxrTCnM5vW9alNNJ0vFhWZckSVKzsLemnideW8evX11LVXU9ACf3SmFqYS7nZHUhFApFOaEkHT+WdUmSJEVVdV0Df3hzA48uWMPufbUA5HbryJSCHEYP6mZJl9QmWdYlSZIUFXUNEZ5+ZxMPzVtNaWU1AH07JzFpdA4Xn9SDcNiSLqntsqxLkiTpuGqIBPxt2Rbun7uKjbv3A9AjJZGfjMrmsqG9iIsJRzmhJEWfZV2SJEnHRRAEvLyylHuLSli1fS8AXTrEM/78LK48szeJcTFRTihJzYdlXZIkScdUEAQsLNnBjDklrNhSAUByYiw/PncA157dl6R4fyWVpH/kT0ZJkiQdM0vW7mL6nGLeXr8HgKT4GK4/px8/HNGflHZxUU4nSc2XZV2SJElH3fLN5dwzu5hXV+0EID42zA+G9+HG8wbQuUNClNNJUvNnWZckSdJRU1JWxYw5xcz+oAyA2HCI756RyYQLsuie0i7K6SSp5bCsS5Ik6Wtbv3Mf988t4W/vbyUIIBSCb5/Sk1vys+nTuX2040lSi2NZlyRJ0le2reIAD85bzdPvbKIhEgBw4YkZTC7IIadbxyink6SWy7IuSZKkI7Zzbw2PvrKGPyzZQG19BIBzc7oytSCXIb1SopxOklo+y7okSZIOW8X+On796hqeeH09+2sbADizXxrTCnM5o29alNNJUuthWZckSdKX2ldTz6w31vOrhWuorK4H4KReKUwtyGVEdhdCoVCUE0pS62JZlyRJ0ueqrmvgj0s28tiC1ezcWwtATrcOTB6dS+GJ3SzpknSMWNYlSZL0KXUNEZ55ZzMPzV/FtopqAPp0TmJSfg4Xn9yDmLAlXZKOJcu6JEmSGjVEAp5/fyv3zS1hw679AHRPSeQno7L5ztBexMWEo5xQktoGy7okSZIIgoDZH5Rxb1ExJWV7AejcPp6bzs/iqmG9SYyLiXJCSWpbLOuSJEltWBAELFq1kxlzilm+uQKA5MRYfnzuAK45qy/tE/x1UZKiwZ++kiRJbdTb63dzz+xi3lq3G4Ck+BiuPbsvN4wYQEpSXJTTSVLbdkQfOrrrrrs444wz6NixI+np6VxyySUUFxc3mamurmb8+PF07tyZDh06cNlll1FWVtZkZuPGjYwZM4akpCTS09OZNm0a9fX1TWYWLFjAaaedRkJCAllZWcyaNetTeR555BH69u1LYmIiw4YN46233jqSlyNJktQmrdhcwdjfvsU/z1zMW+t2Ex8b5rqz+7Hop+czrXCgRV2SmoEjKusLFy5k/PjxvPnmmxQVFVFXV0dBQQH79u1rnJk0aRLPP/88zzzzDAsXLmTr1q1ceumljesbGhoYM2YMtbW1vPHGG/zud79j1qxZ/OIXv2icWbduHWPGjOH8889n2bJlTJw4kR/+8IfMnj27cebPf/4zkydP5o477uDdd9/l5JNPprCwkO3bt3+d74ckSVKrtaqsinG/X8rFD7/GwpIdxIRDXHlmbxZMPY9fXDyILh0Soh1RkvQ/QkEQBF/1wTt27CA9PZ2FCxcycuRIKioq6Nq1K08++STf+c53APj444854YQTWLx4McOHD+ell17ioosuYuvWrXTr1g2AmTNncuutt7Jjxw7i4+O59dZbefHFF1m5cmXjc11xxRWUl5fz8ssvAzBs2DDOOOMMHn74YQAikQiZmZlMmDCBn/3sZ4eVv7KykpSUFCoqKkhOTv6q3wZJkqRmbeOu/dw/t4Rnl20hCCAUgm+d3IOJ+Tn07dI+2vEkqU053B76ta69UVFx8CQkaWlpACxdupS6ujry8/MbZwYOHEjv3r1ZvHgxAIsXL2bIkCGNRR2gsLCQyspKPvjgg8aZT27j0MyhbdTW1rJ06dImM+FwmPz8/MaZz1JTU0NlZWWTmyRJUmtVWlHNvzy7ggtmLOCv7x0s6oUnduPlW0Zy/xWnWtQlqRn7yieYi0QiTJw4kbPPPpvBgwcDUFpaSnx8PKmpqU1mu3XrRmlpaePMJ4v6ofWH1n3RTGVlJQcOHGDPnj00NDR85szHH3/8uZnvuusu7rzzziN/sZIkSS3Irr01PLZgDf/55gZq6yMAjMjuwtSCXE7OTI1uOEnSYfnKZX38+PGsXLmS11577WjmOaZuu+02Jk+e3Hi/srKSzMzMKCaSJEk6eioO1PH4q2v57Wvr2FfbAMAZfTsxtSCXYf07RzmdJOlIfKWyfvPNN/PCCy+waNEievXq1bg8IyOD2tpaysvLmxxdLysrIyMjo3HmH8/afuhs8Z+c+cczyJeVlZGcnEy7du2IiYkhJibmM2cObeOzJCQkkJDgiVMkSVLrsr+2nideX8+vF62l4kAdAEN6pjClIIdzc7oSCoWinFCSdKSO6DPrQRBw88038+yzzzJ//nz69evXZP3QoUOJi4tj3rx5jcuKi4vZuHEjeXl5AOTl5bFixYomZ20vKioiOTmZQYMGNc58chuHZg5tIz4+nqFDhzaZiUQizJs3r3FGkiSptaupb+CJ19cx8u4F3DO7mIoDdWSnd2Dm90/jv28+m/Ny0y3qktRCHdGR9fHjx/Pkk0/yt7/9jY4dOzZ+xjwlJYV27dqRkpLC9ddfz+TJk0lLSyM5OZkJEyaQl5fH8OHDASgoKGDQoEFcffXV3H333ZSWlnL77bczfvz4xqPe48aN4+GHH+anP/0p1113HfPnz+fpp5/mxRdfbMwyefJkxo4dy+mnn86ZZ57J/fffz759+7j22muP1vdGkiSpWapviPCXpZt5cN4qtlZUA9A7LYmJ+dl865SexIQt6JLU0h3Rpds+7y+zTzzxBNdccw0A1dXVTJkyhT/96U/U1NRQWFjIo48+2uTt6Rs2bODGG29kwYIFtG/fnrFjx/LLX/6S2Nj//dvBggULmDRpEh9++CG9evXi5z//eeNzHPLwww9zzz33UFpayimnnMKDDz7IsGHDDvvFe+k2SZLUkkQiAc8v38p9RSWs37UfgIzkRCaMyuK7p2cSF/O1LvQjSToODreHfq3rrLd0lnVJktQSBEFA0YdlzJhTQnFZFQBp7eO56bwBfH94HxLjYqKcUJJ0uA63h37ls8FLkiTp2AqCgNdW72T6nBLe31QOQMfEWG4Y0Z9rz+lHhwR/lZOk1sqf8JIkSc3QO+t3c8/sYpas2w1Au7gYrj27LzeM7E9qUnyU00mSjjXLuiRJUjOycksFM+YU80rxDgDiY8J8b1hvxp+fRdeOXoJWktoKy7okSVIzsHp7FfcWlfD3FQevthMTDvHPQ3sxYVQ2PVPbRTmdJOl4s6xLkiRF0abd+7lvbgnPvbeFSAChEPzTyT2YmJ9Dvy7tox1PkhQllnVJkqQoKKus5qH5q/jz25uoazh4cZ7Rg7oxpSCHgRlepUaS2jrLuiRJ0nG0e18tjy1YzX8u3kBNfQSAEdldmFKQyymZqdENJ0lqNizrkiRJx0FldR2Pv7qO37y6ln21DQAM7dOJqQW55A3oHOV0kqTmxrIuSZJ0DO2vred3b2xg5sI1VByoA+DEHslMLcjlvNyuhEKhKCeUJDVHlnVJkqRjoKa+gT8t2cjDr6xh594aALLSOzB5dA4XnphBOGxJlyR9Psu6JEnSUVTfEOGv727hgXmr2FJ+AIDMtHZMHJXDJaf2JMaSLkk6DJZ1SZKkoyASCXhhxTbuLyph7c59AHRLTmDCBdl89/RM4mPDUU4oSWpJLOuSJElfQxAEzPtoO9PnFPNxaRUAnZLiuOm8LK7O60NiXEyUE0qSWiLLuiRJ0lf0+uqd3DO7mGWbygHomBDLj0b257pz+tEhwV+zJElfnf+KSJIkHaGlG/YwfXYxi9fuAiAxLsw1Z/Vj3Ln9SU2Kj3I6SVJrYFmXJEk6TB9srWDGnBLmf7wdgPiYMN8b1pubzh9AesfEKKeTJLUmlnVJkqQvsXr7Xu6bW8KLy7cBEBMOcdlpPfnJqGx6dUqKcjpJUmtkWZckSfocm3bv54F5q/jru5uJBAeXXXxyDyblZ9O/a4fohpMktWqWdUmSpH+wvbKah+av5qm3N1LXcLCl55/QjSkFOZzQPTnK6SRJbYFlXZIk6X/s2VfLzIVr+N3i9VTXRQA4O6szUwpyOa13pyinkyS1JZZ1SZLU5lVV1/H4q+v4zWvr2FtTD8BpvVOZWpjLWQO6RDmdJKktsqxLkqQ260BtA/+5eD2PLVxD+f46AE7onsy0whzOz00nFApFOaEkqa2yrEuSpDantj7CU29v5KH5q9lRVQNA/67tmTw6h28O7k44bEmXJEWXZV2SJLUZ9Q0R/vreFh6Yu4ot5QcA6NWpHbeMyubbp/YkNiYc5YSSJB1kWZckSa1eJBLw95XbuLeohLU79gGQ3jGBCRdkcfkZvYmPtaRLkpoXy7okSWq1giBg/sfbmT6nhI+2VQKQmhTHTecN4OrhfWkXHxPlhJIkfTbLuiRJapXeWLOT6bOLeXdjOQAdEmL54Yh+XH9OPzomxkU3nCRJX8KyLkmSWpV3N+5hxpxiXl+9C4DEuDBjz+rLuJED6NQ+PsrpJEk6PJZ1SZLUKny4tZJ7i4qZ+9F2AOJiQlx5Zm9uPj+L9OTEKKeTJOnIWNYlSVKLtmbHXu4rKuGF5dsACIfgstN68ZNR2WSmJUU5nSRJX41lXZIktUib9+zngbmr+K93NxMJDi676KTuTBqdw4CuHaIbTpKkr8myLkmSWpTtVdU8Mn81T761kbqGgy191MB0JhfkcGKPlCinkyTp6LCsS5KkFmHPvlpmLlrD795YT3VdBICzBnRmSkEuQ/t0inI6SZKOLsu6JElq1qqq6/jta+t5/NW1VNXUA3BKZirTCnM5O6tLlNNJknRsWNYlSVKzVF3XwH8uXs9jC9awZ38dAAMzOjK1IJdRJ6QTCoWinFCSpGPHsi5JkpqV2voIf35nEw/NW8X2qhoA+ndpz6TROYwZ0p1w2JIuSWr9LOuSJKlZaIgEPPveFu6fW8LmPQcA6JnajltGZXPpaT2JjQlHOaEkScePZV2SJEVVJBLw0spS7i0qZs2OfQB06ZDAhAuyuOLMTBJiY6KcUJKk48+yLkmSoiIIAhYU72D6nGI+2FoJQGpSHOPOHcDYvL60i7ekS5LaLsu6JEk67hav2cX0OcUs3bAHgPbxMfxwRH+uH9GP5MS4KKeTJCn6LOuSJOm4WbapnOmzi3lt9U4AEmLDjD2rL+POHUBa+/gop5MkqfmwrEuSpGPu49JKZswpoejDMgDiYkJccUZvbr4gi27JiVFOJ0lS82NZlyRJx8y6nfu4r6iE55dvJQggHIJvn9qLifnZZKYlRTueJEnNlmVdkiQddVvKD/Dg3FX85d3NNEQCAMYM6c6k0dlkpXeMcjpJkpo/y7okSTpqtldV8+gra3hyyUZqGyIAXDAwncmjcxjcMyXK6SRJajks65Ik6Wsr31/LrxatZdbr6zlQ1wDA8P5pTCvMZWiftCinkySp5bGsS5Kkr2xvTT2/fW0d/2/RWqpq6gE4OTOVaQW5nJ3VmVAoFOWEkiS1TJZ1SZJ0xKrrGvjDmxt4dMEadu+rBWBgRkemFOSSf0K6JV2SpK/Jsi5Jkg5bbX2Ep9/ZxEPzV1FWWQNAvy7tmZifzcUn9SActqRLknQ0WNYlSdKXaogEPPfeFu6fV8Km3QcA6JGSyC352Vx2Wi9iY8JRTihJUutiWZckSZ8rCAJeXlnKvUUlrNq+F4AuHeIZf34W3xvWm4TYmCgnlCSpdbKsS5KkTwmCgAUlO5gxp5iVWyoBSGkXx4/P7c81Z/UlKd5fISRJOpb8l1aSJDWxZO0ups8p5u31ewBoHx/D9ef04/oR/UlpFxfldJIktQ2WdUmSBMD7m8qZPqeYV1ftBCA+NszYvD6MO3cAnTskRDmdJElti2VdkqQ2rri0ihlzipnzYRkAseEQl5+RyYQLsslISYxyOkmS2ibLuiRJbdT6nfu4f24Jf3t/K0EA4RBccmpPJo7KoXfnpGjHkySpTbOsS5LUxmwtP8BD81fx9DubaYgEAHxjcAaTR+eQ3a1jlNNJkiSwrEuS1GbsqKrh0QWr+eOSjdTWRwA4L7crUwtyGdwzJcrpJEnSJ1nWJUlq5Sr21/GrRWt44vX1HKhrAODMfmlMK8zljL5pUU4nSZI+i2VdkqRWal9NPU+8vo5fLVpLVXU9ACf1SmFqQS4jsrsQCoWinFCSJH0ey7okSa1MdV0Df3hzA48tWMOufbUA5HbryOSCHAoGdbOkS5LUAljWJUlqJeoaIjzzzmYenLeK0spqAPp0TmLy6BwuOqkHMWFLuiRJLYVlXZKkFq4hEvDf72/h/rmr2LBrPwDdUxL5yahsvjO0F3Ex4SgnlCRJR8qyLklSCxUEAbM/KOXeohJKyvYC0KVDPDedl8X3hvUmMS4mygklSdJXdcR/al+0aBEXX3wxPXr0IBQK8dxzzzVZf8011xAKhZrcLrzwwiYzu3fv5qqrriI5OZnU1FSuv/569u7d22Rm+fLljBgxgsTERDIzM7n77rs/leWZZ55h4MCBJCYmMmTIEP7+978f6cuRJKnFCYKAhSU7+NYjrzPuD+9SUraX5MRYphXmsnDa+Vx3Tj+LuiRJLdwRH1nft28fJ598Mtdddx2XXnrpZ85ceOGFPPHEE433ExISmqy/6qqr2LZtG0VFRdTV1XHttddyww038OSTTwJQWVlJQUEB+fn5zJw5kxUrVnDdddeRmprKDTfcAMAbb7zBlVdeyV133cVFF13Ek08+ySWXXMK7777L4MGDj/RlSZLUIry1bjfTZxfz1vrdACTFx3Dd2f340cj+pLSLi3I6SZJ0tISCIAi+8oNDIZ599lkuueSSxmXXXHMN5eXlnzrifshHH33EoEGDePvttzn99NMBePnll/nmN7/J5s2b6dGjB4899hj/+q//SmlpKfHx8QD87Gc/47nnnuPjjz8G4PLLL2ffvn288MILjdsePnw4p5xyCjNnzjys/JWVlaSkpFBRUUFycvJX+A5IknR8rNhcwT1zillUsgOA+NgwVw/vw43nDaBLh4QvebQkSWouDreHHpMzzixYsID09HRyc3O58cYb2bVrV+O6xYsXk5qa2ljUAfLz8wmHwyxZsqRxZuTIkY1FHaCwsJDi4mL27NnTOJOfn9/keQsLC1m8ePHn5qqpqaGysrLJTZKk5qykrIpxv1/KxQ+/xqKSHcSGQ3xvWG8WTjuPn180yKIuSVIrddRPMHfhhRdy6aWX0q9fP9asWcO//Mu/8I1vfIPFixcTExNDaWkp6enpTUPExpKWlkZpaSkApaWl9OvXr8lMt27dGtd16tSJ0tLSxmWfnDm0jc9y1113ceeddx6NlylJ0jG1Ydc+7p+7iueWbSEIIBSCS07pycT8bPp0bh/teJIk6Rg76mX9iiuuaPx6yJAhnHTSSQwYMIAFCxYwatSoo/10R+S2225j8uTJjfcrKyvJzMyMYiJJkpraVnGAh+av5um3N1EfOfhJtQtPzGByQQ453TpGOZ0kSTpejvml2/r370+XLl1YvXo1o0aNIiMjg+3btzeZqa+vZ/fu3WRkZACQkZFBWVlZk5lD979s5tD6z5KQkPCpk91JktQc7Npbw6ML1vD7NzdQWx8BYGROV6YW5HBSr9TohpMkScfdMfnM+idt3ryZXbt20b17dwDy8vIoLy9n6dKljTPz588nEokwbNiwxplFixZRV1fXOFNUVERubi6dOnVqnJk3b16T5yoqKiIvL+9YvyRJko6aigN1TJ9dzIi7X+E3r62jtj7CmX3TePrHefzndWda1CVJaqOO+Mj63r17Wb16deP9devWsWzZMtLS0khLS+POO+/ksssuIyMjgzVr1vDTn/6UrKwsCgsLATjhhBO48MIL+dGPfsTMmTOpq6vj5ptv5oorrqBHjx4AfO973+POO+/k+uuv59Zbb2XlypU88MAD3HfffY3Pe8stt3DuuecyY8YMxowZw1NPPcU777zDr3/966/7PZEk6ZjbV1PPrDfW86uFa6isrgdgSM8UphbmMjK7C6FQKMoJJUlSNB3xpdsWLFjA+eef/6nlY8eO5bHHHuOSSy7hvffeo7y8nB49elBQUMD/+T//p8nJ4Hbv3s3NN9/M888/Tzgc5rLLLuPBBx+kQ4cOjTPLly9n/PjxvP3223Tp0oUJEyZw6623NnnOZ555httvv53169eTnZ3N3XffzTe/+c3Dfi1euk2SdLxV1zXw5JKNPLpgNTv31gKQnd6BKQU5FJ6YYUmXJKmVO9we+rWus97SWdYlScdLXUOEvyzdzIPzVrGtohqA3mlJTBqdzT+d3JOYsCVdkqS24HB76DE/wZwkSW1ZJBLw/PKt3FdUwvpd+wHISE7kJ6Oy+efTexEXc8xPHyNJklogy7okScdAEATM+bCMe+eUUFxWBUDn9vHceN4Avj+8D4lxMVFOKEmSmjPLuiRJR1EQBLy6aicz5hTz/uYKADomxvLjkf259ux+tE/wn15JkvTl/I1BkqSj5J31u7lndjFL1u0GoF1cDNee3ZcfjxxASlJclNNJkqSWxLIuSdLXtHJLBdPnFLOgeAcA8TFhrhrem5vOy6Jrx4Qop5MkSS2RZV2SpK9oVVkV9xaV8NLKUgBiwiG+e3ovJlyQTY/UdlFOJ0mSWjLLuiRJR2jjrv3cP6+E597bQiSAUAj+6eQeTMzPoV+X9tGOJ0mSWgHLuiRJh6m0opqH5q/iz29voj4SAFAwqBtTCnLJzegY5XSSJKk1saxLkvQldu+r5bEFq/nPxRuoqY8AMCK7C1MLcjk5MzW64SRJUqtkWZck6XNUVtfx+KK1/Oa1deyrbQDg9D6dmFqYy/D+naOcTpIktWaWdUmS/sH+2npmvbGeXy1cS8WBOgAG90xmSkEu5+V0JRQKRTmhJElq7SzrkiT9j5r6Bv60ZCMPv7KGnXtrAMhK78CU0TlcODjDki5Jko4by7okqc2rb4jwX+9u5sF5q9lSfgCAzLR2TByVwyWn9iQmbEmXJEnHl2VdktRmRSIBzy/fyv1zV7Fu5z4AuiUnMOGCbL57eibxseEoJ5QkSW2VZV2S1OYEQcDcj7YzY04xH5dWAZDWPp6bzhvA94f3ITEuJsoJJUlSW2dZlyS1GUEQ8PrqXdwzp5j3N5UD0DEhlh+N7M915/SjQ4L/LEqSpObB30okSW3C0g27uWd2MW+u3Q1Au7gYrjm7Lz8e2Z/UpPgop5MkSWrKsi5JatU+2FrBjDklzP94OwDxMWG+N6w3N50/gPSOiVFOJ0mS9Nks65KkVmn19r3cV1TCiyu2ARATDvGd03rxk/xseqa2i3I6SZKkL2ZZlyS1Kpt27+f+uat49r3NRIKDy/7p5B5MzM+mf9cO0Q0nSZJ0mCzrkqRWoayymofnr+aptzdS13Cwpeef0I0pBTmc0D05yukkSZKOjGVdktSi7d5Xy8yFa/jdG+upqY8AcE5WF6YU5HBq705RTidJkvTVWNYlSS1SVXUdj7+6jt+8to69NfUADO3TiakFueQN6BzldJIkSV+PZV2S1KIcqG3gd4vXM3PhGsr31wEwqHsy0wpzOS+3K6FQKMoJJUmSvj7LuiSpRaipb+Cptzbx8Cur2VFVA8CAru2ZPDqXbwzOIBy2pEuSpNbDsi5JatbqGyL89b0tPDB3FVvKDwDQq1M7JubncMkpPYiNCUc5oSRJ0tFnWZckNUuRSMCLK7Zx39wS1u7YB0B6xwQmXJDF5Wf0Jj7Wki5Jklovy7okqVkJgoB5H21nRlEJH22rBKBTUhw3njeAq4f3pV18TJQTSpIkHXuWdUlSs/HG6p3cM6eY9zaWA9AhIZYfjejPdef0pWNiXHTDSZIkHUeWdUlS1L27cQ/TZxfzxppdACTGhRl7Vl/GjRxAp/bxUU4nSZJ0/FnWJUlR8+HWSmbMKWbex9sBiIsJ8b0zezP+/CzSkxOjnE6SJCl6LOuSpONuzY693FdUwgvLtwEQDsFlp/XiJ6OyyUxLinI6SZKk6LOsS5KOm8179vPA3FX817ubiQQHl110Uncmjc5hQNcO0Q0nSZLUjFjWJUnH3PbKah5+ZTV/emsjdQ0HW3r+CelMHp3LoB7JUU4nSZLU/FjWJUnHzJ59tcxctIbfvbGe6roIAGdndWZKQS6n9e4U5XSSJEnNl2VdknTUVVXX8ZvX1vGbV9dRVVMPwKm9U5lWkMtZWV2inE6SJKn5s6xLko6a6roG/nPxeh5bsIY9++sAOKF7MlMLcrhgYDqhUCjKCSVJkloGy7ok6WurrY/w57c38tD81WyvqgGgf9f2TB6dwzcHdycctqRLkiQdCcu6JOkrq2+I8Ox7W3hg3io27zkAQM/UdtySn82lp/YkNiYc5YSSJEktk2VdknTEIpGAl1aWcm9RMWt27AOga8cEJlyQxeVnZJIQGxPlhJIkSS2bZV2SdNiCIOCV4u1Mn13Ch9sqAUhNiuPGcwfwg7y+tIu3pEuSJB0NlnVJ0mF5Y81OZswpYemGPQB0SIjl+nP6cf2IfiQnxkU5nSRJUutiWZckfaH3Nu5h+pxiXl+9C4CE2DDXnNWXH587gLT28VFOJ0mS1DpZ1iVJn+mjbZXMmFPC3I/KAIiLCXHFGb25+YIsuiUnRjmdJElS62ZZlyQ1sXbHXu6bu4oXlm8lCCAcgktP68Uto7LJTEuKdjxJkqQ2wbIuSQJgS/kBHpy7ir+8u5mGSADAmCHdmTQ6h6z0DlFOJ0mS1LZY1iWpjdteVc2jr6zhySUbqW2IAHDBwHQmj85hcM+UKKeTJElqmyzrktRGle+vZebCtfzujfUcqGsAYHj/NKYV5jK0T1qU00mSJLVtlnVJamP21tTz29fW8f8WraWqph6AUzJTmVaYy1kDOhMKhaKcUJIkSZZ1SWojqusa+P3iDTy2cA2799UCMDCjI1MLchl1QrolXZIkqRmxrEtSK1dbH+Hpdzbx0PxVlFXWANCvS3smjc7hoiHdCYct6ZIkSc2NZV2SWqmGSMBz723h/nklbNp9AICeqe24ZVQ2l57Wk9iYcJQTSpIk6fNY1iWplYlEAl7+oJR7i0pYvX0vAF06JHDz+QO4clhvEmJjopxQkiRJX8ayLkmtRBAELCjZwYw5xazcUglASrs4xp07gLFn9SEp3h/5kiRJLYW/uUlSK/Dm2l1Mn13MOxv2ANA+PobrR/TnhyP6kZwYF+V0kiRJOlKWdUlqwd7fVM70OcW8umonAAmxYX6Q14dx5w6gc4eEKKeTJEnSV2VZl6QW6OPSSmbMKaHowzIAYsMhrjgzk5vPzyYjJTHK6SRJkvR1WdYlqQVZv3Mf980t4b/f30oQQDgEl5zak4mjcujdOSna8SRJknSUWNYlqQXYWn6AB+et4pmlm2mIBAB8c0gGk0fnkJXeMcrpJEmSdLRZ1iWpGdtRVcMjr6zmySUbqW2IAHB+blemFOQyuGdKlNNJkiTpWLGsS1IzVLG/jl8tWsMTr6/nQF0DAMP6pTGtMJfT+6ZFOZ0kSZKONcu6JDUje2vqeeK1dfz61bVUVdcDcHKvFKYW5nJOVhdCoVCUE0qSJOl4sKxLUjNQXdfAH97cwGML1rBrXy0Aud06Mrkgh4JB3SzpkiRJbYxlXZKiqK4hwtPvbOKheasprawGoG/nJCaNzuGik3oQE7akS5IktUXhI33AokWLuPjii+nRowehUIjnnnuuyfogCPjFL35B9+7dadeuHfn5+axatarJzO7du7nqqqtITk4mNTWV66+/nr179zaZWb58OSNGjCAxMZHMzEzuvvvuT2V55plnGDhwIImJiQwZMoS///3vR/pyJCkqGiIBz763mVEzFvKvz66ktLKaHimJ/PLSIRRNPpdvndLToi5JktSGHXFZ37dvHyeffDKPPPLIZ66/++67efDBB5k5cyZLliyhffv2FBYWUl1d3Thz1VVX8cEHH1BUVMQLL7zAokWLuOGGGxrXV1ZWUlBQQJ8+fVi6dCn33HMP//Zv/8avf/3rxpk33niDK6+8kuuvv5733nuPSy65hEsuuYSVK1ce6UuSpOMmCAJeXrmNC+9fxKQ/v8/G3fvp0iGeOy4exPyp53HFmb2JizniH82SJElqZUJBEARf+cGhEM8++yyXXHIJcPCX0B49ejBlyhSmTp0KQEVFBd26dWPWrFlcccUVfPTRRwwaNIi3336b008/HYCXX36Zb37zm2zevJkePXrw2GOP8a//+q+UlpYSHx8PwM9+9jOee+45Pv74YwAuv/xy9u3bxwsvvNCYZ/jw4ZxyyinMnDnzsPJXVlaSkpJCRUUFycnJX/XbIElfKggCFpbsYMacElZsqQAgOTGWH587gGvP7ktSvJ9KkiRJagsOt4ce1cM369ato7S0lPz8/MZlKSkpDBs2jMWLFwOwePFiUlNTG4s6QH5+PuFwmCVLljTOjBw5srGoAxQWFlJcXMyePXsaZz75PIdmDj3PZ6mpqaGysrLJTZKOtbfW7ebyX73JNU+8zYotFSTFxzDhgixevfUCxp+fZVGXJEnSpxzV3xBLS0sB6NatW5Pl3bp1a1xXWlpKenp60xCxsaSlpTWZ6dev36e2cWhdp06dKC0t/cLn+Sx33XUXd95551d4ZZJ05JZvLmf6nBIWlewAID42zA+G9+HG8wbQuUNClNNJkiSpOWtTh3Nuu+02Jk+e3Hi/srKSzMzMKCaS1BqVlFUxY04xsz8oAyA2HOK7Z2Qy4YIsuqe0i3I6SZIktQRHtaxnZGQAUFZWRvfu3RuXl5WVccoppzTObN++vcnj6uvr2b17d+PjMzIyKCsrazJz6P6XzRxa/1kSEhJISPBolqRjY/3OfTwwbxXPLdtCEEAoBN8+pSe35GfTp3P7aMeTJElSC3JUP7Per18/MjIymDdvXuOyyspKlixZQl5eHgB5eXmUl5ezdOnSxpn58+cTiUQYNmxY48yiRYuoq6trnCkqKiI3N5dOnTo1znzyeQ7NHHoeSTpetlUc4La/rmDUvQt59r2DRf3CEzOYPXEk915+ikVdkiRJR+yIj6zv3buX1atXN95ft24dy5YtIy0tjd69ezNx4kT+7//9v2RnZ9OvXz9+/vOf06NHj8Yzxp9wwglceOGF/OhHP2LmzJnU1dVx8803c8UVV9CjRw8Avve973HnnXdy/fXXc+utt7Jy5UoeeOAB7rvvvsbnveWWWzj33HOZMWMGY8aM4amnnuKdd95pcnk3STqWdu6t4dFX1vCHJRuorY8AcG5OV6YW5DKkV0qU00mSJKklO+JLty1YsIDzzz//U8vHjh3LrFmzCIKAO+64g1//+teUl5dzzjnn8Oijj5KTk9M4u3v3bm6++Waef/55wuEwl112GQ8++CAdOnRonFm+fDnjx4/n7bffpkuXLkyYMIFbb721yXM+88wz3H777axfv57s7GzuvvtuvvnNbx72a/HSbZK+ior9dfz61TU88fp69tc2AHBm3zSmFuZyZr+0KKeTJElSc3a4PfRrXWe9pbOsSzoS+2rqmfXGen61cA2V1fUADOmZwtTCXEZmdyEUCkU5oSRJkpq7w+2hbeps8JL0VVTXNfDHJRt5bMFqdu6tBSCnWwcmj86l8MRulnRJkiQddZZ1SfocdQ0R/rJ0Mw/OW8W2imoAeqclMXl0Dhef3IOYsCVdkiRJx4ZlXZL+QUMk4Pn3t3Lf3BI27NoPQPeURCZckM0/n96LuJijeiENSZIk6VMs65L0P4IgYPYHZdxbVExJ2V4AOreP56bzs7hqWG8S42KinFCSJElthWVdUpsXBAGvrtrJjDnFvL+5AoDkxFh+fO4ArjmrL+0T/FEpSZKk48vfQCW1aW+v3809s4t5a91uAJLiY7j27L7cMGIAKUlxUU4nSZKktsqyLqlNWrmlgulzillQvAOA+Ngw3x/Wh5vOH0CXDglRTidJkqS2zrIuqU1ZVVbFvUUlvLSyFICYcIjvnp7JhAuy6JHaLsrpJEmSpIMs65LahI279nP/3BKeW7aFSAChEHzr5B5MzM+hb5f20Y4nSZIkNWFZl9SqlVZU89D8Vfz57U3URwIACk/sxuTRueRmdIxyOkmSJOmzWdYltUq79tbw2II1/P7NDdTURwAYkd2FqQW5nJyZGt1wkiRJ0pewrEtqVSoO1PH4q2v57Wvr2FfbAMAZfTsxtSCXYf07RzmdJEmSdHgs65Jahf219Tzx+np+vWgtFQfqABjcM5mpBbmcm9OVUCgU5YSSJEnS4bOsS2rRauobeHLJRh55ZQ0799YAkJXegSmjc7hwcIYlXZIkSS2SZV1Si1TfEOEvSzfz4LxVbK2oBqB3WhIT87P51ik9iQlb0iVJktRyWdYltSiRSMDzy7dyX1EJ63ftB6BbcgI/GZXNd0/PJC4mHOWEkiRJ0tdnWZfUIgRBQNGHZdxbVMLHpVUApLWP56bzBvD94X1IjIuJckJJkiTp6LGsS2rWgiDgtdU7mT6nhPc3lQPQMTGWG0b059pz+tEhwR9jkiRJan38LVdSs7V0w27umV3Mm2t3A9AuLoZrz+7LDSP7k5oUH+V0kiRJ0rFjWZfU7KzcUsGMOcW8UrwDgPiYMN8b1pvx52fRtWNClNNJkiRJx55lXVKzsXp7FfcWlfD3FaUAxIRD/PPQXkwYlU3P1HZRTidJkiQdP5Z1SVG3afd+7p+7imff20wkgFAI/unkHkzMz6Ffl/bRjidJkiQdd5Z1SVFTVlnNQ/NX8ee3N1HXEAAwelA3phTkMDAjOcrpJEmSpOixrEs67nbvq2XmwjX87o311NRHABiR3YUpBbmckpka3XCSJElSM2BZl3TcVFbX8fir6/jta+vYW1MPwNA+nZhakEvegM5RTidJkiQ1H5Z1Scfc/tp6fvfGBn61aA3l++sAOLFHMlMLcjkvtyuhUCjKCSVJkqTmxbIu6ZipqW/gT0s28vAra9i5twaAAV3bM6UglwtPzCActqRLkiRJn8WyLumoq2+I8Nd3t/DAvFVsKT8AQK9O7ZiYn8O3T+1JjCVdkiRJ+kKWdUlHTSQS8MKKbdxfVMLanfsASO+YwIRR2Vx+eibxseEoJ5QkSZJaBsu6pK8tCALmfbSd6XOK+bi0CoBOSXHcdF4WV+f1ITEuJsoJJUmSpJbFsi7pa3l99U7umV3Msk3lAHRMiOWHI/pz3Tl96ZgYF91wkiRJUgtlWZf0lSzdsIfps4tZvHYXAIlxYa45qx8/HtmfTu3jo5xOkiRJatks65KOyAdbK7h3TgnzPt4OQHxMmO8N681N5w8gvWNilNNJkiRJrYNlXdJhWbNjL/cWlfDi8m0AxIRDXHZaT34yKptenZKinE6SJElqXSzrkr7Qpt37eWDeKv767mYiwcFlF5/cg0n52fTv2iG64SRJkqRWyrIu6TNtr6zm4VdW86e3NlLXcLCl55/QjSkFOZzQPTnK6SRJkqTWzbIuqYk9+2qZuXANv1u8nuq6CABnZ3VmSkEup/XuFOV0kiRJUttgWZcEQFV1Hb95bR2Pv7qOvTX1AJzWO5WphbmcNaBLlNNJkiRJbYtlXWrjDtQ28J+L1zNz4Rr27K8D4ITuyUwrzOH83HRCoVCUE0qSJEltj2VdaqNq6yM89fZGHp6/mu1VNQD079qeyaNz+Obg7oTDlnRJkiQpWizrUhtT3xDhr+9t4YG5q9hSfgCAnqntmJifzbdP7UlsTDjKCSVJkiRZ1qU2IhIJ+PvKbdxbVMLaHfsA6NoxgQkXZHH5GZkkxMZEOaEkSZKkQyzrUisXBAHzP97O9DklfLStEoDUpDhuPHcAP8jrS7t4S7okSZLU3FjWpVbsjTU7mT67mHc3lgPQISGWH47ox/Xn9KNjYlx0w0mSJEn6XJZ1qRV6b+Meps8p5vXVuwBIjAszNq8v484dQKf28VFOJ0mSJOnLWNalVuSjbZXMmFPM3I+2AxAXE+LKM3tz8/lZpCcnRjmdJEmSpMNlWZdagbU79nLf3FU8//5WAMIhuOy0XvxkVDaZaUlRTidJkiTpSFnWpRZs8579PDhvFf/17hYaIgEAF53UnUmjcxjQtUOU00mSJEn6qizrUgu0vaqaR+av5k9vbaK2IQLAqIHpTC7I4cQeKVFOJ0mSJOnrsqxLLUj5/lpmLlzLrDfWUV13sKSfNaAzUwpyGdqnU5TTSZIkSTpaLOtSC7C3pp7fvLqOx19dS1VNPQCnZKYyrTCXs7O6RDmdJEmSpKPNsi41Y9V1Dfx+8QYeXbCaPfvrABiY0ZGpBbmMOiGdUCgU5YSSJEmSjgXLutQM1dZH+PM7m3h4/irKKmsA6N+lPZNG5zBmSHfCYUu6JEmS1JpZ1qVmpCES8Ox7W3hgXgmbdh8AoGdqO24Zlc2lp/UkNiYc5YSSJEmSjgfLutQMRCIBL60s5d6iYtbs2AdAlw4JTLggiyvOzCQhNibKCSVJkiQdT5Z1KYqCIGBB8Q6mzynmg62VAKS0i2PcuQMYe1YfkuL9X1SSJElqi2wCUpQsXrOL6XOKWbphDwDt42O4fkR/fjiiH8mJcVFOJ0mSJCmaLOvScbZsUznTZxfz2uqdACTEhhl7Vl/GnTuAtPbxUU4nSZIkqTmwrEvHycellcyYU0LRh2UAxIZDXHFmJhMuyKZbcmKU00mSJElqTizr0jG2buc+7isq4fnlWwkCCIfg26f2YmJ+NplpSdGOJ0mSJKkZsqxLx8iW8gM8NG8VzyzdTEMkAGDMkO5MGp1NVnrHKKeTJEmS1JxZ1qWjbEdVDY+8sponl2yktiECwAUD05k8OofBPVOinE6SJElSS2BZl46S8v21/GrRWma9vp4DdQ0ADO+fxrTCXIb2SYtyOkmSJEktiWVd+pr21tTzxGvr+PWra6mqrgfg5MxUphXkcnZWZ0KhUJQTSpIkSWppwkd7g//2b/9GKBRqchs4cGDj+urqasaPH0/nzp3p0KEDl112GWVlZU22sXHjRsaMGUNSUhLp6elMmzaN+vr6JjMLFizgtNNOIyEhgaysLGbNmnW0X4r0harrGnj81bWMvPsVZhSVUFVdz8CMjvy/H5zOczedxTnZXSzqkiRJkr6SY3Jk/cQTT2Tu3Ln/+ySx//s0kyZN4sUXX+SZZ54hJSWFm2++mUsvvZTXX38dgIaGBsaMGUNGRgZvvPEG27Zt4wc/+AFxcXH8x3/8BwDr1q1jzJgxjBs3jj/+8Y/MmzePH/7wh3Tv3p3CwsJj8ZKkRnUNEZ5+ZxMPzVtNaWU1AP26tGdifjYXn9SDcNiCLkmSJOnrCQVBEBzNDf7bv/0bzz33HMuWLfvUuoqKCrp27cqTTz7Jd77zHQA+/vhjTjjhBBYvXszw4cN56aWXuOiii9i6dSvdunUDYObMmdx6663s2LGD+Ph4br31Vl588UVWrlzZuO0rrriC8vJyXn755cPOWllZSUpKChUVFSQnJ3+9F65WryES8LdlW7h/7io27t4PQI+URG7Jz+ay03oRG3PU36giSZIkqZU53B56TNrFqlWr6NGjB/379+eqq65i48aNACxdupS6ujry8/MbZwcOHEjv3r1ZvHgxAIsXL2bIkCGNRR2gsLCQyspKPvjgg8aZT27j0MyhbXyempoaKisrm9ykLxMEAS+t2MaF9y9i8tPvs3H3frp0iOeOiwfxyrTzuPyM3hZ1SZIkSUfVUX8b/LBhw5g1axa5ubls27aNO++8kxEjRrBy5UpKS0uJj48nNTW1yWO6detGaWkpAKWlpU2K+qH1h9Z90UxlZSUHDhygXbt2n5ntrrvu4s477zwaL1NtQBAELCzZwYw5JazYUgFASrs4fnxuf645qy9J8Z6fUZIkSdKxcdTbxje+8Y3Gr0866SSGDRtGnz59ePrppz+3RB8vt912G5MnT268X1lZSWZmZhQTqblasnYX0+cU8/b6PQC0j4/hunP68cMR/UlpFxfldJIkSZJau2N+aDA1NZWcnBxWr17N6NGjqa2tpby8vMnR9bKyMjIyMgDIyMjgrbfearKNQ2eL/+TMP55BvqysjOTk5C/8g0BCQgIJCQlH42WplXp/UznT5xTz6qqdAMTHhvnB8D7ceN4AOndw35EkSZJ0fBzzD9ru3buXNWvW0L17d4YOHUpcXBzz5s1rXF9cXMzGjRvJy8sDIC8vjxUrVrB9+/bGmaKiIpKTkxk0aFDjzCe3cWjm0DakI1VcWsUN//kO33rkdV5dtZPYcIirhvVm0bTzuf2iQRZ1SZIkScfVUT+yPnXqVC6++GL69OnD1q1bueOOO4iJieHKK68kJSWF66+/nsmTJ5OWlkZycjITJkwgLy+P4cOHA1BQUMCgQYO4+uqrufvuuyktLeX2229n/PjxjUfFx40bx8MPP8xPf/pTrrvuOubPn8/TTz/Niy++eLRfjlq59Tv3cf/cEv72/laCAEIh+PYpPZmYn0PvzknRjidJkiSpjTrqZX3z5s1ceeWV7Nq1i65du3LOOefw5ptv0rVrVwDuu+8+wuEwl112GTU1NRQWFvLoo482Pj4mJoYXXniBG2+8kby8PNq3b8/YsWP593//98aZfv368eKLLzJp0iQeeOABevXqxeOPP+411nXYtpYf4KH5q3j6nc00RA5evfAbgzOYPDqH7G4do5xOkiRJUlt31K+z3pJ4nfW2Z+feGh59ZQ1/WLKB2voIAOfldmXK6FyG9EqJcjpJkiRJrd3h9lCvPaU2oWJ/Hb9+dQ1PvL6e/bUNAJzZL41phbmc0TctyukkSZIkqSnLulq1fTX1PPH6On69aC2V1fUAnNQrhakFuYzI7kIoFIpyQkmSJEn6NMu6WqXqugb+uGQjj76yml37agHI7daRyQU5FAzqZkmXJEmS1KxZ1tWq1DVEeOadzTw0fxXbKqoB6NM5icmjc7jopB7EhC3pkiRJkpo/y7pahYZIwPPvb+W+uSVs2LUfgO4pifxkVDbfGdqLuJhwlBNKkiRJ0uGzrKtFC4KA2R+UcW9RMSVlewHo0iGem87L4nvDepMYFxPlhJIkSZJ05CzrapGCIGDRqp3MmFPM8s0VACQnxvLjcwdwzVl9aZ/gri1JkiSp5bLRqMV5e/1u7pldzFvrdgOQFB/DdWf340cj+5PSLi7K6SRJkiTp67Osq8VYsbmC6XOKWViyA4D42DBXD+/DjecNoEuHhCinkyRJkqSjx7KuZq+krIp755Tw8gelAMSGQ/zz6Zn8ZFQW3VPaRTmdJEmSJB19lnU1Wxt27eP+uat4btkWggBCIbjklJ5MzM+mT+f20Y4nSZIkSceMZV3NzraKAzw0fzVPv72J+kgAQOGJ3Zg8OpfcjI5RTidJkiRJx55lXc3Grr01PLpgDb9/cwO19REARuZ0ZWpBDif1So1uOEmSJEk6jizrirqKA3U8/upafvPaOvbXNgBwZt80phTkMKx/5yinkyRJkqTjz7KuY6YhEvDWut1sr6omvWMiZ/ZLIyYcaly/v7aeJ15fz68WrqGyuh6AIT1TmFqYy8jsLoRCoc/btCRJkiS1apZ1HRMvr9zGnc9/yLaK6sZl3VMSuePiQZyXm86TSzby6ILV7NxbC0B2egemFORQeGKGJV2SJElSm2dZ11H38spt3PiHdwn+YXlpRTXj/vAunZLi2LO/DoDeaUlMGp3NP53cs8lRd0mSJElqyyzrOqoaIgF3Pv/hp4o60Lhsz/46unVM4Jb8HP759F7ExYSPZ0RJkiRJavYs6zoqgiBg975aij4sa/LW989z9z+fxLk56cchmSRJkiS1PJb1Zu7LTtJ2POyrqae0spqyymq2V9Y0fn3wVkNpRTU7qmqobYgc9jbL/+dt8JIkSZKkT7OsN2NfdJK2Cwd3/9rbr2uIsL2q5mDprjhYvksra9heWf2JQl7D3pr6w95mcmJs45ndv0h6x8SvE12SJEmSWjXLejP1RSdpu/EP7/LY90/73MJ+6C3pZZU1jUfAS/+neJd94qj4rn21BJ/14fLP0D4+hm4piXTrmEhGSiLpyQlkJCfSrfGWQHrHRGLCIc75/+ZTWlH9mZ9bDwEZKQffISBJkiRJ+myW9WbocE7S9q/PrmR/TQPb99Z8rbekx4ZDdEv+7PKdkZxIevLBct4h4fB3lTsuHsSNf3iX0CfywsGifmi9Z36XJEmSpM9nWW+G3lq3+0tP0rZrXy2Tn3n/C2c6t48/WLaTEz5RwhPJSDl4FDwjJZG0pHjCR7k4Xzi4O499/7RPvYU/4yi+hV+SJEmSWjPLejO0verLz6YOkJ3egcE9U0hPTmh8e3q3/ynmXTsmkBAbc4yTfr4LB3dn9KCMqJ8cT5IkSZJaIst6M3S4J1/7928NJm9A52Oc5quLCYeadT5JkiRJaq7C0Q6gTzuzXxrdUxL5vGPQIQ6eFd6TtEmSJElS62RZb4ZiwiHuuHgQwKcKuydpkyRJkqTWz7LeTB06SVtGStO3xGekJH7hZdskSZIkSS2fn1lvxjxJmyRJkiS1TZb1Zs6TtEmSJElS2+Pb4CVJkiRJamYs65IkSZIkNTOWdUmSJEmSmhnLuiRJkiRJzYxlXZIkSZKkZsayLkmSJElSM2NZlyRJkiSpmbGsS5IkSZLUzFjWJUmSJElqZizrkiRJkiQ1M5Z1SZIkSZKaGcu6JEmSJEnNjGVdkiRJkqRmJjbaAaIpCAIAKisro5xEkiRJktQWHOqfh/ro52nTZb2qqgqAzMzMKCeRJEmSJLUlVVVVpKSkfO76UPBldb4Vi0QibN26lY4dOxIKhaIdR8dBZWUlmZmZbNq0ieTk5GjHkY4a9221Ru7Xaq3ct9UauV8fviAIqKqqokePHoTDn//J9DZ9ZD0cDtOrV69ox1AUJCcn+0NErZL7tloj92u1Vu7bao3crw/PFx1RP8QTzEmSJEmS1MxY1iVJkiRJamYs62pTEhISuOOOO0hISIh2FOmoct9Wa+R+rdbKfVutkfv10demTzAnSZIkSVJz5JF1SZIkSZKaGcu6JEmSJEnNjGVdkiRJkqRmxrIuSZIkSVIzY1mXJEmSJKmZsayr2Vm0aBEXX3wxPXr0IBQK8dxzzzVZHwQBv/jFL+jevTvt2rUjPz+fVatWNZnZvXs3V111FcnJyaSmpnL99dezd+/eJjPLly9nxIgRJCYmkpmZyd133/2pLM888wwDBw4kMTGRIUOG8Pe///2Is0gAd911F2eccQYdO3YkPT2dSy65hOLi4iYz1dXVjB8/ns6dO9OhQwcuu+wyysrKmsxs3LiRMWPGkJSURHp6OtOmTaO+vr7JzIIFCzjttNNISEggKyuLWbNmfSrPI488Qt++fUlMTGTYsGG89dZbR5xFeuyxxzjppJNITk4mOTmZvLw8Xnrppcb17tNqDX75y18SCoWYOHFi4zL3bbVE//Zv/0YoFGpyGzhwYON69+tmKJCamb///e/Bv/7rvwZ//etfAyB49tlnm6z/5S9/GaSkpATPPfdc8P777wf/9E//FPTr1y84cOBA48yFF14YnHzyycGbb74ZvPrqq0FWVlZw5ZVXNq6vqKgIunXrFlx11VXBypUrgz/96U9Bu3btgl/96leNM6+//noQExMT3H333cGHH34Y3H777UFcXFywYsWKI8oiBUEQFBYWBk888USwcuXKYNmyZcE3v/nNoHfv3sHevXsbZ8aNGxdkZmYG8+bNC955551g+PDhwVlnndW4vr6+Phg8eHCQn58fvPfee8Hf//73oEuXLsFtt93WOLN27dogKSkpmDx5cvDhhx8GDz30UBATExO8/PLLjTNPPfVUEB8fH/z2t78NPvjgg+BHP/pRkJqaGpSVlR12FikIguC///u/gxdffDEoKSkJiouLg3/5l38J4uLigpUrVwZB4D6tlu+tt94K+vbtG5x00knBLbfc0rjcfVst0R133BGceOKJwbZt2xpvO3bsaFzvft38WNbVrP1jWY9EIkFGRkZwzz33NC4rLy8PEhISgj/96U9BEATBhx9+GADB22+/3Tjz0ksvBaFQKNiyZUsQBEHw6KOPBp06dQpqamoaZ2699dYgNze38f53v/vdYMyYMU3yDBs2LPjxj3982Fmkz7N9+/YACBYuXBgEwcF9Jy4uLnjmmWcaZz766KMACBYvXhwEwcE/ZIXD4aC0tLRx5rHHHguSk5Mb9+Wf/vSnwYknntjkuS6//PKgsLCw8f6ZZ54ZjB8/vvF+Q0ND0KNHj+Cuu+467CzS5+nUqVPw+OOPu0+rxauqqgqys7ODoqKi4Nxzz20s6+7baqnuuOOO4OSTT/7Mde7XzZNvg1eLsm7dOkpLS8nPz29clpKSwrBhw1i8eDEAixcvJjU1ldNPP71xJj8/n3A4zJIlSxpnRo4cSXx8fONMYWEhxcXF7Nmzp3Hmk89zaObQ8xxOFunzVFRUAJCWlgbA0qVLqaura7I/DRw4kN69ezfZt4cMGUK3bt0aZwoLC6msrOSDDz5onPmi/ba2tpalS5c2mQmHw+Tn5zfOHE4W6R81NDTw1FNPsW/fPvLy8tyn1eKNHz+eMWPGfGr/c99WS7Zq1Sp69OhB//79ueqqq9i4cSPgft1cWdbVopSWlgI0+SFx6P6hdaWlpaSnpzdZHxsbS1paWpOZz9rGJ5/j82Y+uf7LskifJRKJMHHiRM4++2wGDx4MHNyf4uPjSU1NbTL7j/vcV91vKysrOXDgADt37qShoeFL9+0vyyIdsmLFCjp06EBCQgLjxo3j2WefZdCgQe7TatGeeuop3n33Xe66665PrXPfVks1bNgwZs2axcsvv8xjjz3GunXrGDFiBFVVVe7XzVRstANIUlszfvx4Vq5cyWuvvRbtKNLXlpuby7Jly6ioqOAvf/kLY8eOZeHChdGOJX1lmzZt4pZbbqGoqIjExMRox5GOmm984xuNX5900kkMGzaMPn368PTTT9OuXbsoJtPn8ci6WpSMjAyAT50NsqysrHFdRkYG27dvb7K+vr6e3bt3N5n5rG188jk+b+aT678si/SPbr75Zl544QVeeeUVevXq1bg8IyOD2tpaysvLm8z/4z73Vffb5ORk2rVrR5cuXYiJifnSffvLskiHxMfHk5WVxdChQ7nrrrs4+eSTeeCBB9yn1WItXbqU7du3c9pppxEbG0tsbCwLFy7kwQcfJDY2lm7durlvq1VITU0lJyeH1atX+zO7mbKsq0Xp168fGRkZzJs3r3FZZWUlS5YsIS8vD4C8vDzKy8tZunRp48z8+fOJRCIMGzascWbRokXU1dU1zhQVFZGbm0unTp0aZz75PIdmDj3P4WSRDgmCgJtvvplnn32W+fPn069fvybrhw4dSlxcXJP9qbi4mI0bNzbZt1esWNHkj1FFRUUkJyczaNCgxpkv2m/j4+MZOnRok5lIJMK8efMaZw4ni/R5IpEINTU17tNqsUaNGsWKFStYtmxZ4+3000/nqquuavzafVutwd69e1mzZg3du3f3Z3ZzFe0z3En/qKqqKnjvvfeC9957LwCCe++9N3jvvfeCDRs2BEFw8HJpqampwd/+9rdg+fLlwbe+9a3PvHTbqaeeGixZsiR47bXXguzs7CaXbisvLw+6desWXH311cHKlSuDp556KkhKSvrUpdtiY2OD6dOnBx999FFwxx13fOal274sixQEQXDjjTcGKSkpwYIFC5pcMmX//v2NM+PGjQt69+4dzJ8/P3jnnXeCvLy8IC8vr3H9oUumFBQUBMuWLQtefvnloGvXrp95yZRp06YFH330UfDII4985iVTEhISglmzZgUffvhhcMMNNwSpqalNzu76ZVmkIAiCn/3sZ8HChQuDdevWBcuXLw9+9rOfBaFQKJgzZ04QBO7Taj0+eTb4IHDfVss0ZcqUYMGCBcG6deuC119/PcjPzw+6dOkSbN++PQgC9+vmyLKuZueVV14JgE/dxo4dGwTBwUum/fznPw+6desWJCQkBKNGjQqKi4ubbGPXrl3BlVdeGXTo0CFITk4Orr322qCqqqrJzPvvvx+cc845QUJCQtCzZ8/gl7/85aeyPP3000FOTk4QHx8fnHjiicGLL77YZP3hZJGCIPjMfRoInnjiicaZAwcOBDfddFPQqVOnICkpKfj2t78dbNu2rcl21q9fH3zjG98I2rVrF3Tp0iWYMmVKUFdX12TmlVdeCU455ZQgPj4+6N+/f5PnOOShhx4KevfuHcTHxwdnnnlm8OabbzZZfzhZpOuuuy7o06dPEB8fH3Tt2jUYNWpUY1EPAvdptR7/WNbdt9USXX755UH37t2D+Pj4oGfPnsHll18erF69unG9+3XzEwqCIIjOMX1JkiRJkvRZ/My6JEmSJEnNjGVdkiRJkqRmxrIuSZIkSVIzY1mXJEmSJKmZsaxLkiRJktTMWNYlSZIkSWpmLOuSJEmSJDUzlnVJkiRJkpoZy7okSZIkSc2MZV2SJEmSpGbGsi5JkiRJUjPz/weEuxiDVUPFxAAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "2\n", + "# Escalar los datos entre 0 y 1scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_y = MinMaxScaler(feature_range=(0, 1))\n", + "train_X_scaled = scaler_X.fit_transform(train_X)\n", + "test_X_scaled = scaler_X.transform(test_X)\n", + "train_y_scaled = scaler_y.fit_transform(train_y.values.reshape(-1, 1))\n", + "test_y_scaled = scaler_y.transform(test_y.values.reshape(-1, 1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + }, + "id": "ji9qjt_SCrvY", + "outputId": "7610dff1-9cc5-4bba-92ea-a0b93fdf3a09" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mscaler_X\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mscaler_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mtrain_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mtest_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mtrain_y_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/_set_output.py\u001b[0m in \u001b[0;36mwrapped\u001b[0;34m(self, X, *args, **kwargs)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mdata_to_wrap\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_to_wrap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[0;31m# only wrap the first output for cross decomposition\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 876\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0my\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 877\u001b[0m \u001b[0;31m# fit method of arity 1 (unsupervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 878\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 879\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 880\u001b[0m \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 425\u001b[0m \u001b[0;31m# Reset internal state before fitting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 426\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 427\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 428\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mpartial_fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 464\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 465\u001b[0m \u001b[0mfirst_pass\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"n_samples_seen_\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 466\u001b[0;31m X = self._validate_data(\n\u001b[0m\u001b[1;32m 467\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[0mreset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfirst_pass\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36m_validate_data\u001b[0;34m(self, X, y, reset, validate_separately, **check_params)\u001b[0m\n\u001b[1;32m 563\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Validation should be done on X, y or both.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 564\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 565\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"X\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mcheck_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 566\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 567\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_array\u001b[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator, input_name)\u001b[0m\n\u001b[1;32m 776\u001b[0m )\n\u001b[1;32m 777\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtype_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdtype_iter\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 778\u001b[0;31m \u001b[0mdtype_orig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 779\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 780\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"iloc\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"dtype\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numpy/core/overrides.py\u001b[0m in \u001b[0;36mresult_type\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: at least one array or dtype is required" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Definir el modelo LSTM\n", + "model_lstm = Sequential()\n", + "model_lstm.add(LSTM(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "model_lstm.add(Dense(1))\n", + "model_lstm.compile(optimizer='adam', loss='mse')\n", + "\n", + "#/ Definir el modelo GRU\n", + "#model_gru = Sequential()\n", + "#model_gru.add(GRU(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "#model_gru.add(Dense(1))\n", + "#model_gru.compile(optimizer='adam', loss='mse')\n", + "#" + ], + "metadata": { + "id": "CaTJQmj33IvW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model_lstm.fit(train_X, train_y, epochs=10, verbose=0)\n", + "#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\n", + "\n", + "# Evaluar los modelos\n", + "mse_lstm = model_lstm.evaluate(test_X, test_y)\n", + "#mse_gru = model_gru.evaluate(test_X, test_y)\n", + "\n", + "print(f'Test MSE LSTM: {mse_lstm}')\n", + "#print(f'Test MSE GRU: {mse_gru}')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 245 + }, + "id": "3wBcalVC41ED", + "outputId": "671dcbb9-7d07-4da9-b9e3-1c52a5f16ef9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;31m#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Evaluar los modelos\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mmse_lstm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'train_X' is not defined" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "hasta aca\n" + ], + "metadata": { + "id": "keXYd4TrurKV" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Convertir los datos a un formato largo usando melt de pandas\n", + "new_data = pd.melt(data, id_vars=['Country', 'Latitude', 'Longitude', 'Features', 'Region'], var_name='Year', value_name='Value')\n", + "\n", + "# Convertir las columnas al tipo de datos correcto\n", + "new_data['Year'] = new_data['Year'].astype(int)\n", + "new_data['Latitude'] = pd.to_numeric(new_data['Latitude'])\n", + "new_data['Longitude'] = pd.to_numeric(new_data['Longitude'])" + ], + "metadata": { + "id": "Xd6En43Apl_Z", + "outputId": "ff66b8ad-695e-4976-8859-ea466bc350cc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\"", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Convertir las columnas al tipo de datos correcto\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/tools/numeric.py\u001b[0m in \u001b[0;36mto_numeric\u001b[0;34m(arg, errors, downcast)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[0mcoerce_numeric\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0merrors\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"ignore\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"raise\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 184\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 185\u001b[0;31m values, _ = lib.maybe_convert_numeric(\n\u001b[0m\u001b[1;32m 186\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 187\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\" at position 161" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Reordenar los niveles de 'Features' en la secuencia deseada\n", + "feature_order = [\"imports\", \"exports\", \"net imports\", \"installed capacity\", \"net generation\", \"net consumption\", \"distribution losses\"]\n", + "new_data['Features'] = pd.Categorical(new_data['Features'], categories=feature_order, ordered=True)\n", + "\n", + "custom_palette = [\"red\", \"blue\", \"green\",\"purple\", \"#FF7F00\", \"cyan\", \"brown\"]\n", + "\n", + "# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\n", + "region_features = new_data.groupby(['Year', 'Region', 'Features']).agg(Total_Value=('Value', 'sum')).reset_index()\n", + "\n", + "# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "# Crear el gráfico de líneas con la paleta de colores personalizada\n", + "sns.lineplot(data=region_features, x='Year', y='Total_Value', hue='Region')\n", + "plt.title('Total Values by Region Over Time')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('Total')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 390 + }, + "id": "cYzGOiNeVfY7", + "outputId": "d3044941-773c-479f-a4bf-7e86be3e6785" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mregion_features\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Region'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0magg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTotal_Value\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Value'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sum'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36mgroupby\u001b[0;34m(self, by, axis, level, as_index, sort, group_keys, squeeze, observed, dropna)\u001b[0m\n\u001b[1;32m 8400\u001b[0m \u001b[0maxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_axis_number\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8401\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 8402\u001b[0;31m return DataFrameGroupBy(\n\u001b[0m\u001b[1;32m 8403\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8404\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/groupby.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, obj, keys, axis, level, grouper, exclusions, selection, as_index, sort, group_keys, squeeze, observed, mutated, dropna)\u001b[0m\n\u001b[1;32m 963\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrouper\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mget_grouper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 964\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 965\u001b[0;31m grouper, exclusions, obj = get_grouper(\n\u001b[0m\u001b[1;32m 966\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 967\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/grouper.py\u001b[0m in \u001b[0;36mget_grouper\u001b[0;34m(obj, key, axis, level, sort, observed, mutated, validate, dropna)\u001b[0m\n\u001b[1;32m 886\u001b[0m \u001b[0min_axis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 888\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 889\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGrouper\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkey\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 890\u001b[0m \u001b[0;31m# Add key to exclusions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "custom_palette = [\"#E41A1C\", \"#377EB8\", \"#4DAF4A\", \"#984EA3\", \"#FF7F00\", \"#FFFF33\", \"#A65628\"]\n", + "\n", + "# Filter the data for the past five years and 'exports'\n", + "export_data = new_data[(new_data['Features'] == \"exports\") & (new_data['Year'] >= (new_data['Year'].max() - 4))]\n", + "\n", + "# Group by 'Country' and calculate the total export value\n", + "top_exporting_countries = export_data.groupby('Country')['Value'].sum().reset_index().sort_values(by='Value', ascending=False).head(10)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(x='Value', y='Country', data=top_exporting_countries, palette=custom_palette)\n", + "print(top_exporting_countries)\n", + "\n", + "plt.xlabel('Total Exports')\n", + "plt.ylabel('Country')\n", + "plt.title('Exports - Last 5 Years - Top Ten Countries')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 512 + }, + "id": "pEGfENwGVhHK", + "outputId": "2dc0d837-10ef-4939-a46a-d36246f692a7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3801\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3802\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Filter the data for the past five years and 'exports'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mexport_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"exports\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# Group by 'Country' and calculate the total export value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3805\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3807\u001b[0;31m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3808\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3809\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3802\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3804\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3805\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;31m# If we have a listlike key, _check_indexing_error will raise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "RQfTp3HSXLqQ" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/proyectoIAPrediccion1CNNPrediccion0.2.ipynb b/proyectoIAPrediccion1CNNPrediccion0.2.ipynb new file mode 100644 index 0000000..70376d2 --- /dev/null +++ b/proyectoIAPrediccion1CNNPrediccion0.2.ipynb @@ -0,0 +1,346 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from keras.models import Sequential\n", + "from keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout\n", + "from keras.regularizers import l1_l2\n", + "from keras.callbacks import EarlyStopping" + ], + "metadata": { + "id": "H7kZjC_GUZZd" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "9_FId2wvQAgd", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 442 + }, + "outputId": "d5726d71-fd4c-43d0-90f8-d5a704c92b11" + }, + "outputs": [ + { + "output_type": "error", + "ename": "FileNotFoundError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Cargar el archivo de estadísticas de electricidad\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mfile_path\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Global_Electricity_Statistics.csv'\u001b[0m \u001b[0;31m# Asegúrate de cambiar esto a tu ruta de archivo\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0melectricity_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_csv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/util/_decorators.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 210\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnew_arg_name\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_arg_value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 211\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 212\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 213\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mF\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/util/_decorators.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 329\u001b[0m \u001b[0mstacklevel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfind_stack_level\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 330\u001b[0m )\n\u001b[0;32m--> 331\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 332\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 333\u001b[0m \u001b[0;31m# error: \"Callable[[VarArg(Any), KwArg(Any)], Any]\" has no\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, error_bad_lines, warn_bad_lines, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options)\u001b[0m\n\u001b[1;32m 948\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwds_defaults\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 949\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 950\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_read\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 951\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 952\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 603\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 604\u001b[0m \u001b[0;31m# Create the parser.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 605\u001b[0;31m \u001b[0mparser\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTextFileReader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 606\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 607\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mchunksize\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0miterator\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1440\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1441\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandles\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mIOHandles\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1442\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_engine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mengine\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1443\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1444\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36m_make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1733\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m\"b\"\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1734\u001b[0m \u001b[0mmode\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m\"b\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1735\u001b[0;31m self.handles = get_handle(\n\u001b[0m\u001b[1;32m 1736\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1737\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/io/common.py\u001b[0m in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 854\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mioargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencoding\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m\"b\"\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mioargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 855\u001b[0m \u001b[0;31m# Encoding\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 856\u001b[0;31m handle = open(\n\u001b[0m\u001b[1;32m 857\u001b[0m \u001b[0mhandle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 858\u001b[0m \u001b[0mioargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'Global_Electricity_Statistics.csv'" + ] + } + ], + "source": [ + "# Cargar el archivo de estadísticas de electricidad\n", + "file_path = 'global_electricity_statistics_by_region.csv' # Asegúrate de cambiar esto a tu ruta de archivo\n", + "electricity_data = pd.read_csv(file_path)\n" + ] + }, + { + "cell_type": "code", + "source": [ + "# Convertir todos los valores a números, tratando los valores no numéricos como nulos\n", + "years_columns = electricity_data.columns[3:] # Columnas de años\n", + "electricity_data[years_columns] = electricity_data[years_columns].apply(pd.to_numeric, errors='coerce')\n" + ], + "metadata": { + "id": "dM7ktPDSOl8N" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Reemplazar valores 0 con NaN utilizando una máscara booleana\n", + "for column in years_columns:\n", + " mask = electricity_data[column] == 0\n", + " electricity_data.loc[mask, column] = pd.NA\n", + "\n", + "# Calcular la media de cada fila excluyendo NaN\n", + "row_means = electricity_data[years_columns].mean(axis=1)\n", + "\n", + "# Usar `fillna` en cada columna para reemplazar NaN con la media correspondiente de cada fila\n", + "for year in years_columns:\n", + " electricity_data[year] = electricity_data[year].fillna(row_means)\n", + "\n", + "# Verificar si hay valores nulos después de la normalización\n", + "null_values_after_normalization = electricity_data[years_columns].isna().sum().sum()\n" + ], + "metadata": { + "id": "374vEgbTOw3P" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Asegúrate de que los datos están agrupados por región y año como se hizo anteriormente\n", + "grouped_data = electricity_data.groupby('Region')[years_columns].sum().transpose()\n", + "\n", + "# Crear un gráfico de líneas\n", + "plt.figure(figsize=(15, 8)) # Ajusta el tamaño del gráfico según tus necesidades\n", + "\n", + "for region in grouped_data.columns:\n", + " plt.plot(grouped_data.index, grouped_data[region], label=region)\n", + "\n", + "# Agregar títulos y etiquetas\n", + "plt.title('Consumo de Electricidad por Región a lo Largo del Tiempo')\n", + "plt.xlabel('Año')\n", + "plt.ylabel('Consumo de Electricidad (Unidades)')\n", + "plt.xticks(rotation=45) # Rota las etiquetas del eje X para mejor legibilidad\n", + "plt.legend() # Añade una leyenda para identificar cada línea/región\n", + "\n", + "# Mostrar el gráfico\n", + "plt.show()" + ], + "metadata": { + "id": "lWY6qwmkQ2PL" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Normalizar los datos\n", + "scaler = MinMaxScaler()\n", + "scaled_data = scaler.fit_transform(grouped_data)\n", + "\n", + "# Reformatear los datos para la CNN\n", + "# Suponiendo que cada columna (región) es un 'canal' y cada fila es un punto de tiempo\n", + "X = scaled_data.reshape(scaled_data.shape[0], 1, scaled_data.shape[1])\n", + "\n", + "# Dividir en entrenamiento y prueba (usando los últimos datos para prueba)\n", + "train_size = int(X.shape[0] * 0.8)\n", + "X_train, X_test = X[:train_size, :, :], X[train_size:, :, :]\n", + "\n", + "# Generar Y (etiquetas) para los conjuntos de entrenamiento y prueba\n", + "Y_train, Y_test = X_train[:, :, :], X_test[:, :, :]" + ], + "metadata": { + "id": "9MZcbtw9t95l" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Asegúrate de que la forma de X_train sea correcta\n", + "# X_train debería tener una forma (num_samples, num_steps, num_features)\n", + "print(\"Forma de X_train:\", X_train.shape)\n" + ], + "metadata": { + "id": "jR-a5gHyQPMt" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Diseño de la CNN con ajustes\n", + "model = Sequential()\n", + "# Añadir regularización a la capa convolucional\n", + "model.add(Conv1D(filters=64, kernel_size=1, activation='relu', input_shape=(X_train.shape[1], X_train.shape[2]), kernel_regularizer=l1_l2(l1=0.01, l2=0.01)))\n", + "model.add(MaxPooling1D(pool_size=1))\n", + "model.add(Flatten())\n", + "# Añadir Dropout para reducir el sobreajuste\n", + "model.add(Dropout(0.5))\n", + "# Capa densa con regularización\n", + "model.add(Dense(50, activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01)))\n", + "model.add(Dense(X_train.shape[2]))\n", + "\n", + "# Compilar el modelo con un optimizador y tasa de aprendizaje ajustados\n", + "model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mse'])\n", + "\n", + "# Resumen del modelo para verificar la arquitectura\n", + "model.summary()" + ], + "metadata": { + "id": "1eAT7FatQ3_W" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "early_stopping = EarlyStopping(monitor='val_loss', patience=100, mode='min')\n", + "history = model.fit(X_train, Y_train, epochs=500, validation_data=(X_test, Y_test), callbacks=[early_stopping], verbose=10)" + ], + "metadata": { + "id": "xros5lXUS3eR" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Visualizar el entrenamiento\n", + "plt.plot(history.history['loss'], label='train')\n", + "plt.title('Model Loss per Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "id": "uQuljCCiQnBd" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "plt.plot(history.history['val_loss'], label='test')\n", + "plt.title('Model Loss per Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "id": "O5NpleLGSF4Q" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(electricity_data[\"Region\"])" + ], + "metadata": { + "id": "kT7euZcTW482" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(electricity_data.columns) # Si 2020 es una columna\n", + "print(electricity_data.index) # Si 2020 es un índice\n" + ], + "metadata": { + "id": "oDKGm3BTajlP" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Entrada del usuario o definición de la región y el año\n", + "region_seleccionada = 'Africa' # Reemplaza con la entrada del usuario o una variable\n", + "anio_seleccionado = 2020 # Reemplaza con la entrada del usuario o una variable\n", + "\n", + "datos_para_prediccion = electricity_data.loc[region_seleccionada, anio_seleccionado]\n", + "\n", + "datos_para_prediccion_escalados = scaler.transform([datos_para_prediccion])\n", + "datos_para_prediccion_reshaped = datos_para_prediccion_escalados.reshape(1, 1, -1)\n", + "\n", + "# Realizar la predicción\n", + "prediccion = model.predict(datos_para_prediccion_reshaped)\n", + "\n", + "# Mostrar la predicción\n", + "print(f\"Predicción del consumo de electricidad para {region_seleccionada} en el año {anio_seleccionado}: {prediccion}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 570 + }, + "id": "EOl4zF1VTp-c", + "outputId": "7284c06d-770b-439c-bc62-cbea103533d7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3801\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3802\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 2020", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0manio_seleccionado\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2020\u001b[0m \u001b[0;31m# Reemplaza con la entrada del usuario o una variable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mdatos_para_prediccion\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0melectricity_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mregion_seleccionada\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0manio_seleccionado\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mdatos_para_prediccion_escalados\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdatos_para_prediccion\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 1064\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_if_callable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1065\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_is_scalar_access\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1066\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtakeable\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_takeable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1067\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_tuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1068\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m_get_value\u001b[0;34m(self, index, col, takeable)\u001b[0m\n\u001b[1;32m 3915\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_values\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3916\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3917\u001b[0;31m \u001b[0mseries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_item_cache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcol\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3918\u001b[0m \u001b[0mengine\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3919\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m_get_item_cache\u001b[0;34m(self, item)\u001b[0m\n\u001b[1;32m 4280\u001b[0m \u001b[0;31m# pending resolution of GH#33047\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4281\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4282\u001b[0;31m \u001b[0mloc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4283\u001b[0m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_ixs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4284\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3802\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3804\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3805\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;31m# If we have a listlike key, _check_indexing_error will raise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 2020" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "uKxrVjY4U9qL" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/proyectoIAPrediccion1GRU.ipynb b/proyectoIAPrediccion1GRU.ipynb new file mode 100644 index 0000000..c55f0ab --- /dev/null +++ b/proyectoIAPrediccion1GRU.ipynb @@ -0,0 +1,2142 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyNp43MburvFerSKWrM2U2ox", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as mcolors\n", + "import matplotlib.cm as cm\n", + "import seaborn as sns\n", + "import plotly.express as px\n", + "from wordcloud import WordCloud\n", + "import geopandas as gpd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from keras.models import Sequential\n", + "from keras.layers import LSTM, GRU, Conv1D, MaxPooling1D, Flatten, Dense\n", + "from keras.losses import MeanSquaredError\n", + "from keras.regularizers import l2\n", + "\n" + ], + "metadata": { + "id": "H7kZjC_GUZZd" + }, + "execution_count": 77, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "id": "9_FId2wvQAgd" + }, + "outputs": [], + "source": [ + "# Leer los datos\n", + "GES_Data = \"global_electricity_statistics_cleaned.csv\"\n", + "df = pd.read_csv(GES_Data)" + ] + }, + { + "cell_type": "code", + "source": [ + "# Ver los primeros datos\n", + "print(df.head())\n", + "df[\"Features\"].value_counts()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lWY6qwmkQ2PL", + "outputId": "e89148ab-3b26-4467-9a79-ac3d32f733d6" + }, + "execution_count": 79, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Country Features Region 1980 1981 1982 1983 \\\n", + "0 Algeria net generation Africa 6.683 7.65 8.824 9.615 \n", + "1 Angola net generation Africa 0.905 0.906 0.995 1.028 \n", + "2 Benin net generation Africa 0.005 0.005 0.005 0.005 \n", + "3 Botswana net generation Africa 0.443 0.502 0.489 0.434 \n", + "4 Burkina Faso net generation Africa 0.098 0.108 0.115 0.117 \n", + "\n", + " 1984 1985 1986 ... 2012 2013 2014 2015 \\\n", + "0 10.537 11.569 12.214 ... 53.9845 56.3134 60.39972 64.68244 \n", + "1 1.028 1.028 1.088 ... 6.03408 7.97606 9.21666 9.30914 \n", + "2 0.005 0.005 0.005 ... 0.04612 0.08848 0.22666 0.31056 \n", + "3 0.445 0.456 0.538 ... 0.33 0.86868 2.17628 2.79104 \n", + "4 0.113 0.115 0.122 ... 0.86834 0.98268 1.11808 1.43986 \n", + "\n", + " 2016 2017 2018 2019 2020 2021 \n", + "0 66.75504 71.49546 72.10903 76.685 72.73591277 77.53072719 \n", + "1 10.203511 10.67604 12.83194 15.4 16.6 16.429392 \n", + "2 0.26004 0.3115 0.19028 0.2017 0.22608 0.24109728 \n", + "3 2.52984 2.8438 2.97076 3.0469 2.05144 2.18234816 \n", + "4 1.5509 1.64602 1.6464 1.72552 1.647133174 1.761209666 \n", + "\n", + "[5 rows x 45 columns]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "net generation 230\n", + "net consumption 230\n", + "imports 230\n", + "exports 230\n", + "net imports 230\n", + "installed capacity 230\n", + "distribution losses 230\n", + "Name: Features, dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 79 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Convertir las columnas de los años a numéricas\n", + "cols = [str(year) for year in range(1980, 2022)]\n", + "df[cols] = df[cols].apply(pd.to_numeric, errors='coerce')\n", + "\n", + "# Calcular el promedio de cada fila (ignorando los valores NaN)\n", + "df['avg'] = df.loc[:, '1980':'2021'].mean(axis=1)\n", + "\n", + "# Rellenar los valores NaN con el promedio de la fila correspondiente\n", + "for col in cols:\n", + " df[col].fillna(df['avg'], inplace=True)\n", + "\n", + "# Eliminar la columna 'avg' ya que ya no es necesaria\n", + "df.drop('avg', axis=1, inplace=True)\n", + "\n", + "# Agregar la columna 'Total' que es la suma de las columnas desde 1980 hasta 2021\n", + "df['Total'] = df.loc[:, '1980':'2021'].sum(axis=1)\n", + "\n", + "# Agrupar por 'Region' y 'Features', y obtener la suma\n", + "df_grouped = df.groupby(['Region', 'Features']).sum(numeric_only=True)\n" + ], + "metadata": { + "id": "9MZcbtw9t95l" + }, + "execution_count": 84, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "base de datos lista con regiones y caracteristicas 1980 al 2021 abajo listo falta red neuronal y entrenamiento\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "_28HoIcVTX5H" + } + }, + { + "cell_type": "code", + "source": [ + "print(df_grouped)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6wZ4FIMSDhZH", + "outputId": "77273682-c22c-41a9-fae1-a801427bd5e7" + }, + "execution_count": 81, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " 1980 1981 \\\n", + "Region Features \n", + "Africa distribution losses 1.874121e+01 20.443093 \n", + " exports 3.935375e+00 4.327375 \n", + " imports 5.659906e+00 6.051906 \n", + " installed capacity 4.814117e+01 52.983167 \n", + " net consumption 1.737664e+02 183.373190 \n", + " net generation 1.907831e+02 202.091751 \n", + " net imports 1.724531e+00 1.724531 \n", + "Asia & Oceania distribution losses 1.031399e+02 110.245063 \n", + " exports 1.190000e+00 1.158000 \n", + " imports 1.507000e+00 1.585000 \n", + " installed capacity 3.299673e+02 350.290346 \n", + " net consumption 1.162988e+03 1192.215726 \n", + " net generation 1.265811e+03 1302.033789 \n", + " net imports 3.170000e-01 0.427000 \n", + "Central & South America distribution losses 3.859152e+01 36.077525 \n", + " exports 4.380000e-01 0.590000 \n", + " imports 4.380000e-01 0.449000 \n", + " installed capacity 8.227979e+01 89.194786 \n", + " net consumption 2.705502e+02 280.515562 \n", + " net generation 3.091417e+02 316.734087 \n", + " net imports 6.938894e-18 -0.141000 \n", + "Eurasia distribution losses 2.617115e+02 262.611506 \n", + " exports 7.943247e+01 81.441472 \n", + " imports 4.476119e+01 44.761188 \n", + " installed capacity 6.222894e+02 632.202353 \n", + " net consumption 2.343170e+03 2298.454189 \n", + " net generation 2.639553e+03 2597.745980 \n", + " net imports -3.467128e+01 -36.680284 \n", + "Europe distribution losses 2.120365e+02 209.191182 \n", + " exports 2.115657e+02 220.309746 \n", + " imports 2.116504e+02 222.262370 \n", + " installed capacity 7.708206e+02 786.288617 \n", + " net consumption 2.740265e+03 2745.516068 \n", + " net generation 2.952217e+03 2952.754626 \n", + " net imports 8.462388e-02 1.952624 \n", + "Middle East distribution losses 7.515476e+00 11.216626 \n", + " exports 2.320000e-01 0.227000 \n", + " imports 4.111621e+00 4.106621 \n", + " installed capacity 3.230383e+01 38.292828 \n", + " net consumption 8.818376e+01 95.959605 \n", + " net generation 9.181961e+01 103.296610 \n", + " net imports 3.879621e+00 3.879621 \n", + "North America distribution losses 2.558195e+02 221.393494 \n", + " exports 3.466465e+01 39.482123 \n", + " imports 3.003898e+01 39.913572 \n", + " installed capacity 6.737250e+02 698.724000 \n", + " net consumption 2.461083e+03 2531.029293 \n", + " net generation 2.721528e+03 2751.991338 \n", + " net imports -4.625664e+00 0.431449 \n", + "\n", + " 1982 1983 \\\n", + "Region Features \n", + "Africa distribution losses 20.504713 22.792113 \n", + " exports 4.989375 4.251375 \n", + " imports 6.722906 6.253906 \n", + " installed capacity 53.899167 56.308967 \n", + " net consumption 189.994270 196.583670 \n", + " net generation 208.765451 217.373251 \n", + " net imports 1.733531 2.002531 \n", + "Asia & Oceania distribution losses 112.874513 121.149903 \n", + " exports 1.179000 1.265000 \n", + " imports 2.009000 2.005000 \n", + " installed capacity 368.918346 392.552346 \n", + " net consumption 1246.608115 1325.026719 \n", + " net generation 1358.652628 1445.436622 \n", + " net imports 0.830000 0.740000 \n", + "Central & South America distribution losses 42.593765 45.658395 \n", + " exports 0.475000 4.261000 \n", + " imports 0.601000 4.033000 \n", + " installed capacity 94.589786 100.067786 \n", + " net consumption 293.158242 310.713632 \n", + " net generation 335.626007 356.600027 \n", + " net imports 0.126000 -0.228000 \n", + "Eurasia distribution losses 267.411506 270.111506 \n", + " exports 82.052472 83.838472 \n", + " imports 44.761188 44.761188 \n", + " installed capacity 640.328353 649.579353 \n", + " net consumption 2408.629042 2452.972540 \n", + " net generation 2713.331833 2762.161331 \n", + " net imports -37.291284 -39.077284 \n", + "Europe distribution losses 210.397242 220.819682 \n", + " exports 216.397746 239.093746 \n", + " imports 218.558370 243.130370 \n", + " installed capacity 804.458617 817.115617 \n", + " net consumption 2757.528008 2819.162568 \n", + " net generation 2965.764626 3035.945626 \n", + " net imports 2.160624 4.036624 \n", + "Middle East distribution losses 12.716366 12.381506 \n", + " exports 0.330000 0.291000 \n", + " imports 4.209621 4.170621 \n", + " installed capacity 43.108828 48.766828 \n", + " net consumption 114.088865 128.651725 \n", + " net generation 122.925610 137.153610 \n", + " net imports 3.879621 3.879621 \n", + "North America distribution losses 227.643996 237.414793 \n", + " exports 40.319463 42.314293 \n", + " imports 40.319634 42.314038 \n", + " installed capacity 717.576000 728.127000 \n", + " net consumption 2476.041662 2555.949638 \n", + " net generation 2703.685487 2793.364686 \n", + " net imports 0.000171 -0.000255 \n", + "\n", + " 1984 1985 \\\n", + "Region Features \n", + "Africa distribution losses 24.310513 29.939433 \n", + " exports 4.594375 4.237375 \n", + " imports 6.369906 5.961906 \n", + " installed capacity 60.707967 63.234967 \n", + " net consumption 214.139970 225.634750 \n", + " net generation 236.674951 253.849651 \n", + " net imports 1.775531 1.724531 \n", + "Asia & Oceania distribution losses 126.509673 148.113229 \n", + " exports 1.696000 1.903000 \n", + " imports 2.134000 2.228000 \n", + " installed capacity 416.259346 440.239786 \n", + " net consumption 1422.219174 1498.540497 \n", + " net generation 1548.290847 1646.328726 \n", + " net imports 0.438000 0.325000 \n", + "Central & South America distribution losses 46.117535 50.984685 \n", + " exports 3.760000 5.323000 \n", + " imports 3.665000 2.648000 \n", + " installed capacity 106.934786 113.188786 \n", + " net consumption 337.728692 350.544262 \n", + " net generation 383.941227 404.203947 \n", + " net imports -0.095000 -2.675000 \n", + "Eurasia distribution losses 280.911506 288.511506 \n", + " exports 84.734472 91.332472 \n", + " imports 44.761188 46.361188 \n", + " installed capacity 659.918353 669.045353 \n", + " net consumption 2516.762419 2557.075511 \n", + " net generation 2837.647210 2890.558302 \n", + " net imports -39.973284 -44.971284 \n", + "Europe distribution losses 227.212242 239.311152 \n", + " exports 244.937746 246.803746 \n", + " imports 250.172370 257.239370 \n", + " installed capacity 842.635617 862.814617 \n", + " net consumption 2923.534008 3014.283098 \n", + " net generation 3145.511626 3243.158626 \n", + " net imports 5.234624 10.435624 \n", + "Middle East distribution losses 12.534696 14.515696 \n", + " exports 0.199000 0.328000 \n", + " imports 4.078621 4.207621 \n", + " installed capacity 53.286828 54.877828 \n", + " net consumption 143.957535 153.760535 \n", + " net generation 152.612610 164.396610 \n", + " net imports 3.879621 3.879621 \n", + "North America distribution losses 213.703069 235.735172 \n", + " exports 43.476293 47.519917 \n", + " imports 43.476432 47.458180 \n", + " installed capacity 748.786000 770.521000 \n", + " net consumption 2720.030437 2778.895211 \n", + " net generation 2933.733367 3014.692120 \n", + " net imports 0.000139 -0.061737 \n", + "\n", + " 1986 1987 \\\n", + "Region Features \n", + "Africa distribution losses 23.062873 26.468153 \n", + " exports 4.171375 2.530375 \n", + " imports 6.010906 4.454906 \n", + " installed capacity 69.761967 71.632967 \n", + " net consumption 245.635010 254.337430 \n", + " net generation 266.858351 278.881051 \n", + " net imports 1.839531 1.924531 \n", + "Asia & Oceania distribution losses 153.614063 168.974833 \n", + " exports 2.265198 2.838005 \n", + " imports 2.184701 2.737251 \n", + " installed capacity 462.890166 486.629886 \n", + " net consumption 1583.920647 1715.996800 \n", + " net generation 1737.615207 1885.072388 \n", + " net imports -0.080498 -0.100755 \n", + "Central & South America distribution losses 59.351220 65.950150 \n", + " exports 13.315000 18.816000 \n", + " imports 13.188000 18.337600 \n", + " installed capacity 117.481000 122.055000 \n", + " net consumption 375.881060 385.142790 \n", + " net generation 435.359280 451.571340 \n", + " net imports -0.127000 -0.478400 \n", + "Eurasia distribution losses 292.111506 297.411506 \n", + " exports 91.067472 95.700472 \n", + " imports 46.061188 45.661188 \n", + " installed capacity 675.670353 679.240353 \n", + " net consumption 2518.068596 2569.916228 \n", + " net generation 2855.186387 2917.367019 \n", + " net imports -45.006284 -50.039284 \n", + "Europe distribution losses 236.588012 243.415292 \n", + " exports 241.788746 255.341746 \n", + " imports 252.566370 271.346370 \n", + " installed capacity 878.766617 898.170617 \n", + " net consumption 3073.428238 3145.392958 \n", + " net generation 3299.238626 3372.803626 \n", + " net imports 10.777624 16.004624 \n", + "Middle East distribution losses 12.710696 16.239696 \n", + " exports 0.573000 0.478000 \n", + " imports 4.252621 4.191621 \n", + " installed capacity 58.097828 62.736828 \n", + " net consumption 163.961535 169.719535 \n", + " net generation 172.992610 182.245610 \n", + " net imports 3.679621 3.713621 \n", + "North America distribution losses 201.979128 210.630140 \n", + " exports 44.521565 54.824235 \n", + " imports 44.511861 54.829032 \n", + " installed capacity 783.141000 796.349000 \n", + " net consumption 2843.497120 2954.184324 \n", + " net generation 3045.485952 3164.809667 \n", + " net imports -0.009704 0.004797 \n", + "\n", + " 1988 1989 ... \\\n", + "Region Features ... \n", + "Africa distribution losses 27.225493 28.415993 ... \n", + " exports 2.427375 2.709375 ... \n", + " imports 4.419906 4.531906 ... \n", + " installed capacity 75.977967 79.771567 ... \n", + " net consumption 262.564790 271.933940 ... \n", + " net generation 287.797751 298.527401 ... \n", + " net imports 1.992531 1.822531 ... \n", + "Asia & Oceania distribution losses 178.805683 200.790531 ... \n", + " exports 3.310800 3.860101 ... \n", + " imports 3.174608 3.324543 ... \n", + " installed capacity 513.284356 536.453276 ... \n", + " net consumption 1856.190046 1977.313215 ... \n", + " net generation 2035.131922 2178.639305 ... \n", + " net imports -0.136193 -0.535558 ... \n", + "Central & South America distribution losses 67.784620 72.544900 ... \n", + " exports 19.189000 21.934000 ... \n", + " imports 19.033500 23.353000 ... \n", + " installed capacity 127.767000 130.554000 ... \n", + " net consumption 405.170040 413.088700 ... \n", + " net generation 473.110160 484.214600 ... \n", + " net imports -0.155500 1.419000 ... \n", + "Eurasia distribution losses 294.711506 296.411506 ... \n", + " exports 99.212472 98.535472 ... \n", + " imports 45.461188 45.461188 ... \n", + " installed capacity 692.645353 695.674353 ... \n", + " net consumption 2607.296149 2638.989586 ... \n", + " net generation 2955.758940 2988.475377 ... \n", + " net imports -53.751284 -53.074284 ... \n", + "Europe distribution losses 241.951762 243.408832 ... \n", + " exports 272.139746 293.217746 ... \n", + " imports 291.926370 312.685370 ... \n", + " installed capacity 908.236617 916.832617 ... \n", + " net consumption 3199.221488 3253.479218 ... \n", + " net generation 3421.386626 3477.420426 ... \n", + " net imports 19.786624 19.467624 ... \n", + "Middle East distribution losses 19.424696 19.650696 ... \n", + " exports 0.375000 0.380000 ... \n", + " imports 4.234621 4.259621 ... \n", + " installed capacity 69.399828 72.768828 ... \n", + " net consumption 189.148535 200.692535 ... \n", + " net generation 204.713610 216.463610 ... \n", + " net imports 3.859621 3.879621 ... \n", + "North America distribution losses 213.193537 278.523167 ... \n", + " exports 42.929646 39.016589 ... \n", + " imports 42.936199 39.084799 ... \n", + " installed capacity 798.026000 834.564000 ... \n", + " net consumption 3095.903194 3292.470057 ... \n", + " net generation 3309.090178 3570.925014 ... \n", + " net imports 0.006553 0.068210 ... \n", + "\n", + " 2012 2013 \\\n", + "Region Features \n", + "Africa distribution losses 90.741794 100.652074 \n", + " exports 31.560100 29.270320 \n", + " imports 39.407200 38.460900 \n", + " installed capacity 157.783510 166.204887 \n", + " net consumption 611.512095 620.559458 \n", + " net generation 695.766565 713.380728 \n", + " net imports 7.847100 9.190580 \n", + "Asia & Oceania distribution losses 678.990130 718.717462 \n", + " exports 38.076848 43.201222 \n", + " imports 48.086716 53.728922 \n", + " installed capacity 2169.864984 2330.909732 \n", + " net consumption 8227.563211 8719.145784 \n", + " net generation 8896.543473 9427.335547 \n", + " net imports 10.009868 10.527699 \n", + "Central & South America distribution losses 178.592105 183.188955 \n", + " exports 50.448000 50.482230 \n", + " imports 51.803500 51.705970 \n", + " installed capacity 296.354729 317.115300 \n", + " net consumption 1006.331172 1046.180499 \n", + " net generation 1185.825005 1230.402943 \n", + " net imports 1.355500 1.223740 \n", + "Eurasia distribution losses 290.124833 293.506833 \n", + " exports 81.157750 76.856750 \n", + " imports 28.093500 26.833500 \n", + " installed capacity 670.648753 680.877699 \n", + " net consumption 2613.014998 2608.658934 \n", + " net generation 2956.204082 2952.189018 \n", + " net imports -53.064250 -50.023250 \n", + "Europe distribution losses 312.122568 313.103557 \n", + " exports 443.876981 430.539587 \n", + " imports 461.685229 448.473861 \n", + " installed capacity 1268.886878 1286.459488 \n", + " net consumption 4021.955784 4033.031850 \n", + " net generation 4316.270104 4328.201133 \n", + " net imports 17.808248 17.934274 \n", + "Middle East distribution losses 115.204000 115.606100 \n", + " exports 16.475700 17.626000 \n", + " imports 20.749000 22.276000 \n", + " installed capacity 233.853100 253.873369 \n", + " net consumption 814.418020 859.965481 \n", + " net generation 925.348720 970.921581 \n", + " net imports 4.273300 4.650000 \n", + "North America distribution losses 332.848244 324.129033 \n", + " exports 70.976291 74.859494 \n", + " imports 72.321289 81.829801 \n", + " installed capacity 1263.275800 1260.288100 \n", + " net consumption 4620.822297 4683.045310 \n", + " net generation 4952.325543 5000.204037 \n", + " net imports 1.344998 6.970307 \n", + "\n", + " 2014 2015 \\\n", + "Region Features \n", + "Africa distribution losses 100.862683 107.622472 \n", + " exports 31.922840 34.030950 \n", + " imports 40.958282 40.208600 \n", + " installed capacity 169.635611 179.322610 \n", + " net consumption 646.013219 658.567024 \n", + " net generation 739.200236 761.371622 \n", + " net imports 9.035442 6.177650 \n", + "Asia & Oceania distribution losses 726.043045 728.905453 \n", + " exports 43.899299 46.000806 \n", + " imports 53.420703 58.622526 \n", + " installed capacity 2463.426712 2668.076439 \n", + " net consumption 9121.177292 9385.732178 \n", + " net generation 9837.698933 10102.015911 \n", + " net imports 9.521404 12.621720 \n", + "Central & South America distribution losses 195.090374 195.044023 \n", + " exports 46.755000 46.214375 \n", + " imports 48.488000 46.891300 \n", + " installed capacity 327.351239 341.688198 \n", + " net consumption 1029.599917 1064.668354 \n", + " net generation 1225.214520 1261.292682 \n", + " net imports 1.733000 0.676925 \n", + "Eurasia distribution losses 288.718833 283.011833 \n", + " exports 72.713750 68.759750 \n", + " imports 25.708500 24.632500 \n", + " installed capacity 706.369683 704.632633 \n", + " net consumption 2609.666644 2602.340334 \n", + " net generation 2945.390728 2929.479418 \n", + " net imports -47.005250 -44.127250 \n", + "Europe distribution losses 302.146616 307.118887 \n", + " exports 470.691760 499.598125 \n", + " imports 484.565844 512.493304 \n", + " installed capacity 1310.856618 1325.619640 \n", + " net consumption 3927.158554 4010.027085 \n", + " net generation 4215.431086 4304.250793 \n", + " net imports 13.874084 12.895179 \n", + "Middle East distribution losses 121.753000 136.956300 \n", + " exports 15.734300 13.304700 \n", + " imports 22.482000 24.437000 \n", + " installed capacity 267.802900 281.223764 \n", + " net consumption 921.739356 960.867656 \n", + " net generation 1036.744656 1086.691656 \n", + " net imports 6.747700 11.132300 \n", + "North America distribution losses 314.189122 319.202703 \n", + " exports 75.406872 84.372314 \n", + " imports 80.754999 88.191435 \n", + " installed capacity 1281.423800 1288.473000 \n", + " net consumption 4723.259542 4715.376861 \n", + " net generation 5032.100536 5030.760443 \n", + " net imports 5.348127 3.819121 \n", + "\n", + " 2016 2017 \\\n", + "Region Features \n", + "Africa distribution losses 120.267951 117.446872 \n", + " exports 34.692430 33.327730 \n", + " imports 41.309200 39.782764 \n", + " installed capacity 192.320816 210.921447 \n", + " net consumption 653.876644 686.573884 \n", + " net generation 768.887601 798.925498 \n", + " net imports 6.616770 6.455034 \n", + "Asia & Oceania distribution losses 762.739982 777.224502 \n", + " exports 58.194332 63.917965 \n", + " imports 65.819156 71.950994 \n", + " installed capacity 2887.051792 3072.989237 \n", + " net consumption 9870.251320 10499.360390 \n", + " net generation 10625.366477 11268.551864 \n", + " net imports 7.624824 8.033029 \n", + "Central & South America distribution losses 196.301150 196.639998 \n", + " exports 54.136813 49.679473 \n", + " imports 55.026600 51.657462 \n", + " installed capacity 362.778609 375.971286 \n", + " net consumption 1071.664743 1078.315722 \n", + " net generation 1269.333335 1275.234959 \n", + " net imports 0.889787 1.977989 \n", + "Eurasia distribution losses 282.647833 282.927833 \n", + " exports 70.614750 76.300450 \n", + " imports 19.114500 24.919500 \n", + " installed capacity 715.716686 714.825145 \n", + " net consumption 2624.207881 2632.181290 \n", + " net generation 2958.355965 2966.490074 \n", + " net imports -51.500250 -51.380950 \n", + "Europe distribution losses 306.535603 303.730092 \n", + " exports 461.683138 470.334575 \n", + " imports 479.089613 484.382843 \n", + " installed capacity 1340.532988 1366.865274 \n", + " net consumption 4075.724022 4087.731918 \n", + " net generation 4364.853150 4377.413742 \n", + " net imports 17.406475 14.048268 \n", + "Middle East distribution losses 141.557300 152.387842 \n", + " exports 14.215200 15.588800 \n", + " imports 23.822000 22.874000 \n", + " installed capacity 290.084263 296.263143 \n", + " net consumption 989.887694 1027.643852 \n", + " net generation 1121.838194 1172.746494 \n", + " net imports 9.606800 7.285200 \n", + "North America distribution losses 314.334447 306.825106 \n", + " exports 81.285189 83.214566 \n", + " imports 84.250796 77.729212 \n", + " installed capacity 1309.804900 1326.263400 \n", + " net consumption 4733.993558 4702.000202 \n", + " net generation 5045.362399 5014.310663 \n", + " net imports 2.965607 -5.485354 \n", + "\n", + " 2018 2019 \\\n", + "Region Features \n", + "Africa distribution losses 120.350344 123.135014 \n", + " exports 31.730300 36.012330 \n", + " imports 37.158895 36.120142 \n", + " installed capacity 231.117096 239.367773 \n", + " net consumption 698.793253 702.889739 \n", + " net generation 815.074778 827.276717 \n", + " net imports 5.428595 0.107812 \n", + "Asia & Oceania distribution losses 810.210076 811.441910 \n", + " exports 67.358170 69.461613 \n", + " imports 75.641028 79.321945 \n", + " installed capacity 3265.095200 3429.788250 \n", + " net consumption 11070.559832 11474.482488 \n", + " net generation 11872.487050 12276.064067 \n", + " net imports 8.282858 9.860332 \n", + "Central & South America distribution losses 199.318646 198.809974 \n", + " exports 48.688924 41.949039 \n", + " imports 49.430425 42.838501 \n", + " installed capacity 387.997173 402.208029 \n", + " net consumption 1096.508255 1099.521880 \n", + " net generation 1297.342629 1299.699622 \n", + " net imports 0.741501 0.889462 \n", + "Eurasia distribution losses 274.900433 272.615133 \n", + " exports 74.254750 73.869750 \n", + " imports 16.404700 16.388500 \n", + " installed capacity 714.917193 724.167792 \n", + " net consumption 2662.169213 2678.159241 \n", + " net generation 2994.919697 3008.255625 \n", + " net imports -57.850050 -57.481250 \n", + "Europe distribution losses 303.082485 297.535852 \n", + " exports 465.459254 464.196084 \n", + " imports 486.205733 491.142257 \n", + " installed capacity 1400.952397 1418.280092 \n", + " net consumption 4069.003190 4055.926950 \n", + " net generation 4351.339196 4326.516629 \n", + " net imports 20.746479 26.946173 \n", + "Middle East distribution losses 155.221385 165.089182 \n", + " exports 14.144000 13.858000 \n", + " imports 31.987000 44.946100 \n", + " installed capacity 298.368401 303.954947 \n", + " net consumption 1052.527842 1086.018911 \n", + " net generation 1189.906227 1220.019993 \n", + " net imports 17.843000 31.088100 \n", + "North America distribution losses 298.010523 288.822191 \n", + " exports 77.631527 83.441019 \n", + " imports 75.128295 76.293597 \n", + " installed capacity 1351.724789 1364.576789 \n", + " net consumption 4878.979091 4816.574574 \n", + " net generation 5179.492847 5112.544188 \n", + " net imports -2.503232 -7.147422 \n", + "\n", + " 2020 2021 \n", + "Region Features \n", + "Africa distribution losses 124.310329 124.988388 \n", + " exports 37.082820 37.662881 \n", + " imports 36.093690 37.648292 \n", + " installed capacity 243.532941 245.193015 \n", + " net consumption 680.388746 712.584720 \n", + " net generation 807.047981 838.947473 \n", + " net imports -0.989130 -0.014589 \n", + "Asia & Oceania distribution losses 786.911065 792.500149 \n", + " exports 75.376583 77.030618 \n", + " imports 88.089951 87.463914 \n", + " installed capacity 3680.474175 3853.457685 \n", + " net consumption 11742.523702 12665.270200 \n", + " net generation 12516.721399 13447.337052 \n", + " net imports 12.713368 10.433296 \n", + "Central & South America distribution losses 195.857514 199.680010 \n", + " exports 38.434271 38.794599 \n", + " imports 39.625489 35.477785 \n", + " installed capacity 414.911323 428.896663 \n", + " net consumption 1100.092492 1167.026170 \n", + " net generation 1297.016017 1372.280224 \n", + " net imports 1.191218 -3.316815 \n", + "Eurasia distribution losses 265.384183 263.323374 \n", + " exports 63.197350 72.384710 \n", + " imports 21.221200 26.346138 \n", + " installed capacity 733.129110 743.105110 \n", + " net consumption 2673.289939 2761.897411 \n", + " net generation 2980.650272 3071.259358 \n", + " net imports -41.976150 -46.038573 \n", + "Europe distribution losses 292.605807 294.824287 \n", + " exports 480.083713 507.242862 \n", + " imports 494.061577 529.015329 \n", + " installed capacity 1444.290822 1482.995172 \n", + " net consumption 3990.746417 4082.522458 \n", + " net generation 4269.374360 4355.574277 \n", + " net imports 13.977864 21.772468 \n", + "Middle East distribution losses 163.117147 169.089625 \n", + " exports 14.629100 14.358920 \n", + " imports 29.050000 28.806431 \n", + " installed capacity 306.974447 309.632447 \n", + " net consumption 1045.687765 1109.498530 \n", + " net generation 1194.384012 1264.140644 \n", + " net imports 14.420900 14.447511 \n", + "North America distribution losses 270.644224 296.127051 \n", + " exports 87.486172 68.009584 \n", + " imports 81.225548 71.680961 \n", + " installed capacity 1387.359489 1425.152689 \n", + " net consumption 4725.063247 4836.156431 \n", + " net generation 5001.968095 5128.612105 \n", + " net imports -6.260624 3.671377 \n", + "\n", + "[49 rows x 42 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Agrupar por 'Region' y obtener la suma de los valores\n", + "df_grouped = df.groupby('Region').sum(numeric_only=True)\n", + "\n", + "# Eliminar la columna 'Total'\n", + "df_groupedeT = df_grouped.drop(columns=['Total'])\n", + "\n", + "# Transponer el DataFrame para que los años sean las columnas y las regiones sean las filas\n", + "df_transposed = df_groupedeT.transpose()\n", + "\n", + "# Crear una figura más grande\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "\n", + "# Crear un mapa de colores\n", + "cmap = cm.get_cmap('tab10')\n", + "\n", + "# Crear un diccionario para asignar un color único a cada región\n", + "region_colors = {region: cmap(i) for i, region in enumerate(df_grouped.index.unique())}\n", + "\n", + "# Para cada región, trazar los valores a lo largo de los años\n", + "for i, (region, values) in enumerate(df_transposed.iteritems()):\n", + " ax.plot(df_transposed.index, values, label=region, color=region_colors[region])\n", + "\n", + "# Rotar las etiquetas del eje x\n", + "plt.xticks(rotation=45)\n", + "\n", + "# Añadir una leyenda fuera del gráfico\n", + "ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "\n", + "# Mostrar el gráfico\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 497 + }, + "id": "UAOFyFDLLMo-", + "outputId": "bce87c94-9834-48fc-f7f7-cc2e09897650" + }, + "execution_count": 85, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":14: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cmap = cm.get_cmap('tab10')\n", + ":20: FutureWarning: iteritems is deprecated and will be removed in a future version. Use .items instead.\n", + " for i, (region, values) in enumerate(df_transposed.iteritems()):\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Guardar el dataframe agrupado\n", + "df_grouped.to_csv('global_electricity_statistics_by_region.csv')" + ], + "metadata": { + "id": "3HyCu76yuvpS" + }, + "execution_count": 86, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Supongamos que 'df_grouped' es tu DataFrame y quieres predecir la columna '2021'\n", + "X = df_grouped.drop('2021', axis=1)\n", + "y = df_grouped['2021']\n", + "\n", + "# Dividir los datos en conjuntos de entrenamiento y prueba\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.42, random_state=45) # Puedes cambiar 'test_size' y 'random_state'\n", + "\n", + "# Crear la red GRU\n", + "model = Sequential()\n", + "model.add(GRU(200, activation='relu', kernel_regularizer=l2(0.2), input_shape=(X_train.shape[1], 1))) # Puedes cambiar el número de neuronas (150 aquí) y la función de activación ('relu' aquí)\n", + "model.add(Dense(1))\n", + "\n", + "# Compilar el modelo\n", + "model.compile(optimizer='adam', loss=MeanSquaredError()) # Puedes cambiar el optimizador ('adam' aquí) y la función de pérdida (MeanSquaredError aquí)\n", + "\n", + "# Ajustar el modelo a los datos de entrenamiento\n", + "history = model.fit(X_train, y_train, epochs=500, verbose=5) # Puedes cambiar el número de épocas (500 aquí)\n", + "\n", + "for i in range(len(history.history['loss'])):\n", + " print(f\"Epoch {i+1}: Loss = {history.history['loss'][i]}\")\n", + "\n", + "# Graficar la pérdida durante el entrenamiento\n", + "plt.plot(history.history['loss'])\n", + "plt.title('Model loss')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train'], loc='upper right')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "nfJrQD1i4qys", + "outputId": "13ef1135-788e-43a6-be85-1e57976461e6" + }, + "execution_count": 126, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/500\n", + "Epoch 2/500\n", + "Epoch 3/500\n", + "Epoch 4/500\n", + "Epoch 5/500\n", + "Epoch 6/500\n", + "Epoch 7/500\n", + "Epoch 8/500\n", + "Epoch 9/500\n", + "Epoch 10/500\n", + "Epoch 11/500\n", + "Epoch 12/500\n", + "Epoch 13/500\n", + "Epoch 14/500\n", + "Epoch 15/500\n", + "Epoch 16/500\n", + "Epoch 17/500\n", + "Epoch 18/500\n", + "Epoch 19/500\n", + "Epoch 20/500\n", + "Epoch 21/500\n", + "Epoch 22/500\n", + "Epoch 23/500\n", + "Epoch 24/500\n", + "Epoch 25/500\n", + "Epoch 26/500\n", + "Epoch 27/500\n", + "Epoch 28/500\n", + "Epoch 29/500\n", + "Epoch 30/500\n", + "Epoch 31/500\n", + "Epoch 32/500\n", + "Epoch 33/500\n", + "Epoch 34/500\n", + "Epoch 35/500\n", + "Epoch 36/500\n", + "Epoch 37/500\n", + "Epoch 38/500\n", + "Epoch 39/500\n", + "Epoch 40/500\n", + "Epoch 41/500\n", + "Epoch 42/500\n", + "Epoch 43/500\n", + "Epoch 44/500\n", + "Epoch 45/500\n", + "Epoch 46/500\n", + "Epoch 47/500\n", + "Epoch 48/500\n", + "Epoch 49/500\n", + "Epoch 50/500\n", + "Epoch 51/500\n", + "Epoch 52/500\n", + "Epoch 53/500\n", + "Epoch 54/500\n", + "Epoch 55/500\n", + "Epoch 56/500\n", + "Epoch 57/500\n", + "Epoch 58/500\n", + "Epoch 59/500\n", + "Epoch 60/500\n", + "Epoch 61/500\n", + "Epoch 62/500\n", + "Epoch 63/500\n", + "Epoch 64/500\n", + "Epoch 65/500\n", + "Epoch 66/500\n", + "Epoch 67/500\n", + "Epoch 68/500\n", + "Epoch 69/500\n", + "Epoch 70/500\n", + "Epoch 71/500\n", + "Epoch 72/500\n", + "Epoch 73/500\n", + "Epoch 74/500\n", + "Epoch 75/500\n", + "Epoch 76/500\n", + "Epoch 77/500\n", + "Epoch 78/500\n", + "Epoch 79/500\n", + "Epoch 80/500\n", + "Epoch 81/500\n", + "Epoch 82/500\n", + "Epoch 83/500\n", + "Epoch 84/500\n", + "Epoch 85/500\n", + "Epoch 86/500\n", + "Epoch 87/500\n", + "Epoch 88/500\n", + "Epoch 89/500\n", + "Epoch 90/500\n", + "Epoch 91/500\n", + "Epoch 92/500\n", + "Epoch 93/500\n", + "Epoch 94/500\n", + "Epoch 95/500\n", + "Epoch 96/500\n", + "Epoch 97/500\n", + "Epoch 98/500\n", + "Epoch 99/500\n", + "Epoch 100/500\n", + "Epoch 101/500\n", + "Epoch 102/500\n", + "Epoch 103/500\n", + "Epoch 104/500\n", + "Epoch 105/500\n", + "Epoch 106/500\n", + "Epoch 107/500\n", + "Epoch 108/500\n", + "Epoch 109/500\n", + "Epoch 110/500\n", + "Epoch 111/500\n", + "Epoch 112/500\n", + "Epoch 113/500\n", + "Epoch 114/500\n", + "Epoch 115/500\n", + "Epoch 116/500\n", + "Epoch 117/500\n", + "Epoch 118/500\n", + "Epoch 119/500\n", + "Epoch 120/500\n", + "Epoch 121/500\n", + "Epoch 122/500\n", + "Epoch 123/500\n", + "Epoch 124/500\n", + "Epoch 125/500\n", + "Epoch 126/500\n", + "Epoch 127/500\n", + "Epoch 128/500\n", + "Epoch 129/500\n", + "Epoch 130/500\n", + "Epoch 131/500\n", + "Epoch 132/500\n", + "Epoch 133/500\n", + "Epoch 134/500\n", + "Epoch 135/500\n", + "Epoch 136/500\n", + "Epoch 137/500\n", + "Epoch 138/500\n", + "Epoch 139/500\n", + "Epoch 140/500\n", + "Epoch 141/500\n", + "Epoch 142/500\n", + "Epoch 143/500\n", + "Epoch 144/500\n", + "Epoch 145/500\n", + "Epoch 146/500\n", + "Epoch 147/500\n", + "Epoch 148/500\n", + "Epoch 149/500\n", + "Epoch 150/500\n", + "Epoch 151/500\n", + "Epoch 152/500\n", + "Epoch 153/500\n", + "Epoch 154/500\n", + "Epoch 155/500\n", + "Epoch 156/500\n", + "Epoch 157/500\n", + "Epoch 158/500\n", + "Epoch 159/500\n", + "Epoch 160/500\n", + "Epoch 161/500\n", + "Epoch 162/500\n", + "Epoch 163/500\n", + "Epoch 164/500\n", + "Epoch 165/500\n", + "Epoch 166/500\n", + "Epoch 167/500\n", + "Epoch 168/500\n", + "Epoch 169/500\n", + "Epoch 170/500\n", + "Epoch 171/500\n", + "Epoch 172/500\n", + "Epoch 173/500\n", + "Epoch 174/500\n", + "Epoch 175/500\n", + "Epoch 176/500\n", + "Epoch 177/500\n", + "Epoch 178/500\n", + "Epoch 179/500\n", + "Epoch 180/500\n", + "Epoch 181/500\n", + "Epoch 182/500\n", + "Epoch 183/500\n", + "Epoch 184/500\n", + "Epoch 185/500\n", + "Epoch 186/500\n", + "Epoch 187/500\n", + "Epoch 188/500\n", + "Epoch 189/500\n", + "Epoch 190/500\n", + "Epoch 191/500\n", + "Epoch 192/500\n", + "Epoch 193/500\n", + "Epoch 194/500\n", + "Epoch 195/500\n", + "Epoch 196/500\n", + "Epoch 197/500\n", + "Epoch 198/500\n", + "Epoch 199/500\n", + "Epoch 200/500\n", + "Epoch 201/500\n", + "Epoch 202/500\n", + "Epoch 203/500\n", + "Epoch 204/500\n", + "Epoch 205/500\n", + "Epoch 206/500\n", + "Epoch 207/500\n", + "Epoch 208/500\n", + "Epoch 209/500\n", + "Epoch 210/500\n", + "Epoch 211/500\n", + "Epoch 212/500\n", + "Epoch 213/500\n", + "Epoch 214/500\n", + "Epoch 215/500\n", + "Epoch 216/500\n", + "Epoch 217/500\n", + "Epoch 218/500\n", + "Epoch 219/500\n", + "Epoch 220/500\n", + "Epoch 221/500\n", + "Epoch 222/500\n", + "Epoch 223/500\n", + "Epoch 224/500\n", + "Epoch 225/500\n", + "Epoch 226/500\n", + "Epoch 227/500\n", + "Epoch 228/500\n", + "Epoch 229/500\n", + "Epoch 230/500\n", + "Epoch 231/500\n", + "Epoch 232/500\n", + "Epoch 233/500\n", + "Epoch 234/500\n", + "Epoch 235/500\n", + "Epoch 236/500\n", + "Epoch 237/500\n", + "Epoch 238/500\n", + "Epoch 239/500\n", + "Epoch 240/500\n", + "Epoch 241/500\n", + "Epoch 242/500\n", + "Epoch 243/500\n", + "Epoch 244/500\n", + "Epoch 245/500\n", + "Epoch 246/500\n", + "Epoch 247/500\n", + "Epoch 248/500\n", + "Epoch 249/500\n", + "Epoch 250/500\n", + "Epoch 251/500\n", + "Epoch 252/500\n", + "Epoch 253/500\n", + "Epoch 254/500\n", + "Epoch 255/500\n", + "Epoch 256/500\n", + "Epoch 257/500\n", + "Epoch 258/500\n", + "Epoch 259/500\n", + "Epoch 260/500\n", + "Epoch 261/500\n", + "Epoch 262/500\n", + "Epoch 263/500\n", + "Epoch 264/500\n", + "Epoch 265/500\n", + "Epoch 266/500\n", + "Epoch 267/500\n", + "Epoch 268/500\n", + "Epoch 269/500\n", + "Epoch 270/500\n", + "Epoch 271/500\n", + "Epoch 272/500\n", + "Epoch 273/500\n", + "Epoch 274/500\n", + "Epoch 275/500\n", + "Epoch 276/500\n", + "Epoch 277/500\n", + "Epoch 278/500\n", + "Epoch 279/500\n", + "Epoch 280/500\n", + "Epoch 281/500\n", + "Epoch 282/500\n", + "Epoch 283/500\n", + "Epoch 284/500\n", + "Epoch 285/500\n", + "Epoch 286/500\n", + "Epoch 287/500\n", + "Epoch 288/500\n", + "Epoch 289/500\n", + "Epoch 290/500\n", + "Epoch 291/500\n", + "Epoch 292/500\n", + "Epoch 293/500\n", + "Epoch 294/500\n", + "Epoch 295/500\n", + "Epoch 296/500\n", + "Epoch 297/500\n", + "Epoch 298/500\n", + "Epoch 299/500\n", + "Epoch 300/500\n", + "Epoch 301/500\n", + "Epoch 302/500\n", + "Epoch 303/500\n", + "Epoch 304/500\n", + "Epoch 305/500\n", + "Epoch 306/500\n", + "Epoch 307/500\n", + "Epoch 308/500\n", + "Epoch 309/500\n", + "Epoch 310/500\n", + "Epoch 311/500\n", + "Epoch 312/500\n", + "Epoch 313/500\n", + "Epoch 314/500\n", + "Epoch 315/500\n", + "Epoch 316/500\n", + "Epoch 317/500\n", + "Epoch 318/500\n", + "Epoch 319/500\n", + "Epoch 320/500\n", + "Epoch 321/500\n", + "Epoch 322/500\n", + "Epoch 323/500\n", + "Epoch 324/500\n", + "Epoch 325/500\n", + "Epoch 326/500\n", + "Epoch 327/500\n", + "Epoch 328/500\n", + "Epoch 329/500\n", + "Epoch 330/500\n", + "Epoch 331/500\n", + "Epoch 332/500\n", + "Epoch 333/500\n", + "Epoch 334/500\n", + "Epoch 335/500\n", + "Epoch 336/500\n", + "Epoch 337/500\n", + "Epoch 338/500\n", + "Epoch 339/500\n", + "Epoch 340/500\n", + "Epoch 341/500\n", + "Epoch 342/500\n", + "Epoch 343/500\n", + "Epoch 344/500\n", + "Epoch 345/500\n", + "Epoch 346/500\n", + "Epoch 347/500\n", + "Epoch 348/500\n", + "Epoch 349/500\n", + "Epoch 350/500\n", + "Epoch 351/500\n", + "Epoch 352/500\n", + "Epoch 353/500\n", + "Epoch 354/500\n", + "Epoch 355/500\n", + "Epoch 356/500\n", + "Epoch 357/500\n", + "Epoch 358/500\n", + "Epoch 359/500\n", + "Epoch 360/500\n", + "Epoch 361/500\n", + "Epoch 362/500\n", + "Epoch 363/500\n", + "Epoch 364/500\n", + "Epoch 365/500\n", + "Epoch 366/500\n", + "Epoch 367/500\n", + "Epoch 368/500\n", + "Epoch 369/500\n", + "Epoch 370/500\n", + "Epoch 371/500\n", + "Epoch 372/500\n", + "Epoch 373/500\n", + "Epoch 374/500\n", + "Epoch 375/500\n", + "Epoch 376/500\n", + "Epoch 377/500\n", + "Epoch 378/500\n", + "Epoch 379/500\n", + "Epoch 380/500\n", + "Epoch 381/500\n", + "Epoch 382/500\n", + "Epoch 383/500\n", + "Epoch 384/500\n", + "Epoch 385/500\n", + "Epoch 386/500\n", + "Epoch 387/500\n", + "Epoch 388/500\n", + "Epoch 389/500\n", + "Epoch 390/500\n", + "Epoch 391/500\n", + "Epoch 392/500\n", + "Epoch 393/500\n", + "Epoch 394/500\n", + "Epoch 395/500\n", + "Epoch 396/500\n", + "Epoch 397/500\n", + "Epoch 398/500\n", + "Epoch 399/500\n", + "Epoch 400/500\n", + "Epoch 401/500\n", + "Epoch 402/500\n", + "Epoch 403/500\n", + "Epoch 404/500\n", + "Epoch 405/500\n", + "Epoch 406/500\n", + "Epoch 407/500\n", + "Epoch 408/500\n", + "Epoch 409/500\n", + "Epoch 410/500\n", + "Epoch 411/500\n", + "Epoch 412/500\n", + "Epoch 413/500\n", + "Epoch 414/500\n", + "Epoch 415/500\n", + "Epoch 416/500\n", + "Epoch 417/500\n", + "Epoch 418/500\n", + "Epoch 419/500\n", + "Epoch 420/500\n", + "Epoch 421/500\n", + "Epoch 422/500\n", + "Epoch 423/500\n", + "Epoch 424/500\n", + "Epoch 425/500\n", + "Epoch 426/500\n", + "Epoch 427/500\n", + "Epoch 428/500\n", + "Epoch 429/500\n", + "Epoch 430/500\n", + "Epoch 431/500\n", + "Epoch 432/500\n", + "Epoch 433/500\n", + "Epoch 434/500\n", + "Epoch 435/500\n", + "Epoch 436/500\n", + "Epoch 437/500\n", + "Epoch 438/500\n", + "Epoch 439/500\n", + "Epoch 440/500\n", + "Epoch 441/500\n", + "Epoch 442/500\n", + "Epoch 443/500\n", + "Epoch 444/500\n", + "Epoch 445/500\n", + "Epoch 446/500\n", + "Epoch 447/500\n", + "Epoch 448/500\n", + "Epoch 449/500\n", + "Epoch 450/500\n", + "Epoch 451/500\n", + "Epoch 452/500\n", + "Epoch 453/500\n", + "Epoch 454/500\n", + "Epoch 455/500\n", + "Epoch 456/500\n", + "Epoch 457/500\n", + "Epoch 458/500\n", + "Epoch 459/500\n", + "Epoch 460/500\n", + "Epoch 461/500\n", + "Epoch 462/500\n", + "Epoch 463/500\n", + "Epoch 464/500\n", + "Epoch 465/500\n", + "Epoch 466/500\n", + "Epoch 467/500\n", + "Epoch 468/500\n", + "Epoch 469/500\n", + "Epoch 470/500\n", + "Epoch 471/500\n", + "Epoch 472/500\n", + "Epoch 473/500\n", + "Epoch 474/500\n", + "Epoch 475/500\n", + "Epoch 476/500\n", + "Epoch 477/500\n", + "Epoch 478/500\n", + "Epoch 479/500\n", + "Epoch 480/500\n", + "Epoch 481/500\n", + "Epoch 482/500\n", + "Epoch 483/500\n", + "Epoch 484/500\n", + "Epoch 485/500\n", + "Epoch 486/500\n", + "Epoch 487/500\n", + "Epoch 488/500\n", + "Epoch 489/500\n", + "Epoch 490/500\n", + "Epoch 491/500\n", + "Epoch 492/500\n", + "Epoch 493/500\n", + "Epoch 494/500\n", + "Epoch 495/500\n", + "Epoch 496/500\n", + "Epoch 497/500\n", + "Epoch 498/500\n", + "Epoch 499/500\n", + "Epoch 500/500\n", + "Epoch 1: Loss = 476664320.0\n", + "Epoch 2: Loss = 383786176.0\n", + "Epoch 3: Loss = 275799584.0\n", + "Epoch 4: Loss = 144508784.0\n", + "Epoch 5: Loss = 86024400.0\n", + "Epoch 6: Loss = 50962160.0\n", + "Epoch 7: Loss = 30715182.0\n", + "Epoch 8: Loss = 21446492.0\n", + "Epoch 9: Loss = 1780972.0\n", + "Epoch 10: Loss = 616118.25\n", + "Epoch 11: Loss = 4608782.5\n", + "Epoch 12: Loss = 11165317.0\n", + "Epoch 13: Loss = 18538434.0\n", + "Epoch 14: Loss = 25265214.0\n", + "Epoch 15: Loss = 30020844.0\n", + "Epoch 16: Loss = 32484670.0\n", + "Epoch 17: Loss = 32069092.0\n", + "Epoch 18: Loss = 29959058.0\n", + "Epoch 19: Loss = 26224408.0\n", + "Epoch 20: Loss = 21320588.0\n", + "Epoch 21: Loss = 16034396.0\n", + "Epoch 22: Loss = 10948210.0\n", + "Epoch 23: Loss = 6723899.5\n", + "Epoch 24: Loss = 3383370.25\n", + "Epoch 25: Loss = 1263004.0\n", + "Epoch 26: Loss = 327972.90625\n", + "Epoch 27: Loss = 414811.9375\n", + "Epoch 28: Loss = 1275788.875\n", + "Epoch 29: Loss = 2570814.25\n", + "Epoch 30: Loss = 3942282.25\n", + "Epoch 31: Loss = 5124012.5\n", + "Epoch 32: Loss = 5742816.0\n", + "Epoch 33: Loss = 5946823.0\n", + "Epoch 34: Loss = 5374017.5\n", + "Epoch 35: Loss = 4437854.5\n", + "Epoch 36: Loss = 3458658.75\n", + "Epoch 37: Loss = 2136305.25\n", + "Epoch 38: Loss = 1345446.125\n", + "Epoch 39: Loss = 745571.375\n", + "Epoch 40: Loss = 379348.625\n", + "Epoch 41: Loss = 243101.40625\n", + "Epoch 42: Loss = 333880.9375\n", + "Epoch 43: Loss = 639979.25\n", + "Epoch 44: Loss = 1131097.625\n", + "Epoch 45: Loss = 1276156.875\n", + "Epoch 46: Loss = 1350289.25\n", + "Epoch 47: Loss = 1262604.875\n", + "Epoch 48: Loss = 1080269.875\n", + "Epoch 49: Loss = 1366670.75\n", + "Epoch 50: Loss = 920123.5625\n", + "Epoch 51: Loss = 612060.0625\n", + "Epoch 52: Loss = 242664.03125\n", + "Epoch 53: Loss = 238456.203125\n", + "Epoch 54: Loss = 331863.59375\n", + "Epoch 55: Loss = 405303.8125\n", + "Epoch 56: Loss = 509425.5\n", + "Epoch 57: Loss = 567652.6875\n", + "Epoch 58: Loss = 567605.5\n", + "Epoch 59: Loss = 449008.65625\n", + "Epoch 60: Loss = 367502.3125\n", + "Epoch 61: Loss = 254137.484375\n", + "Epoch 62: Loss = 217291.21875\n", + "Epoch 63: Loss = 210903.125\n", + "Epoch 64: Loss = 259898.296875\n", + "Epoch 65: Loss = 344656.0\n", + "Epoch 66: Loss = 313494.625\n", + "Epoch 67: Loss = 271120.15625\n", + "Epoch 68: Loss = 252635.640625\n", + "Epoch 69: Loss = 215255.4375\n", + "Epoch 70: Loss = 207134.53125\n", + "Epoch 71: Loss = 213421.859375\n", + "Epoch 72: Loss = 227616.375\n", + "Epoch 73: Loss = 224419.578125\n", + "Epoch 74: Loss = 330953.875\n", + "Epoch 75: Loss = 280401.9375\n", + "Epoch 76: Loss = 248410.046875\n", + "Epoch 77: Loss = 225617.59375\n", + "Epoch 78: Loss = 234678.0625\n", + "Epoch 79: Loss = 476375.5625\n", + "Epoch 80: Loss = 413566.6875\n", + "Epoch 81: Loss = 805563.9375\n", + "Epoch 82: Loss = 611543.1875\n", + "Epoch 83: Loss = 412170.9375\n", + "Epoch 84: Loss = 272107.21875\n", + "Epoch 85: Loss = 224679.125\n", + "Epoch 86: Loss = 223775.265625\n", + "Epoch 87: Loss = 405831.0\n", + "Epoch 88: Loss = 250020.84375\n", + "Epoch 89: Loss = 225281.484375\n", + "Epoch 90: Loss = 293061.0625\n", + "Epoch 91: Loss = 303139.40625\n", + "Epoch 92: Loss = 18937316.0\n", + "Epoch 93: Loss = 14433902.0\n", + "Epoch 94: Loss = 9064868.0\n", + "Epoch 95: Loss = 4095144.0\n", + "Epoch 96: Loss = 1124284.625\n", + "Epoch 97: Loss = 253690.03125\n", + "Epoch 98: Loss = 1039788.9375\n", + "Epoch 99: Loss = 2869081.5\n", + "Epoch 100: Loss = 4597382.0\n", + "Epoch 101: Loss = 6111712.5\n", + "Epoch 102: Loss = 5288407.0\n", + "Epoch 103: Loss = 4304008.0\n", + "Epoch 104: Loss = 2920462.5\n", + "Epoch 105: Loss = 1562694.0\n", + "Epoch 106: Loss = 597787.0625\n", + "Epoch 107: Loss = 215539.296875\n", + "Epoch 108: Loss = 433322.15625\n", + "Epoch 109: Loss = 1002153.875\n", + "Epoch 110: Loss = 1704510.25\n", + "Epoch 111: Loss = 1702312.875\n", + "Epoch 112: Loss = 1679507.125\n", + "Epoch 113: Loss = 1609862.25\n", + "Epoch 114: Loss = 1132493.375\n", + "Epoch 115: Loss = 671538.75\n", + "Epoch 116: Loss = 342272.4375\n", + "Epoch 117: Loss = 219786.6875\n", + "Epoch 118: Loss = 290771.59375\n", + "Epoch 119: Loss = 417387.09375\n", + "Epoch 120: Loss = 278222.0\n", + "Epoch 121: Loss = 352689.5\n", + "Epoch 122: Loss = 385353.6875\n", + "Epoch 123: Loss = 372619.09375\n", + "Epoch 124: Loss = 324061.1875\n", + "Epoch 125: Loss = 282354.34375\n", + "Epoch 126: Loss = 218600.09375\n", + "Epoch 127: Loss = 251053.46875\n", + "Epoch 128: Loss = 303800.65625\n", + "Epoch 129: Loss = 306274.875\n", + "Epoch 130: Loss = 282078.875\n", + "Epoch 131: Loss = 240117.25\n", + "Epoch 132: Loss = 219662.078125\n", + "Epoch 133: Loss = 212038.1875\n", + "Epoch 134: Loss = 237756.65625\n", + "Epoch 135: Loss = 241494.6875\n", + "Epoch 136: Loss = 226768.640625\n", + "Epoch 137: Loss = 204988.609375\n", + "Epoch 138: Loss = 160396.921875\n", + "Epoch 139: Loss = 158947.828125\n", + "Epoch 140: Loss = 1449201.0\n", + "Epoch 141: Loss = 1005428.5625\n", + "Epoch 142: Loss = 505652.53125\n", + "Epoch 143: Loss = 230413.359375\n", + "Epoch 144: Loss = 262285.5625\n", + "Epoch 145: Loss = 486337.03125\n", + "Epoch 146: Loss = 699882.125\n", + "Epoch 147: Loss = 684973.0625\n", + "Epoch 148: Loss = 494940.25\n", + "Epoch 149: Loss = 308742.875\n", + "Epoch 150: Loss = 192906.546875\n", + "Epoch 151: Loss = 198533.234375\n", + "Epoch 152: Loss = 276844.96875\n", + "Epoch 153: Loss = 344609.65625\n", + "Epoch 154: Loss = 1425865.125\n", + "Epoch 155: Loss = 243603.234375\n", + "Epoch 156: Loss = 185963.453125\n", + "Epoch 157: Loss = 155074.109375\n", + "Epoch 158: Loss = 187397.578125\n", + "Epoch 159: Loss = 259713.296875\n", + "Epoch 160: Loss = 286994.21875\n", + "Epoch 161: Loss = 280063.15625\n", + "Epoch 162: Loss = 247889.078125\n", + "Epoch 163: Loss = 211460.59375\n", + "Epoch 164: Loss = 963858.75\n", + "Epoch 165: Loss = 843820.625\n", + "Epoch 166: Loss = 574424.125\n", + "Epoch 167: Loss = 307616.46875\n", + "Epoch 168: Loss = 179169.984375\n", + "Epoch 169: Loss = 217556.984375\n", + "Epoch 170: Loss = 352362.5625\n", + "Epoch 171: Loss = 475269.0\n", + "Epoch 172: Loss = 509051.0\n", + "Epoch 173: Loss = 442788.5625\n", + "Epoch 174: Loss = 322979.46875\n", + "Epoch 175: Loss = 217366.40625\n", + "Epoch 176: Loss = 173403.359375\n", + "Epoch 177: Loss = 771162.4375\n", + "Epoch 178: Loss = 1202059.875\n", + "Epoch 179: Loss = 923131.25\n", + "Epoch 180: Loss = 542332.4375\n", + "Epoch 181: Loss = 271904.15625\n", + "Epoch 182: Loss = 221525.28125\n", + "Epoch 183: Loss = 353268.59375\n", + "Epoch 184: Loss = 537740.4375\n", + "Epoch 185: Loss = 645227.125\n", + "Epoch 186: Loss = 609486.8125\n", + "Epoch 187: Loss = 478009.40625\n", + "Epoch 188: Loss = 323947.40625\n", + "Epoch 189: Loss = 226339.125\n", + "Epoch 190: Loss = 219845.109375\n", + "Epoch 191: Loss = 283317.71875\n", + "Epoch 192: Loss = 360763.59375\n", + "Epoch 193: Loss = 399017.46875\n", + "Epoch 194: Loss = 377548.6875\n", + "Epoch 195: Loss = 313441.8125\n", + "Epoch 196: Loss = 242432.34375\n", + "Epoch 197: Loss = 201209.328125\n", + "Epoch 198: Loss = 204912.0\n", + "Epoch 199: Loss = 183994.796875\n", + "Epoch 200: Loss = 140977.359375\n", + "Epoch 201: Loss = 195614.4375\n", + "Epoch 202: Loss = 180938.765625\n", + "Epoch 203: Loss = 192589.75\n", + "Epoch 204: Loss = 213580.953125\n", + "Epoch 205: Loss = 196357.59375\n", + "Epoch 206: Loss = 180170.359375\n", + "Epoch 207: Loss = 168971.796875\n", + "Epoch 208: Loss = 172608.015625\n", + "Epoch 209: Loss = 180740.421875\n", + "Epoch 210: Loss = 176480.765625\n", + "Epoch 211: Loss = 164719.640625\n", + "Epoch 212: Loss = 159779.75\n", + "Epoch 213: Loss = 162895.375\n", + "Epoch 214: Loss = 165778.8125\n", + "Epoch 215: Loss = 3625436.0\n", + "Epoch 216: Loss = 1046363.3125\n", + "Epoch 217: Loss = 280614.3125\n", + "Epoch 218: Loss = 193853.546875\n", + "Epoch 219: Loss = 726596.1875\n", + "Epoch 220: Loss = 1165000.625\n", + "Epoch 221: Loss = 1018852.8125\n", + "Epoch 222: Loss = 533663.375\n", + "Epoch 223: Loss = 182641.734375\n", + "Epoch 224: Loss = 188730.09375\n", + "Epoch 225: Loss = 357399.84375\n", + "Epoch 226: Loss = 525476.8125\n", + "Epoch 227: Loss = 559322.3125\n", + "Epoch 228: Loss = 434058.71875\n", + "Epoch 229: Loss = 245131.515625\n", + "Epoch 230: Loss = 146602.6875\n", + "Epoch 231: Loss = 166093.71875\n", + "Epoch 232: Loss = 258646.921875\n", + "Epoch 233: Loss = 333600.21875\n", + "Epoch 234: Loss = 330236.40625\n", + "Epoch 235: Loss = 258638.9375\n", + "Epoch 236: Loss = 164502.59375\n", + "Epoch 237: Loss = 150593.515625\n", + "Epoch 238: Loss = 197698.4375\n", + "Epoch 239: Loss = 203402.265625\n", + "Epoch 240: Loss = 177990.0\n", + "Epoch 241: Loss = 169388.296875\n", + "Epoch 242: Loss = 160226.796875\n", + "Epoch 243: Loss = 143777.171875\n", + "Epoch 244: Loss = 141049.171875\n", + "Epoch 245: Loss = 148986.640625\n", + "Epoch 246: Loss = 157991.78125\n", + "Epoch 247: Loss = 180828.921875\n", + "Epoch 248: Loss = 147415.21875\n", + "Epoch 249: Loss = 138972.5\n", + "Epoch 250: Loss = 140020.015625\n", + "Epoch 251: Loss = 151804.21875\n", + "Epoch 252: Loss = 156365.265625\n", + "Epoch 253: Loss = 147665.734375\n", + "Epoch 254: Loss = 138242.765625\n", + "Epoch 255: Loss = 133920.265625\n", + "Epoch 256: Loss = 135045.671875\n", + "Epoch 257: Loss = 137099.125\n", + "Epoch 258: Loss = 136219.078125\n", + "Epoch 259: Loss = 132869.734375\n", + "Epoch 260: Loss = 6329099.0\n", + "Epoch 261: Loss = 4039440.75\n", + "Epoch 262: Loss = 1535747.0\n", + "Epoch 263: Loss = 264612.5\n", + "Epoch 264: Loss = 473520.125\n", + "Epoch 265: Loss = 1281833.125\n", + "Epoch 266: Loss = 2285685.0\n", + "Epoch 267: Loss = 2647135.0\n", + "Epoch 268: Loss = 2151582.25\n", + "Epoch 269: Loss = 1216443.125\n", + "Epoch 270: Loss = 318984.0\n", + "Epoch 271: Loss = 182622.453125\n", + "Epoch 272: Loss = 519531.40625\n", + "Epoch 273: Loss = 2095936.75\n", + "Epoch 274: Loss = 933172.3125\n", + "Epoch 275: Loss = 656698.3125\n", + "Epoch 276: Loss = 351158.5625\n", + "Epoch 277: Loss = 179935.265625\n", + "Epoch 278: Loss = 198289.71875\n", + "Epoch 279: Loss = 328879.15625\n", + "Epoch 280: Loss = 429191.8125\n", + "Epoch 281: Loss = 385994.09375\n", + "Epoch 282: Loss = 311288.125\n", + "Epoch 283: Loss = 225913.046875\n", + "Epoch 284: Loss = 171472.59375\n", + "Epoch 285: Loss = 172492.109375\n", + "Epoch 286: Loss = 210539.671875\n", + "Epoch 287: Loss = 243812.453125\n", + "Epoch 288: Loss = 3413708.5\n", + "Epoch 289: Loss = 1607231.125\n", + "Epoch 290: Loss = 257074.296875\n", + "Epoch 291: Loss = 259135.96875\n", + "Epoch 292: Loss = 902523.875\n", + "Epoch 293: Loss = 1470664.0\n", + "Epoch 294: Loss = 1556418.5\n", + "Epoch 295: Loss = 1906245.0\n", + "Epoch 296: Loss = 534941.125\n", + "Epoch 297: Loss = 192017.3125\n", + "Epoch 298: Loss = 202692.484375\n", + "Epoch 299: Loss = 465808.90625\n", + "Epoch 300: Loss = 732611.375\n", + "Epoch 301: Loss = 803350.0625\n", + "Epoch 302: Loss = 650247.125\n", + "Epoch 303: Loss = 397986.9375\n", + "Epoch 304: Loss = 206968.65625\n", + "Epoch 305: Loss = 165366.515625\n", + "Epoch 306: Loss = 159550.28125\n", + "Epoch 307: Loss = 175349.578125\n", + "Epoch 308: Loss = 188417.609375\n", + "Epoch 309: Loss = 173470.484375\n", + "Epoch 310: Loss = 151514.28125\n", + "Epoch 311: Loss = 159768.921875\n", + "Epoch 312: Loss = 168476.234375\n", + "Epoch 313: Loss = 148719.296875\n", + "Epoch 314: Loss = 150364.03125\n", + "Epoch 315: Loss = 154403.078125\n", + "Epoch 316: Loss = 454715.65625\n", + "Epoch 317: Loss = 276361.25\n", + "Epoch 318: Loss = 1367032.625\n", + "Epoch 319: Loss = 928810.3125\n", + "Epoch 320: Loss = 344173.21875\n", + "Epoch 321: Loss = 227058.609375\n", + "Epoch 322: Loss = 488522.09375\n", + "Epoch 323: Loss = 738131.5\n", + "Epoch 324: Loss = 729562.1875\n", + "Epoch 325: Loss = 2578598.75\n", + "Epoch 326: Loss = 171772.78125\n", + "Epoch 327: Loss = 293189.34375\n", + "Epoch 328: Loss = 569136.6875\n", + "Epoch 329: Loss = 625360.5625\n", + "Epoch 330: Loss = 471528.84375\n", + "Epoch 331: Loss = 242281.265625\n", + "Epoch 332: Loss = 137829.65625\n", + "Epoch 333: Loss = 196910.203125\n", + "Epoch 334: Loss = 318009.46875\n", + "Epoch 335: Loss = 380215.03125\n", + "Epoch 336: Loss = 337928.9375\n", + "Epoch 337: Loss = 235216.65625\n", + "Epoch 338: Loss = 154426.1875\n", + "Epoch 339: Loss = 147600.515625\n", + "Epoch 340: Loss = 201735.1875\n", + "Epoch 341: Loss = 255848.203125\n", + "Epoch 342: Loss = 248465.671875\n", + "Epoch 343: Loss = 169249.984375\n", + "Epoch 344: Loss = 149859.984375\n", + "Epoch 345: Loss = 147534.65625\n", + "Epoch 346: Loss = 154858.921875\n", + "Epoch 347: Loss = 174684.453125\n", + "Epoch 348: Loss = 156387.296875\n", + "Epoch 349: Loss = 266670.25\n", + "Epoch 350: Loss = 194430.09375\n", + "Epoch 351: Loss = 145305.296875\n", + "Epoch 352: Loss = 157074.5625\n", + "Epoch 353: Loss = 198298.328125\n", + "Epoch 354: Loss = 210365.546875\n", + "Epoch 355: Loss = 184047.78125\n", + "Epoch 356: Loss = 150473.921875\n", + "Epoch 357: Loss = 145185.453125\n", + "Epoch 358: Loss = 161722.375\n", + "Epoch 359: Loss = 163034.34375\n", + "Epoch 360: Loss = 162141.3125\n", + "Epoch 361: Loss = 151445.453125\n", + "Epoch 362: Loss = 141140.578125\n", + "Epoch 363: Loss = 137765.796875\n", + "Epoch 364: Loss = 132135.046875\n", + "Epoch 365: Loss = 130028.3359375\n", + "Epoch 366: Loss = 131535.71875\n", + "Epoch 367: Loss = 132132.625\n", + "Epoch 368: Loss = 130477.3671875\n", + "Epoch 369: Loss = 182739.78125\n", + "Epoch 370: Loss = 193128.734375\n", + "Epoch 371: Loss = 22865238.0\n", + "Epoch 372: Loss = 1247231.5\n", + "Epoch 373: Loss = 3883804.75\n", + "Epoch 374: Loss = 5641214.0\n", + "Epoch 375: Loss = 5474279.0\n", + "Epoch 376: Loss = 3782541.75\n", + "Epoch 377: Loss = 1704671.875\n", + "Epoch 378: Loss = 369237.78125\n", + "Epoch 379: Loss = 277872.375\n", + "Epoch 380: Loss = 1141628.75\n", + "Epoch 381: Loss = 2284744.5\n", + "Epoch 382: Loss = 2868966.5\n", + "Epoch 383: Loss = 4432581.0\n", + "Epoch 384: Loss = 3062475.5\n", + "Epoch 385: Loss = 1425274.75\n", + "Epoch 386: Loss = 361800.25\n", + "Epoch 387: Loss = 190131.125\n", + "Epoch 388: Loss = 583218.4375\n", + "Epoch 389: Loss = 1354179.625\n", + "Epoch 390: Loss = 1971119.0\n", + "Epoch 391: Loss = 2051274.25\n", + "Epoch 392: Loss = 1588909.625\n", + "Epoch 393: Loss = 846037.125\n", + "Epoch 394: Loss = 311060.71875\n", + "Epoch 395: Loss = 182415.859375\n", + "Epoch 396: Loss = 392944.65625\n", + "Epoch 397: Loss = 729744.125\n", + "Epoch 398: Loss = 846853.25\n", + "Epoch 399: Loss = 1221546.25\n", + "Epoch 400: Loss = 569594.3125\n", + "Epoch 401: Loss = 3032983.5\n", + "Epoch 402: Loss = 1657521.875\n", + "Epoch 403: Loss = 642202.375\n", + "Epoch 404: Loss = 194139.296875\n", + "Epoch 405: Loss = 488545.5625\n", + "Epoch 406: Loss = 1146071.375\n", + "Epoch 407: Loss = 1704032.75\n", + "Epoch 408: Loss = 1833427.125\n", + "Epoch 409: Loss = 1364362.375\n", + "Epoch 410: Loss = 838029.4375\n", + "Epoch 411: Loss = 319070.53125\n", + "Epoch 412: Loss = 214860.4375\n", + "Epoch 413: Loss = 387015.40625\n", + "Epoch 414: Loss = 685258.0625\n", + "Epoch 415: Loss = 809109.5625\n", + "Epoch 416: Loss = 734258.5625\n", + "Epoch 417: Loss = 530141.8125\n", + "Epoch 418: Loss = 320167.46875\n", + "Epoch 419: Loss = 206332.953125\n", + "Epoch 420: Loss = 212957.328125\n", + "Epoch 421: Loss = 294922.65625\n", + "Epoch 422: Loss = 344933.9375\n", + "Epoch 423: Loss = 204774.484375\n", + "Epoch 424: Loss = 206724.75\n", + "Epoch 425: Loss = 208003.921875\n", + "Epoch 426: Loss = 157369.796875\n", + "Epoch 427: Loss = 1339827.875\n", + "Epoch 428: Loss = 1548149.375\n", + "Epoch 429: Loss = 805548.5625\n", + "Epoch 430: Loss = 295187.8125\n", + "Epoch 431: Loss = 242409.140625\n", + "Epoch 432: Loss = 546811.1875\n", + "Epoch 433: Loss = 907333.9375\n", + "Epoch 434: Loss = 1055614.25\n", + "Epoch 435: Loss = 914947.3125\n", + "Epoch 436: Loss = 599572.8125\n", + "Epoch 437: Loss = 313066.53125\n", + "Epoch 438: Loss = 205606.96875\n", + "Epoch 439: Loss = 292028.78125\n", + "Epoch 440: Loss = 464949.09375\n", + "Epoch 441: Loss = 582895.625\n", + "Epoch 442: Loss = 567657.625\n", + "Epoch 443: Loss = 441874.75\n", + "Epoch 444: Loss = 294223.65625\n", + "Epoch 445: Loss = 210527.5\n", + "Epoch 446: Loss = 221002.015625\n", + "Epoch 447: Loss = 292714.5\n", + "Epoch 448: Loss = 376907.78125\n", + "Epoch 449: Loss = 393276.125\n", + "Epoch 450: Loss = 347753.3125\n", + "Epoch 451: Loss = 274122.65625\n", + "Epoch 452: Loss = 217602.421875\n", + "Epoch 453: Loss = 205256.78125\n", + "Epoch 454: Loss = 232232.40625\n", + "Epoch 455: Loss = 270426.03125\n", + "Epoch 456: Loss = 290370.03125\n", + "Epoch 457: Loss = 279821.8125\n", + "Epoch 458: Loss = 248248.0\n", + "Epoch 459: Loss = 216701.484375\n", + "Epoch 460: Loss = 202339.890625\n", + "Epoch 461: Loss = 208689.25\n", + "Epoch 462: Loss = 225922.78125\n", + "Epoch 463: Loss = 227206.375\n", + "Epoch 464: Loss = 229209.265625\n", + "Epoch 465: Loss = 221308.84375\n", + "Epoch 466: Loss = 209248.5625\n", + "Epoch 467: Loss = 203957.484375\n", + "Epoch 468: Loss = 199229.015625\n", + "Epoch 469: Loss = 202812.390625\n", + "Epoch 470: Loss = 209775.265625\n", + "Epoch 471: Loss = 213797.46875\n", + "Epoch 472: Loss = 211998.78125\n", + "Epoch 473: Loss = 206037.359375\n", + "Epoch 474: Loss = 200049.890625\n", + "Epoch 475: Loss = 197442.015625\n", + "Epoch 476: Loss = 198735.453125\n", + "Epoch 477: Loss = 201724.953125\n", + "Epoch 478: Loss = 203506.46875\n", + "Epoch 479: Loss = 202587.015625\n", + "Epoch 480: Loss = 200548.953125\n", + "Epoch 481: Loss = 196328.765625\n", + "Epoch 482: Loss = 194465.296875\n", + "Epoch 483: Loss = 194272.71875\n", + "Epoch 484: Loss = 193126.453125\n", + "Epoch 485: Loss = 384194.28125\n", + "Epoch 486: Loss = 1150305.375\n", + "Epoch 487: Loss = 752610.9375\n", + "Epoch 488: Loss = 376524.59375\n", + "Epoch 489: Loss = 230985.640625\n", + "Epoch 490: Loss = 338725.0\n", + "Epoch 491: Loss = 468431.59375\n", + "Epoch 492: Loss = 573539.6875\n", + "Epoch 493: Loss = 556648.1875\n", + "Epoch 494: Loss = 393611.5\n", + "Epoch 495: Loss = 260614.734375\n", + "Epoch 496: Loss = 214723.8125\n", + "Epoch 497: Loss = 269375.84375\n", + "Epoch 498: Loss = 356699.34375\n", + "Epoch 499: Loss = 364865.96875\n", + "Epoch 500: Loss = 287824.5\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "loss_values = history.history['loss']\n", + "print" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "My8by2_2DI_X", + "outputId": "f696d0f4-2591-4271-e7ce-719f7e48a721" + }, + "execution_count": 38, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[13978865.0, 13661791.0, 13745915.0, 14039383.0, 14036662.0, 13992389.0, 14043848.0, 13798370.0, 13376729.0, 13109994.0, 13637852.0, 13281099.0, 12732879.0, 11649245.0, 12006907.0, 10077946.0, 6745423.5, 8057920.0, 7560234.0, 10751578.0, 7243948.5, 7888572.0, 8588810.0, 8419626.0, 9516969.0, 7365000.0, 7175318.0, 9339095.0, 8668128.0, 7203061.5, 8713561.0, 9448430.0, 9513725.0, 6670869.5, 10145086.0, 6996037.5, 8719094.0, 9057428.0, 7909514.0, 10276208.0, 9739874.0, 10149930.0, 8913145.0, 10026408.0, 8749553.0, 9029780.0, 9004435.0, 9100776.0, 10185200.0, 10122906.0, 8880246.0, 8821126.0, 8521718.0, 8372325.5, 8121804.5, 8525467.0, 8518840.0, 8578520.0, 8065098.5, 7953030.5, 7886762.5, 7736829.5, 7885539.5, 8038061.0, 7792236.5, 7960796.0, 7895030.0, 7796317.5, 7477304.0, 8136023.0, 8435440.0, 8509963.0, 9771523.0, 10068050.0, 10016277.0, 10018746.0, 9927969.0, 9876155.0, 9829617.0, 9834552.0, 9743723.0, 9708187.0, 9673909.0, 9640575.0, 9607001.0, 9573277.0, 9538612.0, 9519751.0, 9463637.0, 9405359.0, 9351933.0, 9333471.0, 9251945.0, 9175816.0, 9133273.0, 9092211.0, 9026029.0, 8972206.0, 8917377.0, 8855146.0, 8817475.0, 8767893.0, 8704868.0, 8672368.0, 8623803.0, 8594071.0, 8551559.0, 8497334.0, 8350219.5, 8291855.0, 8181426.0, 8152970.0, 9679971.0, 9600615.0, 9520171.0, 8666106.0, 7868696.0, 8550929.0, 8475719.0, 8423616.0, 7516146.0, 8298322.0, 8117534.5, 8174611.5, 8131674.5, 8084244.5, 8049593.5, 7999823.5, 7967148.5, 7924028.0, 7876899.5, 7842282.0, 7801153.5, 7763562.5, 7723649.0, 7688537.5, 7653228.5, 7620349.5, 7590787.5, 7560942.0, 7530991.0, 7501377.0, 7471123.0, 7446005.5, 7411576.0, 7382610.0, 7355635.5, 7322470.5, 7322630.5, 7260817.0, 7230733.0, 7197820.0, 7166958.0, 7129025.5, 7092078.0, 7065559.0, 7030418.0, 6997822.5, 7857188.0, 6936069.0, 6907201.0, 6877264.5, 6851487.0, 6826318.0, 6801646.5, 6775227.5, 6749586.0, 6723898.5, 6692865.5, 6664151.0, 6631443.0, 6594502.5, 6556715.5, 6509205.5, 6480022.5, 6434694.0, 6394368.0, 6357692.5, 6316935.5, 6289429.5, 6248276.0, 6222152.5, 6186493.0, 6155007.5, 6119027.5, 6094129.0, 6062169.5, 6032828.5, 6004689.5, 5974583.5, 5951585.0, 5917849.5, 5894174.0, 5858341.0, 5828297.0, 5789473.5, 5757150.5, 5716894.5, 5683586.5, 5637409.5]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Escalar los datos entre 0 y 1scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_y = MinMaxScaler(feature_range=(0, 1))\n", + "train_X_scaled = scaler_X.fit_transform(train_X)\n", + "test_X_scaled = scaler_X.transform(test_X)\n", + "train_y_scaled = scaler_y.fit_transform(train_y.values.reshape(-1, 1))\n", + "test_y_scaled = scaler_y.transform(test_y.values.reshape(-1, 1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + }, + "id": "ji9qjt_SCrvY", + "outputId": "7610dff1-9cc5-4bba-92ea-a0b93fdf3a09" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mscaler_X\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mscaler_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mtrain_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mtest_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mtrain_y_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/_set_output.py\u001b[0m in \u001b[0;36mwrapped\u001b[0;34m(self, X, *args, **kwargs)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mdata_to_wrap\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_to_wrap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[0;31m# only wrap the first output for cross decomposition\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 876\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0my\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 877\u001b[0m \u001b[0;31m# fit method of arity 1 (unsupervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 878\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 879\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 880\u001b[0m \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 425\u001b[0m \u001b[0;31m# Reset internal state before fitting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 426\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 427\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 428\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mpartial_fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 464\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 465\u001b[0m \u001b[0mfirst_pass\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"n_samples_seen_\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 466\u001b[0;31m X = self._validate_data(\n\u001b[0m\u001b[1;32m 467\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[0mreset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfirst_pass\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36m_validate_data\u001b[0;34m(self, X, y, reset, validate_separately, **check_params)\u001b[0m\n\u001b[1;32m 563\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Validation should be done on X, y or both.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 564\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 565\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"X\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mcheck_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 566\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 567\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_array\u001b[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator, input_name)\u001b[0m\n\u001b[1;32m 776\u001b[0m )\n\u001b[1;32m 777\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtype_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdtype_iter\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 778\u001b[0;31m \u001b[0mdtype_orig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 779\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 780\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"iloc\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"dtype\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numpy/core/overrides.py\u001b[0m in \u001b[0;36mresult_type\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: at least one array or dtype is required" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Definir el modelo LSTM\n", + "model_lstm = Sequential()\n", + "model_lstm.add(LSTM(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "model_lstm.add(Dense(1))\n", + "model_lstm.compile(optimizer='adam', loss='mse')\n", + "\n", + "#/ Definir el modelo GRU\n", + "#model_gru = Sequential()\n", + "#model_gru.add(GRU(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "#model_gru.add(Dense(1))\n", + "#model_gru.compile(optimizer='adam', loss='mse')\n", + "#" + ], + "metadata": { + "id": "CaTJQmj33IvW" + }, + "execution_count": 16, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model_lstm.fit(train_X, train_y, epochs=10, verbose=0)\n", + "#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\n", + "\n", + "# Evaluar los modelos\n", + "mse_lstm = model_lstm.evaluate(test_X, test_y)\n", + "#mse_gru = model_gru.evaluate(test_X, test_y)\n", + "\n", + "print(f'Test MSE LSTM: {mse_lstm}')\n", + "#print(f'Test MSE GRU: {mse_gru}')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 245 + }, + "id": "3wBcalVC41ED", + "outputId": "671dcbb9-7d07-4da9-b9e3-1c52a5f16ef9" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;31m#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Evaluar los modelos\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mmse_lstm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'train_X' is not defined" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "hasta aca\n" + ], + "metadata": { + "id": "keXYd4TrurKV" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Convertir los datos a un formato largo usando melt de pandas\n", + "new_data = pd.melt(data, id_vars=['Country', 'Latitude', 'Longitude', 'Features', 'Region'], var_name='Year', value_name='Value')\n", + "\n", + "# Convertir las columnas al tipo de datos correcto\n", + "new_data['Year'] = new_data['Year'].astype(int)\n", + "new_data['Latitude'] = pd.to_numeric(new_data['Latitude'])\n", + "new_data['Longitude'] = pd.to_numeric(new_data['Longitude'])" + ], + "metadata": { + "id": "Xd6En43Apl_Z", + "outputId": "ff66b8ad-695e-4976-8859-ea466bc350cc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\"", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Convertir las columnas al tipo de datos correcto\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/tools/numeric.py\u001b[0m in \u001b[0;36mto_numeric\u001b[0;34m(arg, errors, downcast)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[0mcoerce_numeric\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0merrors\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"ignore\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"raise\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 184\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 185\u001b[0;31m values, _ = lib.maybe_convert_numeric(\n\u001b[0m\u001b[1;32m 186\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 187\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\" at position 161" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Reordenar los niveles de 'Features' en la secuencia deseada\n", + "feature_order = [\"imports\", \"exports\", \"net imports\", \"installed capacity\", \"net generation\", \"net consumption\", \"distribution losses\"]\n", + "new_data['Features'] = pd.Categorical(new_data['Features'], categories=feature_order, ordered=True)\n", + "\n", + "custom_palette = [\"red\", \"blue\", \"green\",\"purple\", \"#FF7F00\", \"cyan\", \"brown\"]\n", + "\n", + "# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\n", + "region_features = new_data.groupby(['Year', 'Region', 'Features']).agg(Total_Value=('Value', 'sum')).reset_index()\n", + "\n", + "# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "# Crear el gráfico de líneas con la paleta de colores personalizada\n", + "sns.lineplot(data=region_features, x='Year', y='Total_Value', hue='Region')\n", + "plt.title('Total Values by Region Over Time')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('Total')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 390 + }, + "id": "cYzGOiNeVfY7", + "outputId": "d3044941-773c-479f-a4bf-7e86be3e6785" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mregion_features\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Region'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0magg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTotal_Value\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Value'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sum'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36mgroupby\u001b[0;34m(self, by, axis, level, as_index, sort, group_keys, squeeze, observed, dropna)\u001b[0m\n\u001b[1;32m 8400\u001b[0m \u001b[0maxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_axis_number\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8401\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 8402\u001b[0;31m return DataFrameGroupBy(\n\u001b[0m\u001b[1;32m 8403\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8404\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/groupby.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, obj, keys, axis, level, grouper, exclusions, selection, as_index, sort, group_keys, squeeze, observed, mutated, dropna)\u001b[0m\n\u001b[1;32m 963\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrouper\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mget_grouper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 964\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 965\u001b[0;31m grouper, exclusions, obj = get_grouper(\n\u001b[0m\u001b[1;32m 966\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 967\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/grouper.py\u001b[0m in \u001b[0;36mget_grouper\u001b[0;34m(obj, key, axis, level, sort, observed, mutated, validate, dropna)\u001b[0m\n\u001b[1;32m 886\u001b[0m \u001b[0min_axis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 888\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 889\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGrouper\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkey\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 890\u001b[0m \u001b[0;31m# Add key to exclusions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "custom_palette = [\"#E41A1C\", \"#377EB8\", \"#4DAF4A\", \"#984EA3\", \"#FF7F00\", \"#FFFF33\", \"#A65628\"]\n", + "\n", + "# Filter the data for the past five years and 'exports'\n", + "export_data = new_data[(new_data['Features'] == \"exports\") & (new_data['Year'] >= (new_data['Year'].max() - 4))]\n", + "\n", + "# Group by 'Country' and calculate the total export value\n", + "top_exporting_countries = export_data.groupby('Country')['Value'].sum().reset_index().sort_values(by='Value', ascending=False).head(10)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(x='Value', y='Country', data=top_exporting_countries, palette=custom_palette)\n", + "print(top_exporting_countries)\n", + "\n", + "plt.xlabel('Total Exports')\n", + "plt.ylabel('Country')\n", + "plt.title('Exports - Last 5 Years - Top Ten Countries')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 512 + }, + "id": "pEGfENwGVhHK", + "outputId": "2dc0d837-10ef-4939-a46a-d36246f692a7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3801\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3802\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Filter the data for the past five years and 'exports'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mexport_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"exports\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# Group by 'Country' and calculate the total export value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3805\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3807\u001b[0;31m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3808\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3809\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3802\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3804\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3805\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;31m# If we have a listlike key, _check_indexing_error will raise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "RQfTp3HSXLqQ" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/proyectoIAPrediccion1LSTM.ipynb b/proyectoIAPrediccion1LSTM.ipynb new file mode 100644 index 0000000..8fa7ac5 --- /dev/null +++ b/proyectoIAPrediccion1LSTM.ipynb @@ -0,0 +1,2141 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as mcolors\n", + "import matplotlib.cm as cm\n", + "import seaborn as sns\n", + "import plotly.express as px\n", + "from wordcloud import WordCloud\n", + "import geopandas as gpd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from keras.models import Sequential\n", + "from keras.layers import LSTM, GRU, Conv1D, MaxPooling1D, Flatten, Dense\n", + "from keras.losses import MeanSquaredError\n", + "from keras.regularizers import l2\n", + "\n" + ], + "metadata": { + "id": "H7kZjC_GUZZd" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9_FId2wvQAgd" + }, + "outputs": [], + "source": [ + "# Leer los datos\n", + "GES_Data = \"global_electricity_statistics_cleaned.csv\"\n", + "df = pd.read_csv(GES_Data)" + ] + }, + { + "cell_type": "code", + "source": [ + "# Ver los primeros datos\n", + "print(df.head())\n", + "df[\"Features\"].value_counts()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lWY6qwmkQ2PL", + "outputId": "e89148ab-3b26-4467-9a79-ac3d32f733d6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Country Features Region 1980 1981 1982 1983 \\\n", + "0 Algeria net generation Africa 6.683 7.65 8.824 9.615 \n", + "1 Angola net generation Africa 0.905 0.906 0.995 1.028 \n", + "2 Benin net generation Africa 0.005 0.005 0.005 0.005 \n", + "3 Botswana net generation Africa 0.443 0.502 0.489 0.434 \n", + "4 Burkina Faso net generation Africa 0.098 0.108 0.115 0.117 \n", + "\n", + " 1984 1985 1986 ... 2012 2013 2014 2015 \\\n", + "0 10.537 11.569 12.214 ... 53.9845 56.3134 60.39972 64.68244 \n", + "1 1.028 1.028 1.088 ... 6.03408 7.97606 9.21666 9.30914 \n", + "2 0.005 0.005 0.005 ... 0.04612 0.08848 0.22666 0.31056 \n", + "3 0.445 0.456 0.538 ... 0.33 0.86868 2.17628 2.79104 \n", + "4 0.113 0.115 0.122 ... 0.86834 0.98268 1.11808 1.43986 \n", + "\n", + " 2016 2017 2018 2019 2020 2021 \n", + "0 66.75504 71.49546 72.10903 76.685 72.73591277 77.53072719 \n", + "1 10.203511 10.67604 12.83194 15.4 16.6 16.429392 \n", + "2 0.26004 0.3115 0.19028 0.2017 0.22608 0.24109728 \n", + "3 2.52984 2.8438 2.97076 3.0469 2.05144 2.18234816 \n", + "4 1.5509 1.64602 1.6464 1.72552 1.647133174 1.761209666 \n", + "\n", + "[5 rows x 45 columns]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "net generation 230\n", + "net consumption 230\n", + "imports 230\n", + "exports 230\n", + "net imports 230\n", + "installed capacity 230\n", + "distribution losses 230\n", + "Name: Features, dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 79 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Convertir las columnas de los años a numéricas\n", + "cols = [str(year) for year in range(1980, 2022)]\n", + "df[cols] = df[cols].apply(pd.to_numeric, errors='coerce')\n", + "\n", + "# Calcular el promedio de cada fila (ignorando los valores NaN)\n", + "df['avg'] = df.loc[:, '1980':'2021'].mean(axis=1)\n", + "\n", + "# Rellenar los valores NaN con el promedio de la fila correspondiente\n", + "for col in cols:\n", + " df[col].fillna(df['avg'], inplace=True)\n", + "\n", + "# Eliminar la columna 'avg' ya que ya no es necesaria\n", + "df.drop('avg', axis=1, inplace=True)\n", + "\n", + "# Agregar la columna 'Total' que es la suma de las columnas desde 1980 hasta 2021\n", + "df['Total'] = df.loc[:, '1980':'2021'].sum(axis=1)\n", + "\n", + "# Agrupar por 'Region' y 'Features', y obtener la suma\n", + "df_grouped = df.groupby(['Region', 'Features']).sum(numeric_only=True)\n" + ], + "metadata": { + "id": "9MZcbtw9t95l" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "base de datos lista con regiones y caracteristicas 1980 al 2021 abajo listo falta red neuronal y entrenamiento\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "_28HoIcVTX5H" + } + }, + { + "cell_type": "code", + "source": [ + "print(df_grouped)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6wZ4FIMSDhZH", + "outputId": "77273682-c22c-41a9-fae1-a801427bd5e7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " 1980 1981 \\\n", + "Region Features \n", + "Africa distribution losses 1.874121e+01 20.443093 \n", + " exports 3.935375e+00 4.327375 \n", + " imports 5.659906e+00 6.051906 \n", + " installed capacity 4.814117e+01 52.983167 \n", + " net consumption 1.737664e+02 183.373190 \n", + " net generation 1.907831e+02 202.091751 \n", + " net imports 1.724531e+00 1.724531 \n", + "Asia & Oceania distribution losses 1.031399e+02 110.245063 \n", + " exports 1.190000e+00 1.158000 \n", + " imports 1.507000e+00 1.585000 \n", + " installed capacity 3.299673e+02 350.290346 \n", + " net consumption 1.162988e+03 1192.215726 \n", + " net generation 1.265811e+03 1302.033789 \n", + " net imports 3.170000e-01 0.427000 \n", + "Central & South America distribution losses 3.859152e+01 36.077525 \n", + " exports 4.380000e-01 0.590000 \n", + " imports 4.380000e-01 0.449000 \n", + " installed capacity 8.227979e+01 89.194786 \n", + " net consumption 2.705502e+02 280.515562 \n", + " net generation 3.091417e+02 316.734087 \n", + " net imports 6.938894e-18 -0.141000 \n", + "Eurasia distribution losses 2.617115e+02 262.611506 \n", + " exports 7.943247e+01 81.441472 \n", + " imports 4.476119e+01 44.761188 \n", + " installed capacity 6.222894e+02 632.202353 \n", + " net consumption 2.343170e+03 2298.454189 \n", + " net generation 2.639553e+03 2597.745980 \n", + " net imports -3.467128e+01 -36.680284 \n", + "Europe distribution losses 2.120365e+02 209.191182 \n", + " exports 2.115657e+02 220.309746 \n", + " imports 2.116504e+02 222.262370 \n", + " installed capacity 7.708206e+02 786.288617 \n", + " net consumption 2.740265e+03 2745.516068 \n", + " net generation 2.952217e+03 2952.754626 \n", + " net imports 8.462388e-02 1.952624 \n", + "Middle East distribution losses 7.515476e+00 11.216626 \n", + " exports 2.320000e-01 0.227000 \n", + " imports 4.111621e+00 4.106621 \n", + " installed capacity 3.230383e+01 38.292828 \n", + " net consumption 8.818376e+01 95.959605 \n", + " net generation 9.181961e+01 103.296610 \n", + " net imports 3.879621e+00 3.879621 \n", + "North America distribution losses 2.558195e+02 221.393494 \n", + " exports 3.466465e+01 39.482123 \n", + " imports 3.003898e+01 39.913572 \n", + " installed capacity 6.737250e+02 698.724000 \n", + " net consumption 2.461083e+03 2531.029293 \n", + " net generation 2.721528e+03 2751.991338 \n", + " net imports -4.625664e+00 0.431449 \n", + "\n", + " 1982 1983 \\\n", + "Region Features \n", + "Africa distribution losses 20.504713 22.792113 \n", + " exports 4.989375 4.251375 \n", + " imports 6.722906 6.253906 \n", + " installed capacity 53.899167 56.308967 \n", + " net consumption 189.994270 196.583670 \n", + " net generation 208.765451 217.373251 \n", + " net imports 1.733531 2.002531 \n", + "Asia & Oceania distribution losses 112.874513 121.149903 \n", + " exports 1.179000 1.265000 \n", + " imports 2.009000 2.005000 \n", + " installed capacity 368.918346 392.552346 \n", + " net consumption 1246.608115 1325.026719 \n", + " net generation 1358.652628 1445.436622 \n", + " net imports 0.830000 0.740000 \n", + "Central & South America distribution losses 42.593765 45.658395 \n", + " exports 0.475000 4.261000 \n", + " imports 0.601000 4.033000 \n", + " installed capacity 94.589786 100.067786 \n", + " net consumption 293.158242 310.713632 \n", + " net generation 335.626007 356.600027 \n", + " net imports 0.126000 -0.228000 \n", + "Eurasia distribution losses 267.411506 270.111506 \n", + " exports 82.052472 83.838472 \n", + " imports 44.761188 44.761188 \n", + " installed capacity 640.328353 649.579353 \n", + " net consumption 2408.629042 2452.972540 \n", + " net generation 2713.331833 2762.161331 \n", + " net imports -37.291284 -39.077284 \n", + "Europe distribution losses 210.397242 220.819682 \n", + " exports 216.397746 239.093746 \n", + " imports 218.558370 243.130370 \n", + " installed capacity 804.458617 817.115617 \n", + " net consumption 2757.528008 2819.162568 \n", + " net generation 2965.764626 3035.945626 \n", + " net imports 2.160624 4.036624 \n", + "Middle East distribution losses 12.716366 12.381506 \n", + " exports 0.330000 0.291000 \n", + " imports 4.209621 4.170621 \n", + " installed capacity 43.108828 48.766828 \n", + " net consumption 114.088865 128.651725 \n", + " net generation 122.925610 137.153610 \n", + " net imports 3.879621 3.879621 \n", + "North America distribution losses 227.643996 237.414793 \n", + " exports 40.319463 42.314293 \n", + " imports 40.319634 42.314038 \n", + " installed capacity 717.576000 728.127000 \n", + " net consumption 2476.041662 2555.949638 \n", + " net generation 2703.685487 2793.364686 \n", + " net imports 0.000171 -0.000255 \n", + "\n", + " 1984 1985 \\\n", + "Region Features \n", + "Africa distribution losses 24.310513 29.939433 \n", + " exports 4.594375 4.237375 \n", + " imports 6.369906 5.961906 \n", + " installed capacity 60.707967 63.234967 \n", + " net consumption 214.139970 225.634750 \n", + " net generation 236.674951 253.849651 \n", + " net imports 1.775531 1.724531 \n", + "Asia & Oceania distribution losses 126.509673 148.113229 \n", + " exports 1.696000 1.903000 \n", + " imports 2.134000 2.228000 \n", + " installed capacity 416.259346 440.239786 \n", + " net consumption 1422.219174 1498.540497 \n", + " net generation 1548.290847 1646.328726 \n", + " net imports 0.438000 0.325000 \n", + "Central & South America distribution losses 46.117535 50.984685 \n", + " exports 3.760000 5.323000 \n", + " imports 3.665000 2.648000 \n", + " installed capacity 106.934786 113.188786 \n", + " net consumption 337.728692 350.544262 \n", + " net generation 383.941227 404.203947 \n", + " net imports -0.095000 -2.675000 \n", + "Eurasia distribution losses 280.911506 288.511506 \n", + " exports 84.734472 91.332472 \n", + " imports 44.761188 46.361188 \n", + " installed capacity 659.918353 669.045353 \n", + " net consumption 2516.762419 2557.075511 \n", + " net generation 2837.647210 2890.558302 \n", + " net imports -39.973284 -44.971284 \n", + "Europe distribution losses 227.212242 239.311152 \n", + " exports 244.937746 246.803746 \n", + " imports 250.172370 257.239370 \n", + " installed capacity 842.635617 862.814617 \n", + " net consumption 2923.534008 3014.283098 \n", + " net generation 3145.511626 3243.158626 \n", + " net imports 5.234624 10.435624 \n", + "Middle East distribution losses 12.534696 14.515696 \n", + " exports 0.199000 0.328000 \n", + " imports 4.078621 4.207621 \n", + " installed capacity 53.286828 54.877828 \n", + " net consumption 143.957535 153.760535 \n", + " net generation 152.612610 164.396610 \n", + " net imports 3.879621 3.879621 \n", + "North America distribution losses 213.703069 235.735172 \n", + " exports 43.476293 47.519917 \n", + " imports 43.476432 47.458180 \n", + " installed capacity 748.786000 770.521000 \n", + " net consumption 2720.030437 2778.895211 \n", + " net generation 2933.733367 3014.692120 \n", + " net imports 0.000139 -0.061737 \n", + "\n", + " 1986 1987 \\\n", + "Region Features \n", + "Africa distribution losses 23.062873 26.468153 \n", + " exports 4.171375 2.530375 \n", + " imports 6.010906 4.454906 \n", + " installed capacity 69.761967 71.632967 \n", + " net consumption 245.635010 254.337430 \n", + " net generation 266.858351 278.881051 \n", + " net imports 1.839531 1.924531 \n", + "Asia & Oceania distribution losses 153.614063 168.974833 \n", + " exports 2.265198 2.838005 \n", + " imports 2.184701 2.737251 \n", + " installed capacity 462.890166 486.629886 \n", + " net consumption 1583.920647 1715.996800 \n", + " net generation 1737.615207 1885.072388 \n", + " net imports -0.080498 -0.100755 \n", + "Central & South America distribution losses 59.351220 65.950150 \n", + " exports 13.315000 18.816000 \n", + " imports 13.188000 18.337600 \n", + " installed capacity 117.481000 122.055000 \n", + " net consumption 375.881060 385.142790 \n", + " net generation 435.359280 451.571340 \n", + " net imports -0.127000 -0.478400 \n", + "Eurasia distribution losses 292.111506 297.411506 \n", + " exports 91.067472 95.700472 \n", + " imports 46.061188 45.661188 \n", + " installed capacity 675.670353 679.240353 \n", + " net consumption 2518.068596 2569.916228 \n", + " net generation 2855.186387 2917.367019 \n", + " net imports -45.006284 -50.039284 \n", + "Europe distribution losses 236.588012 243.415292 \n", + " exports 241.788746 255.341746 \n", + " imports 252.566370 271.346370 \n", + " installed capacity 878.766617 898.170617 \n", + " net consumption 3073.428238 3145.392958 \n", + " net generation 3299.238626 3372.803626 \n", + " net imports 10.777624 16.004624 \n", + "Middle East distribution losses 12.710696 16.239696 \n", + " exports 0.573000 0.478000 \n", + " imports 4.252621 4.191621 \n", + " installed capacity 58.097828 62.736828 \n", + " net consumption 163.961535 169.719535 \n", + " net generation 172.992610 182.245610 \n", + " net imports 3.679621 3.713621 \n", + "North America distribution losses 201.979128 210.630140 \n", + " exports 44.521565 54.824235 \n", + " imports 44.511861 54.829032 \n", + " installed capacity 783.141000 796.349000 \n", + " net consumption 2843.497120 2954.184324 \n", + " net generation 3045.485952 3164.809667 \n", + " net imports -0.009704 0.004797 \n", + "\n", + " 1988 1989 ... \\\n", + "Region Features ... \n", + "Africa distribution losses 27.225493 28.415993 ... \n", + " exports 2.427375 2.709375 ... \n", + " imports 4.419906 4.531906 ... \n", + " installed capacity 75.977967 79.771567 ... \n", + " net consumption 262.564790 271.933940 ... \n", + " net generation 287.797751 298.527401 ... \n", + " net imports 1.992531 1.822531 ... \n", + "Asia & Oceania distribution losses 178.805683 200.790531 ... \n", + " exports 3.310800 3.860101 ... \n", + " imports 3.174608 3.324543 ... \n", + " installed capacity 513.284356 536.453276 ... \n", + " net consumption 1856.190046 1977.313215 ... \n", + " net generation 2035.131922 2178.639305 ... \n", + " net imports -0.136193 -0.535558 ... \n", + "Central & South America distribution losses 67.784620 72.544900 ... \n", + " exports 19.189000 21.934000 ... \n", + " imports 19.033500 23.353000 ... \n", + " installed capacity 127.767000 130.554000 ... \n", + " net consumption 405.170040 413.088700 ... \n", + " net generation 473.110160 484.214600 ... \n", + " net imports -0.155500 1.419000 ... \n", + "Eurasia distribution losses 294.711506 296.411506 ... \n", + " exports 99.212472 98.535472 ... \n", + " imports 45.461188 45.461188 ... \n", + " installed capacity 692.645353 695.674353 ... \n", + " net consumption 2607.296149 2638.989586 ... \n", + " net generation 2955.758940 2988.475377 ... \n", + " net imports -53.751284 -53.074284 ... \n", + "Europe distribution losses 241.951762 243.408832 ... \n", + " exports 272.139746 293.217746 ... \n", + " imports 291.926370 312.685370 ... \n", + " installed capacity 908.236617 916.832617 ... \n", + " net consumption 3199.221488 3253.479218 ... \n", + " net generation 3421.386626 3477.420426 ... \n", + " net imports 19.786624 19.467624 ... \n", + "Middle East distribution losses 19.424696 19.650696 ... \n", + " exports 0.375000 0.380000 ... \n", + " imports 4.234621 4.259621 ... \n", + " installed capacity 69.399828 72.768828 ... \n", + " net consumption 189.148535 200.692535 ... \n", + " net generation 204.713610 216.463610 ... \n", + " net imports 3.859621 3.879621 ... \n", + "North America distribution losses 213.193537 278.523167 ... \n", + " exports 42.929646 39.016589 ... \n", + " imports 42.936199 39.084799 ... \n", + " installed capacity 798.026000 834.564000 ... \n", + " net consumption 3095.903194 3292.470057 ... \n", + " net generation 3309.090178 3570.925014 ... \n", + " net imports 0.006553 0.068210 ... \n", + "\n", + " 2012 2013 \\\n", + "Region Features \n", + "Africa distribution losses 90.741794 100.652074 \n", + " exports 31.560100 29.270320 \n", + " imports 39.407200 38.460900 \n", + " installed capacity 157.783510 166.204887 \n", + " net consumption 611.512095 620.559458 \n", + " net generation 695.766565 713.380728 \n", + " net imports 7.847100 9.190580 \n", + "Asia & Oceania distribution losses 678.990130 718.717462 \n", + " exports 38.076848 43.201222 \n", + " imports 48.086716 53.728922 \n", + " installed capacity 2169.864984 2330.909732 \n", + " net consumption 8227.563211 8719.145784 \n", + " net generation 8896.543473 9427.335547 \n", + " net imports 10.009868 10.527699 \n", + "Central & South America distribution losses 178.592105 183.188955 \n", + " exports 50.448000 50.482230 \n", + " imports 51.803500 51.705970 \n", + " installed capacity 296.354729 317.115300 \n", + " net consumption 1006.331172 1046.180499 \n", + " net generation 1185.825005 1230.402943 \n", + " net imports 1.355500 1.223740 \n", + "Eurasia distribution losses 290.124833 293.506833 \n", + " exports 81.157750 76.856750 \n", + " imports 28.093500 26.833500 \n", + " installed capacity 670.648753 680.877699 \n", + " net consumption 2613.014998 2608.658934 \n", + " net generation 2956.204082 2952.189018 \n", + " net imports -53.064250 -50.023250 \n", + "Europe distribution losses 312.122568 313.103557 \n", + " exports 443.876981 430.539587 \n", + " imports 461.685229 448.473861 \n", + " installed capacity 1268.886878 1286.459488 \n", + " net consumption 4021.955784 4033.031850 \n", + " net generation 4316.270104 4328.201133 \n", + " net imports 17.808248 17.934274 \n", + "Middle East distribution losses 115.204000 115.606100 \n", + " exports 16.475700 17.626000 \n", + " imports 20.749000 22.276000 \n", + " installed capacity 233.853100 253.873369 \n", + " net consumption 814.418020 859.965481 \n", + " net generation 925.348720 970.921581 \n", + " net imports 4.273300 4.650000 \n", + "North America distribution losses 332.848244 324.129033 \n", + " exports 70.976291 74.859494 \n", + " imports 72.321289 81.829801 \n", + " installed capacity 1263.275800 1260.288100 \n", + " net consumption 4620.822297 4683.045310 \n", + " net generation 4952.325543 5000.204037 \n", + " net imports 1.344998 6.970307 \n", + "\n", + " 2014 2015 \\\n", + "Region Features \n", + "Africa distribution losses 100.862683 107.622472 \n", + " exports 31.922840 34.030950 \n", + " imports 40.958282 40.208600 \n", + " installed capacity 169.635611 179.322610 \n", + " net consumption 646.013219 658.567024 \n", + " net generation 739.200236 761.371622 \n", + " net imports 9.035442 6.177650 \n", + "Asia & Oceania distribution losses 726.043045 728.905453 \n", + " exports 43.899299 46.000806 \n", + " imports 53.420703 58.622526 \n", + " installed capacity 2463.426712 2668.076439 \n", + " net consumption 9121.177292 9385.732178 \n", + " net generation 9837.698933 10102.015911 \n", + " net imports 9.521404 12.621720 \n", + "Central & South America distribution losses 195.090374 195.044023 \n", + " exports 46.755000 46.214375 \n", + " imports 48.488000 46.891300 \n", + " installed capacity 327.351239 341.688198 \n", + " net consumption 1029.599917 1064.668354 \n", + " net generation 1225.214520 1261.292682 \n", + " net imports 1.733000 0.676925 \n", + "Eurasia distribution losses 288.718833 283.011833 \n", + " exports 72.713750 68.759750 \n", + " imports 25.708500 24.632500 \n", + " installed capacity 706.369683 704.632633 \n", + " net consumption 2609.666644 2602.340334 \n", + " net generation 2945.390728 2929.479418 \n", + " net imports -47.005250 -44.127250 \n", + "Europe distribution losses 302.146616 307.118887 \n", + " exports 470.691760 499.598125 \n", + " imports 484.565844 512.493304 \n", + " installed capacity 1310.856618 1325.619640 \n", + " net consumption 3927.158554 4010.027085 \n", + " net generation 4215.431086 4304.250793 \n", + " net imports 13.874084 12.895179 \n", + "Middle East distribution losses 121.753000 136.956300 \n", + " exports 15.734300 13.304700 \n", + " imports 22.482000 24.437000 \n", + " installed capacity 267.802900 281.223764 \n", + " net consumption 921.739356 960.867656 \n", + " net generation 1036.744656 1086.691656 \n", + " net imports 6.747700 11.132300 \n", + "North America distribution losses 314.189122 319.202703 \n", + " exports 75.406872 84.372314 \n", + " imports 80.754999 88.191435 \n", + " installed capacity 1281.423800 1288.473000 \n", + " net consumption 4723.259542 4715.376861 \n", + " net generation 5032.100536 5030.760443 \n", + " net imports 5.348127 3.819121 \n", + "\n", + " 2016 2017 \\\n", + "Region Features \n", + "Africa distribution losses 120.267951 117.446872 \n", + " exports 34.692430 33.327730 \n", + " imports 41.309200 39.782764 \n", + " installed capacity 192.320816 210.921447 \n", + " net consumption 653.876644 686.573884 \n", + " net generation 768.887601 798.925498 \n", + " net imports 6.616770 6.455034 \n", + "Asia & Oceania distribution losses 762.739982 777.224502 \n", + " exports 58.194332 63.917965 \n", + " imports 65.819156 71.950994 \n", + " installed capacity 2887.051792 3072.989237 \n", + " net consumption 9870.251320 10499.360390 \n", + " net generation 10625.366477 11268.551864 \n", + " net imports 7.624824 8.033029 \n", + "Central & South America distribution losses 196.301150 196.639998 \n", + " exports 54.136813 49.679473 \n", + " imports 55.026600 51.657462 \n", + " installed capacity 362.778609 375.971286 \n", + " net consumption 1071.664743 1078.315722 \n", + " net generation 1269.333335 1275.234959 \n", + " net imports 0.889787 1.977989 \n", + "Eurasia distribution losses 282.647833 282.927833 \n", + " exports 70.614750 76.300450 \n", + " imports 19.114500 24.919500 \n", + " installed capacity 715.716686 714.825145 \n", + " net consumption 2624.207881 2632.181290 \n", + " net generation 2958.355965 2966.490074 \n", + " net imports -51.500250 -51.380950 \n", + "Europe distribution losses 306.535603 303.730092 \n", + " exports 461.683138 470.334575 \n", + " imports 479.089613 484.382843 \n", + " installed capacity 1340.532988 1366.865274 \n", + " net consumption 4075.724022 4087.731918 \n", + " net generation 4364.853150 4377.413742 \n", + " net imports 17.406475 14.048268 \n", + "Middle East distribution losses 141.557300 152.387842 \n", + " exports 14.215200 15.588800 \n", + " imports 23.822000 22.874000 \n", + " installed capacity 290.084263 296.263143 \n", + " net consumption 989.887694 1027.643852 \n", + " net generation 1121.838194 1172.746494 \n", + " net imports 9.606800 7.285200 \n", + "North America distribution losses 314.334447 306.825106 \n", + " exports 81.285189 83.214566 \n", + " imports 84.250796 77.729212 \n", + " installed capacity 1309.804900 1326.263400 \n", + " net consumption 4733.993558 4702.000202 \n", + " net generation 5045.362399 5014.310663 \n", + " net imports 2.965607 -5.485354 \n", + "\n", + " 2018 2019 \\\n", + "Region Features \n", + "Africa distribution losses 120.350344 123.135014 \n", + " exports 31.730300 36.012330 \n", + " imports 37.158895 36.120142 \n", + " installed capacity 231.117096 239.367773 \n", + " net consumption 698.793253 702.889739 \n", + " net generation 815.074778 827.276717 \n", + " net imports 5.428595 0.107812 \n", + "Asia & Oceania distribution losses 810.210076 811.441910 \n", + " exports 67.358170 69.461613 \n", + " imports 75.641028 79.321945 \n", + " installed capacity 3265.095200 3429.788250 \n", + " net consumption 11070.559832 11474.482488 \n", + " net generation 11872.487050 12276.064067 \n", + " net imports 8.282858 9.860332 \n", + "Central & South America distribution losses 199.318646 198.809974 \n", + " exports 48.688924 41.949039 \n", + " imports 49.430425 42.838501 \n", + " installed capacity 387.997173 402.208029 \n", + " net consumption 1096.508255 1099.521880 \n", + " net generation 1297.342629 1299.699622 \n", + " net imports 0.741501 0.889462 \n", + "Eurasia distribution losses 274.900433 272.615133 \n", + " exports 74.254750 73.869750 \n", + " imports 16.404700 16.388500 \n", + " installed capacity 714.917193 724.167792 \n", + " net consumption 2662.169213 2678.159241 \n", + " net generation 2994.919697 3008.255625 \n", + " net imports -57.850050 -57.481250 \n", + "Europe distribution losses 303.082485 297.535852 \n", + " exports 465.459254 464.196084 \n", + " imports 486.205733 491.142257 \n", + " installed capacity 1400.952397 1418.280092 \n", + " net consumption 4069.003190 4055.926950 \n", + " net generation 4351.339196 4326.516629 \n", + " net imports 20.746479 26.946173 \n", + "Middle East distribution losses 155.221385 165.089182 \n", + " exports 14.144000 13.858000 \n", + " imports 31.987000 44.946100 \n", + " installed capacity 298.368401 303.954947 \n", + " net consumption 1052.527842 1086.018911 \n", + " net generation 1189.906227 1220.019993 \n", + " net imports 17.843000 31.088100 \n", + "North America distribution losses 298.010523 288.822191 \n", + " exports 77.631527 83.441019 \n", + " imports 75.128295 76.293597 \n", + " installed capacity 1351.724789 1364.576789 \n", + " net consumption 4878.979091 4816.574574 \n", + " net generation 5179.492847 5112.544188 \n", + " net imports -2.503232 -7.147422 \n", + "\n", + " 2020 2021 \n", + "Region Features \n", + "Africa distribution losses 124.310329 124.988388 \n", + " exports 37.082820 37.662881 \n", + " imports 36.093690 37.648292 \n", + " installed capacity 243.532941 245.193015 \n", + " net consumption 680.388746 712.584720 \n", + " net generation 807.047981 838.947473 \n", + " net imports -0.989130 -0.014589 \n", + "Asia & Oceania distribution losses 786.911065 792.500149 \n", + " exports 75.376583 77.030618 \n", + " imports 88.089951 87.463914 \n", + " installed capacity 3680.474175 3853.457685 \n", + " net consumption 11742.523702 12665.270200 \n", + " net generation 12516.721399 13447.337052 \n", + " net imports 12.713368 10.433296 \n", + "Central & South America distribution losses 195.857514 199.680010 \n", + " exports 38.434271 38.794599 \n", + " imports 39.625489 35.477785 \n", + " installed capacity 414.911323 428.896663 \n", + " net consumption 1100.092492 1167.026170 \n", + " net generation 1297.016017 1372.280224 \n", + " net imports 1.191218 -3.316815 \n", + "Eurasia distribution losses 265.384183 263.323374 \n", + " exports 63.197350 72.384710 \n", + " imports 21.221200 26.346138 \n", + " installed capacity 733.129110 743.105110 \n", + " net consumption 2673.289939 2761.897411 \n", + " net generation 2980.650272 3071.259358 \n", + " net imports -41.976150 -46.038573 \n", + "Europe distribution losses 292.605807 294.824287 \n", + " exports 480.083713 507.242862 \n", + " imports 494.061577 529.015329 \n", + " installed capacity 1444.290822 1482.995172 \n", + " net consumption 3990.746417 4082.522458 \n", + " net generation 4269.374360 4355.574277 \n", + " net imports 13.977864 21.772468 \n", + "Middle East distribution losses 163.117147 169.089625 \n", + " exports 14.629100 14.358920 \n", + " imports 29.050000 28.806431 \n", + " installed capacity 306.974447 309.632447 \n", + " net consumption 1045.687765 1109.498530 \n", + " net generation 1194.384012 1264.140644 \n", + " net imports 14.420900 14.447511 \n", + "North America distribution losses 270.644224 296.127051 \n", + " exports 87.486172 68.009584 \n", + " imports 81.225548 71.680961 \n", + " installed capacity 1387.359489 1425.152689 \n", + " net consumption 4725.063247 4836.156431 \n", + " net generation 5001.968095 5128.612105 \n", + " net imports -6.260624 3.671377 \n", + "\n", + "[49 rows x 42 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Agrupar por 'Region' y obtener la suma de los valores\n", + "df_grouped = df.groupby('Region').sum(numeric_only=True)\n", + "\n", + "# Eliminar la columna 'Total'\n", + "df_groupedeT = df_grouped.drop(columns=['Total'])\n", + "\n", + "# Transponer el DataFrame para que los años sean las columnas y las regiones sean las filas\n", + "df_transposed = df_groupedeT.transpose()\n", + "\n", + "# Crear una figura más grande\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "\n", + "# Crear un mapa de colores\n", + "cmap = cm.get_cmap('tab10')\n", + "\n", + "# Crear un diccionario para asignar un color único a cada región\n", + "region_colors = {region: cmap(i) for i, region in enumerate(df_grouped.index.unique())}\n", + "\n", + "# Para cada región, trazar los valores a lo largo de los años\n", + "for i, (region, values) in enumerate(df_transposed.iteritems()):\n", + " ax.plot(df_transposed.index, values, label=region, color=region_colors[region])\n", + "\n", + "# Rotar las etiquetas del eje x\n", + "plt.xticks(rotation=45)\n", + "\n", + "# Añadir una leyenda fuera del gráfico\n", + "ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "\n", + "# Mostrar el gráfico\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 632 + }, + "id": "UAOFyFDLLMo-", + "outputId": "bce87c94-9834-48fc-f7f7-cc2e09897650" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":14: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cmap = cm.get_cmap('tab10')\n", + ":20: FutureWarning: iteritems is deprecated and will be removed in a future version. Use .items instead.\n", + " for i, (region, values) in enumerate(df_transposed.iteritems()):\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Guardar el dataframe agrupado\n", + "df_grouped.to_csv('global_electricity_statistics_by_region.csv')" + ], + "metadata": { + "id": "3HyCu76yuvpS" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Supongamos que 'df_grouped' es tu DataFrame y quieres predecir la columna '2021'\n", + "X = df_grouped.drop('2021', axis=1)\n", + "y = df_grouped['2021']\n", + "\n", + "# Dividir los datos en conjuntos de entrenamiento y prueba\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.42, random_state=45) # Puedes cambiar 'test_size' y 'random_state'\n", + "\n", + "# Crear la red LSTM\n", + "model = Sequential()\n", + "model.add(LSTM(150, activation='relu',kernel_regularizer=l2(0.1), input_shape=(X_train.shape[1], 1))) # Puedes cambiar el número de neuronas (50 aquí) y la función de activación ('relu' aquí)\n", + "model.add(Dense(1))\n", + "\n", + "# Compilar el modelo\n", + "model.compile(optimizer='adam', loss=MeanSquaredError()) # Puedes cambiar el optimizador ('adam' aquí) y la función de pérdida (MeanSquaredError aquí)\n", + "\n", + "# Ajustar el modelo a los datos de entrenamiento\n", + "history = model.fit(X_train, y_train, epochs=500, verbose=8) # Puedes cambiar el número de épocas (200 aquí)\n", + "\n", + "for i in range(len(history.history['loss'])):\n", + " print(f\"Epoch {i+1}: Loss = {history.history['loss'][i]}\")\n", + "\n", + "# Graficar la pérdida durante el entrenamiento\n", + "plt.plot(history.history['loss'])\n", + "plt.title('Model loss')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train'], loc='upper right')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "nfJrQD1i4qys", + "outputId": "0109bd7f-ecfe-485d-f633-dccdc80ec34b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/500\n", + "Epoch 2/500\n", + "Epoch 3/500\n", + "Epoch 4/500\n", + "Epoch 5/500\n", + "Epoch 6/500\n", + "Epoch 7/500\n", + "Epoch 8/500\n", + "Epoch 9/500\n", + "Epoch 10/500\n", + "Epoch 11/500\n", + "Epoch 12/500\n", + "Epoch 13/500\n", + "Epoch 14/500\n", + "Epoch 15/500\n", + "Epoch 16/500\n", + "Epoch 17/500\n", + "Epoch 18/500\n", + "Epoch 19/500\n", + "Epoch 20/500\n", + "Epoch 21/500\n", + "Epoch 22/500\n", + "Epoch 23/500\n", + "Epoch 24/500\n", + "Epoch 25/500\n", + "Epoch 26/500\n", + "Epoch 27/500\n", + "Epoch 28/500\n", + "Epoch 29/500\n", + "Epoch 30/500\n", + "Epoch 31/500\n", + "Epoch 32/500\n", + "Epoch 33/500\n", + "Epoch 34/500\n", + "Epoch 35/500\n", + "Epoch 36/500\n", + "Epoch 37/500\n", + "Epoch 38/500\n", + "Epoch 39/500\n", + "Epoch 40/500\n", + "Epoch 41/500\n", + "Epoch 42/500\n", + "Epoch 43/500\n", + "Epoch 44/500\n", + "Epoch 45/500\n", + "Epoch 46/500\n", + "Epoch 47/500\n", + "Epoch 48/500\n", + "Epoch 49/500\n", + "Epoch 50/500\n", + "Epoch 51/500\n", + "Epoch 52/500\n", + "Epoch 53/500\n", + "Epoch 54/500\n", + "Epoch 55/500\n", + "Epoch 56/500\n", + "Epoch 57/500\n", + "Epoch 58/500\n", + "Epoch 59/500\n", + "Epoch 60/500\n", + "Epoch 61/500\n", + "Epoch 62/500\n", + "Epoch 63/500\n", + "Epoch 64/500\n", + "Epoch 65/500\n", + "Epoch 66/500\n", + "Epoch 67/500\n", + "Epoch 68/500\n", + "Epoch 69/500\n", + "Epoch 70/500\n", + "Epoch 71/500\n", + "Epoch 72/500\n", + "Epoch 73/500\n", + "Epoch 74/500\n", + "Epoch 75/500\n", + "Epoch 76/500\n", + "Epoch 77/500\n", + "Epoch 78/500\n", + "Epoch 79/500\n", + "Epoch 80/500\n", + "Epoch 81/500\n", + "Epoch 82/500\n", + "Epoch 83/500\n", + "Epoch 84/500\n", + "Epoch 85/500\n", + "Epoch 86/500\n", + "Epoch 87/500\n", + "Epoch 88/500\n", + "Epoch 89/500\n", + "Epoch 90/500\n", + "Epoch 91/500\n", + "Epoch 92/500\n", + "Epoch 93/500\n", + "Epoch 94/500\n", + "Epoch 95/500\n", + "Epoch 96/500\n", + "Epoch 97/500\n", + "Epoch 98/500\n", + "Epoch 99/500\n", + "Epoch 100/500\n", + "Epoch 101/500\n", + "Epoch 102/500\n", + "Epoch 103/500\n", + "Epoch 104/500\n", + "Epoch 105/500\n", + "Epoch 106/500\n", + "Epoch 107/500\n", + "Epoch 108/500\n", + "Epoch 109/500\n", + "Epoch 110/500\n", + "Epoch 111/500\n", + "Epoch 112/500\n", + "Epoch 113/500\n", + "Epoch 114/500\n", + "Epoch 115/500\n", + "Epoch 116/500\n", + "Epoch 117/500\n", + "Epoch 118/500\n", + "Epoch 119/500\n", + "Epoch 120/500\n", + "Epoch 121/500\n", + "Epoch 122/500\n", + "Epoch 123/500\n", + "Epoch 124/500\n", + "Epoch 125/500\n", + "Epoch 126/500\n", + "Epoch 127/500\n", + "Epoch 128/500\n", + "Epoch 129/500\n", + "Epoch 130/500\n", + "Epoch 131/500\n", + "Epoch 132/500\n", + "Epoch 133/500\n", + "Epoch 134/500\n", + "Epoch 135/500\n", + "Epoch 136/500\n", + "Epoch 137/500\n", + "Epoch 138/500\n", + "Epoch 139/500\n", + "Epoch 140/500\n", + "Epoch 141/500\n", + "Epoch 142/500\n", + "Epoch 143/500\n", + "Epoch 144/500\n", + "Epoch 145/500\n", + "Epoch 146/500\n", + "Epoch 147/500\n", + "Epoch 148/500\n", + "Epoch 149/500\n", + "Epoch 150/500\n", + "Epoch 151/500\n", + "Epoch 152/500\n", + "Epoch 153/500\n", + "Epoch 154/500\n", + "Epoch 155/500\n", + "Epoch 156/500\n", + "Epoch 157/500\n", + "Epoch 158/500\n", + "Epoch 159/500\n", + "Epoch 160/500\n", + "Epoch 161/500\n", + "Epoch 162/500\n", + "Epoch 163/500\n", + "Epoch 164/500\n", + "Epoch 165/500\n", + "Epoch 166/500\n", + "Epoch 167/500\n", + "Epoch 168/500\n", + "Epoch 169/500\n", + "Epoch 170/500\n", + "Epoch 171/500\n", + "Epoch 172/500\n", + "Epoch 173/500\n", + "Epoch 174/500\n", + "Epoch 175/500\n", + "Epoch 176/500\n", + "Epoch 177/500\n", + "Epoch 178/500\n", + "Epoch 179/500\n", + "Epoch 180/500\n", + "Epoch 181/500\n", + "Epoch 182/500\n", + "Epoch 183/500\n", + "Epoch 184/500\n", + "Epoch 185/500\n", + "Epoch 186/500\n", + "Epoch 187/500\n", + "Epoch 188/500\n", + "Epoch 189/500\n", + "Epoch 190/500\n", + "Epoch 191/500\n", + "Epoch 192/500\n", + "Epoch 193/500\n", + "Epoch 194/500\n", + "Epoch 195/500\n", + "Epoch 196/500\n", + "Epoch 197/500\n", + "Epoch 198/500\n", + "Epoch 199/500\n", + "Epoch 200/500\n", + "Epoch 201/500\n", + "Epoch 202/500\n", + "Epoch 203/500\n", + "Epoch 204/500\n", + "Epoch 205/500\n", + "Epoch 206/500\n", + "Epoch 207/500\n", + "Epoch 208/500\n", + "Epoch 209/500\n", + "Epoch 210/500\n", + "Epoch 211/500\n", + "Epoch 212/500\n", + "Epoch 213/500\n", + "Epoch 214/500\n", + "Epoch 215/500\n", + "Epoch 216/500\n", + "Epoch 217/500\n", + "Epoch 218/500\n", + "Epoch 219/500\n", + "Epoch 220/500\n", + "Epoch 221/500\n", + "Epoch 222/500\n", + "Epoch 223/500\n", + "Epoch 224/500\n", + "Epoch 225/500\n", + "Epoch 226/500\n", + "Epoch 227/500\n", + "Epoch 228/500\n", + "Epoch 229/500\n", + "Epoch 230/500\n", + "Epoch 231/500\n", + "Epoch 232/500\n", + "Epoch 233/500\n", + "Epoch 234/500\n", + "Epoch 235/500\n", + "Epoch 236/500\n", + "Epoch 237/500\n", + "Epoch 238/500\n", + "Epoch 239/500\n", + "Epoch 240/500\n", + "Epoch 241/500\n", + "Epoch 242/500\n", + "Epoch 243/500\n", + "Epoch 244/500\n", + "Epoch 245/500\n", + "Epoch 246/500\n", + "Epoch 247/500\n", + "Epoch 248/500\n", + "Epoch 249/500\n", + "Epoch 250/500\n", + "Epoch 251/500\n", + "Epoch 252/500\n", + "Epoch 253/500\n", + "Epoch 254/500\n", + "Epoch 255/500\n", + "Epoch 256/500\n", + "Epoch 257/500\n", + "Epoch 258/500\n", + "Epoch 259/500\n", + "Epoch 260/500\n", + "Epoch 261/500\n", + "Epoch 262/500\n", + "Epoch 263/500\n", + "Epoch 264/500\n", + "Epoch 265/500\n", + "Epoch 266/500\n", + "Epoch 267/500\n", + "Epoch 268/500\n", + "Epoch 269/500\n", + "Epoch 270/500\n", + "Epoch 271/500\n", + "Epoch 272/500\n", + "Epoch 273/500\n", + "Epoch 274/500\n", + "Epoch 275/500\n", + "Epoch 276/500\n", + "Epoch 277/500\n", + "Epoch 278/500\n", + "Epoch 279/500\n", + "Epoch 280/500\n", + "Epoch 281/500\n", + "Epoch 282/500\n", + "Epoch 283/500\n", + "Epoch 284/500\n", + "Epoch 285/500\n", + "Epoch 286/500\n", + "Epoch 287/500\n", + "Epoch 288/500\n", + "Epoch 289/500\n", + "Epoch 290/500\n", + "Epoch 291/500\n", + "Epoch 292/500\n", + "Epoch 293/500\n", + "Epoch 294/500\n", + "Epoch 295/500\n", + "Epoch 296/500\n", + "Epoch 297/500\n", + "Epoch 298/500\n", + "Epoch 299/500\n", + "Epoch 300/500\n", + "Epoch 301/500\n", + "Epoch 302/500\n", + "Epoch 303/500\n", + "Epoch 304/500\n", + "Epoch 305/500\n", + "Epoch 306/500\n", + "Epoch 307/500\n", + "Epoch 308/500\n", + "Epoch 309/500\n", + "Epoch 310/500\n", + "Epoch 311/500\n", + "Epoch 312/500\n", + "Epoch 313/500\n", + "Epoch 314/500\n", + "Epoch 315/500\n", + "Epoch 316/500\n", + "Epoch 317/500\n", + "Epoch 318/500\n", + "Epoch 319/500\n", + "Epoch 320/500\n", + "Epoch 321/500\n", + "Epoch 322/500\n", + "Epoch 323/500\n", + "Epoch 324/500\n", + "Epoch 325/500\n", + "Epoch 326/500\n", + "Epoch 327/500\n", + "Epoch 328/500\n", + "Epoch 329/500\n", + "Epoch 330/500\n", + "Epoch 331/500\n", + "Epoch 332/500\n", + "Epoch 333/500\n", + "Epoch 334/500\n", + "Epoch 335/500\n", + "Epoch 336/500\n", + "Epoch 337/500\n", + "Epoch 338/500\n", + "Epoch 339/500\n", + "Epoch 340/500\n", + "Epoch 341/500\n", + "Epoch 342/500\n", + "Epoch 343/500\n", + "Epoch 344/500\n", + "Epoch 345/500\n", + "Epoch 346/500\n", + "Epoch 347/500\n", + "Epoch 348/500\n", + "Epoch 349/500\n", + "Epoch 350/500\n", + "Epoch 351/500\n", + "Epoch 352/500\n", + "Epoch 353/500\n", + "Epoch 354/500\n", + "Epoch 355/500\n", + "Epoch 356/500\n", + "Epoch 357/500\n", + "Epoch 358/500\n", + "Epoch 359/500\n", + "Epoch 360/500\n", + "Epoch 361/500\n", + "Epoch 362/500\n", + "Epoch 363/500\n", + "Epoch 364/500\n", + "Epoch 365/500\n", + "Epoch 366/500\n", + "Epoch 367/500\n", + "Epoch 368/500\n", + "Epoch 369/500\n", + "Epoch 370/500\n", + "Epoch 371/500\n", + "Epoch 372/500\n", + "Epoch 373/500\n", + "Epoch 374/500\n", + "Epoch 375/500\n", + "Epoch 376/500\n", + "Epoch 377/500\n", + "Epoch 378/500\n", + "Epoch 379/500\n", + "Epoch 380/500\n", + "Epoch 381/500\n", + "Epoch 382/500\n", + "Epoch 383/500\n", + "Epoch 384/500\n", + "Epoch 385/500\n", + "Epoch 386/500\n", + "Epoch 387/500\n", + "Epoch 388/500\n", + "Epoch 389/500\n", + "Epoch 390/500\n", + "Epoch 391/500\n", + "Epoch 392/500\n", + "Epoch 393/500\n", + "Epoch 394/500\n", + "Epoch 395/500\n", + "Epoch 396/500\n", + "Epoch 397/500\n", + "Epoch 398/500\n", + "Epoch 399/500\n", + "Epoch 400/500\n", + "Epoch 401/500\n", + "Epoch 402/500\n", + "Epoch 403/500\n", + "Epoch 404/500\n", + "Epoch 405/500\n", + "Epoch 406/500\n", + "Epoch 407/500\n", + "Epoch 408/500\n", + "Epoch 409/500\n", + "Epoch 410/500\n", + "Epoch 411/500\n", + "Epoch 412/500\n", + "Epoch 413/500\n", + "Epoch 414/500\n", + "Epoch 415/500\n", + "Epoch 416/500\n", + "Epoch 417/500\n", + "Epoch 418/500\n", + "Epoch 419/500\n", + "Epoch 420/500\n", + "Epoch 421/500\n", + "Epoch 422/500\n", + "Epoch 423/500\n", + "Epoch 424/500\n", + "Epoch 425/500\n", + "Epoch 426/500\n", + "Epoch 427/500\n", + "Epoch 428/500\n", + "Epoch 429/500\n", + "Epoch 430/500\n", + "Epoch 431/500\n", + "Epoch 432/500\n", + "Epoch 433/500\n", + "Epoch 434/500\n", + "Epoch 435/500\n", + "Epoch 436/500\n", + "Epoch 437/500\n", + "Epoch 438/500\n", + "Epoch 439/500\n", + "Epoch 440/500\n", + "Epoch 441/500\n", + "Epoch 442/500\n", + "Epoch 443/500\n", + "Epoch 444/500\n", + "Epoch 445/500\n", + "Epoch 446/500\n", + "Epoch 447/500\n", + "Epoch 448/500\n", + "Epoch 449/500\n", + "Epoch 450/500\n", + "Epoch 451/500\n", + "Epoch 452/500\n", + "Epoch 453/500\n", + "Epoch 454/500\n", + "Epoch 455/500\n", + "Epoch 456/500\n", + "Epoch 457/500\n", + "Epoch 458/500\n", + "Epoch 459/500\n", + "Epoch 460/500\n", + "Epoch 461/500\n", + "Epoch 462/500\n", + "Epoch 463/500\n", + "Epoch 464/500\n", + "Epoch 465/500\n", + "Epoch 466/500\n", + "Epoch 467/500\n", + "Epoch 468/500\n", + "Epoch 469/500\n", + "Epoch 470/500\n", + "Epoch 471/500\n", + "Epoch 472/500\n", + "Epoch 473/500\n", + "Epoch 474/500\n", + "Epoch 475/500\n", + "Epoch 476/500\n", + "Epoch 477/500\n", + "Epoch 478/500\n", + "Epoch 479/500\n", + "Epoch 480/500\n", + "Epoch 481/500\n", + "Epoch 482/500\n", + "Epoch 483/500\n", + "Epoch 484/500\n", + "Epoch 485/500\n", + "Epoch 486/500\n", + "Epoch 487/500\n", + "Epoch 488/500\n", + "Epoch 489/500\n", + "Epoch 490/500\n", + "Epoch 491/500\n", + "Epoch 492/500\n", + "Epoch 493/500\n", + "Epoch 494/500\n", + "Epoch 495/500\n", + "Epoch 496/500\n", + "Epoch 497/500\n", + "Epoch 498/500\n", + "Epoch 499/500\n", + "Epoch 500/500\n", + "Epoch 1: Loss = 102832000.0\n", + "Epoch 2: Loss = 28581594.0\n", + "Epoch 3: Loss = 38466356.0\n", + "Epoch 4: Loss = 11858119.0\n", + "Epoch 5: Loss = 28559066.0\n", + "Epoch 6: Loss = 8444905.0\n", + "Epoch 7: Loss = 20377050.0\n", + "Epoch 8: Loss = 9812851.0\n", + "Epoch 9: Loss = 29177000.0\n", + "Epoch 10: Loss = 8028653.5\n", + "Epoch 11: Loss = 13237634.0\n", + "Epoch 12: Loss = 22082724.0\n", + "Epoch 13: Loss = 124183480.0\n", + "Epoch 14: Loss = 139594432.0\n", + "Epoch 15: Loss = 28150334.0\n", + "Epoch 16: Loss = 62225272.0\n", + "Epoch 17: Loss = 58199332.0\n", + "Epoch 18: Loss = 65592624.0\n", + "Epoch 19: Loss = 43185248.0\n", + "Epoch 20: Loss = 1464006.5\n", + "Epoch 21: Loss = 48347900.0\n", + "Epoch 22: Loss = 64234732.0\n", + "Epoch 23: Loss = 52944504.0\n", + "Epoch 24: Loss = 28143280.0\n", + "Epoch 25: Loss = 107148008.0\n", + "Epoch 26: Loss = 246287232.0\n", + "Epoch 27: Loss = 362880256.0\n", + "Epoch 28: Loss = 94853680.0\n", + "Epoch 29: Loss = 360159104.0\n", + "Epoch 30: Loss = 323046208.0\n", + "Epoch 31: Loss = 451675040.0\n", + "Epoch 32: Loss = 464746720.0\n", + "Epoch 33: Loss = 181614256.0\n", + "Epoch 34: Loss = 1016295040.0\n", + "Epoch 35: Loss = 48944064.0\n", + "Epoch 36: Loss = 537670912.0\n", + "Epoch 37: Loss = 183015648.0\n", + "Epoch 38: Loss = 36896788.0\n", + "Epoch 39: Loss = 208437264.0\n", + "Epoch 40: Loss = 404825856.0\n", + "Epoch 41: Loss = 145038928.0\n", + "Epoch 42: Loss = 90906088.0\n", + "Epoch 43: Loss = 317433088.0\n", + "Epoch 44: Loss = 207606352.0\n", + "Epoch 45: Loss = 67569608.0\n", + "Epoch 46: Loss = 248813776.0\n", + "Epoch 47: Loss = 28989996.0\n", + "Epoch 48: Loss = 152745104.0\n", + "Epoch 49: Loss = 378671104.0\n", + "Epoch 50: Loss = 67719336.0\n", + "Epoch 51: Loss = 58827168.0\n", + "Epoch 52: Loss = 44643036.0\n", + "Epoch 53: Loss = 17336574.0\n", + "Epoch 54: Loss = 44304728.0\n", + "Epoch 55: Loss = 62798080.0\n", + "Epoch 56: Loss = 16528823.0\n", + "Epoch 57: Loss = 7602400.0\n", + "Epoch 58: Loss = 27509160.0\n", + "Epoch 59: Loss = 45870420.0\n", + "Epoch 60: Loss = 3016445.25\n", + "Epoch 61: Loss = 37617712.0\n", + "Epoch 62: Loss = 539786.4375\n", + "Epoch 63: Loss = 6469420.5\n", + "Epoch 64: Loss = 5883493.0\n", + "Epoch 65: Loss = 9921310.0\n", + "Epoch 66: Loss = 40837956.0\n", + "Epoch 67: Loss = 28660466.0\n", + "Epoch 68: Loss = 25806316.0\n", + "Epoch 69: Loss = 1407943.875\n", + "Epoch 70: Loss = 26945542.0\n", + "Epoch 71: Loss = 65294368.0\n", + "Epoch 72: Loss = 41522256.0\n", + "Epoch 73: Loss = 50687172.0\n", + "Epoch 74: Loss = 10233583.0\n", + "Epoch 75: Loss = 50585760.0\n", + "Epoch 76: Loss = 5199648.5\n", + "Epoch 77: Loss = 28636404.0\n", + "Epoch 78: Loss = 5874281.5\n", + "Epoch 79: Loss = 20629022.0\n", + "Epoch 80: Loss = 13411407.0\n", + "Epoch 81: Loss = 6462674.0\n", + "Epoch 82: Loss = 36192340.0\n", + "Epoch 83: Loss = 39421420.0\n", + "Epoch 84: Loss = 11029152.0\n", + "Epoch 85: Loss = 13814310.0\n", + "Epoch 86: Loss = 2058303.625\n", + "Epoch 87: Loss = 21444492.0\n", + "Epoch 88: Loss = 60458524.0\n", + "Epoch 89: Loss = 946386.125\n", + "Epoch 90: Loss = 727960.6875\n", + "Epoch 91: Loss = 4561388.0\n", + "Epoch 92: Loss = 11874139.0\n", + "Epoch 93: Loss = 32916434.0\n", + "Epoch 94: Loss = 58273708.0\n", + "Epoch 95: Loss = 170226112.0\n", + "Epoch 96: Loss = 25728500.0\n", + "Epoch 97: Loss = 14353096.0\n", + "Epoch 98: Loss = 29355582.0\n", + "Epoch 99: Loss = 9882171.0\n", + "Epoch 100: Loss = 21905370.0\n", + "Epoch 101: Loss = 9851736.0\n", + "Epoch 102: Loss = 41945844.0\n", + "Epoch 103: Loss = 7750540.0\n", + "Epoch 104: Loss = 14483188.0\n", + "Epoch 105: Loss = 24603462.0\n", + "Epoch 106: Loss = 10265312.0\n", + "Epoch 107: Loss = 14629091.0\n", + "Epoch 108: Loss = 13545599.0\n", + "Epoch 109: Loss = 89341056.0\n", + "Epoch 110: Loss = 131173144.0\n", + "Epoch 111: Loss = 124960984.0\n", + "Epoch 112: Loss = 10596631.0\n", + "Epoch 113: Loss = 31328620.0\n", + "Epoch 114: Loss = 23911078.0\n", + "Epoch 115: Loss = 508030592.0\n", + "Epoch 116: Loss = 4951201.5\n", + "Epoch 117: Loss = 161397488.0\n", + "Epoch 118: Loss = 165640304.0\n", + "Epoch 119: Loss = 1637081600.0\n", + "Epoch 120: Loss = 4162158592.0\n", + "Epoch 121: Loss = 103552992.0\n", + "Epoch 122: Loss = 1941750784.0\n", + "Epoch 123: Loss = 939500736.0\n", + "Epoch 124: Loss = 2160167936.0\n", + "Epoch 125: Loss = 504996992.0\n", + "Epoch 126: Loss = 1218859776.0\n", + "Epoch 127: Loss = 188687232.0\n", + "Epoch 128: Loss = 1326811264.0\n", + "Epoch 129: Loss = 546000000.0\n", + "Epoch 130: Loss = 652817216.0\n", + "Epoch 131: Loss = 798477184.0\n", + "Epoch 132: Loss = 385249184.0\n", + "Epoch 133: Loss = 293815104.0\n", + "Epoch 134: Loss = 876512448.0\n", + "Epoch 135: Loss = 2855535104.0\n", + "Epoch 136: Loss = 554518656.0\n", + "Epoch 137: Loss = 176193920.0\n", + "Epoch 138: Loss = 455097728.0\n", + "Epoch 139: Loss = 38599364.0\n", + "Epoch 140: Loss = 24551452.0\n", + "Epoch 141: Loss = 110513104.0\n", + "Epoch 142: Loss = 110353048.0\n", + "Epoch 143: Loss = 460856768.0\n", + "Epoch 144: Loss = 292320032.0\n", + "Epoch 145: Loss = 447717472.0\n", + "Epoch 146: Loss = 517735072.0\n", + "Epoch 147: Loss = 230246288.0\n", + "Epoch 148: Loss = 74563280.0\n", + "Epoch 149: Loss = 223070800.0\n", + "Epoch 150: Loss = 143589808.0\n", + "Epoch 151: Loss = 138108752.0\n", + "Epoch 152: Loss = 24285336.0\n", + "Epoch 153: Loss = 109380440.0\n", + "Epoch 154: Loss = 59204900.0\n", + "Epoch 155: Loss = 45474664.0\n", + "Epoch 156: Loss = 21519894.0\n", + "Epoch 157: Loss = 9749383.0\n", + "Epoch 158: Loss = 98707960.0\n", + "Epoch 159: Loss = 38516540.0\n", + "Epoch 160: Loss = 117907128.0\n", + "Epoch 161: Loss = 18668372.0\n", + "Epoch 162: Loss = 23324586.0\n", + "Epoch 163: Loss = 16186311.0\n", + "Epoch 164: Loss = 132299872.0\n", + "Epoch 165: Loss = 4137220.5\n", + "Epoch 166: Loss = 32669248.0\n", + "Epoch 167: Loss = 9175897.0\n", + "Epoch 168: Loss = 34163052.0\n", + "Epoch 169: Loss = 23097474.0\n", + "Epoch 170: Loss = 51617992.0\n", + "Epoch 171: Loss = 11813448.0\n", + "Epoch 172: Loss = 41611636.0\n", + "Epoch 173: Loss = 30317978.0\n", + "Epoch 174: Loss = 17387690.0\n", + "Epoch 175: Loss = 3900669.75\n", + "Epoch 176: Loss = 3561742.25\n", + "Epoch 177: Loss = 5969533.0\n", + "Epoch 178: Loss = 117700544.0\n", + "Epoch 179: Loss = 5149296.0\n", + "Epoch 180: Loss = 9947249.0\n", + "Epoch 181: Loss = 46528292.0\n", + "Epoch 182: Loss = 39733124.0\n", + "Epoch 183: Loss = 19441794.0\n", + "Epoch 184: Loss = 8988196.0\n", + "Epoch 185: Loss = 18157304.0\n", + "Epoch 186: Loss = 7252877.5\n", + "Epoch 187: Loss = 41503044.0\n", + "Epoch 188: Loss = 26564140.0\n", + "Epoch 189: Loss = 33145384.0\n", + "Epoch 190: Loss = 24849360.0\n", + "Epoch 191: Loss = 19266568.0\n", + "Epoch 192: Loss = 18558142.0\n", + "Epoch 193: Loss = 68987280.0\n", + "Epoch 194: Loss = 41996672.0\n", + "Epoch 195: Loss = 93667328.0\n", + "Epoch 196: Loss = 893685.625\n", + "Epoch 197: Loss = 67667520.0\n", + "Epoch 198: Loss = 66997572.0\n", + "Epoch 199: Loss = 71625176.0\n", + "Epoch 200: Loss = 95644632.0\n", + "Epoch 201: Loss = 50191872.0\n", + "Epoch 202: Loss = 34075780.0\n", + "Epoch 203: Loss = 73167832.0\n", + "Epoch 204: Loss = 27575636.0\n", + "Epoch 205: Loss = 35330876.0\n", + "Epoch 206: Loss = 22916410.0\n", + "Epoch 207: Loss = 24282562.0\n", + "Epoch 208: Loss = 49295748.0\n", + "Epoch 209: Loss = 47714040.0\n", + "Epoch 210: Loss = 45224276.0\n", + "Epoch 211: Loss = 101702608.0\n", + "Epoch 212: Loss = 60757964.0\n", + "Epoch 213: Loss = 99960848.0\n", + "Epoch 214: Loss = 14283336.0\n", + "Epoch 215: Loss = 16283412.0\n", + "Epoch 216: Loss = 9840116.0\n", + "Epoch 217: Loss = 14328882.0\n", + "Epoch 218: Loss = 118184336.0\n", + "Epoch 219: Loss = 84319664.0\n", + "Epoch 220: Loss = 45551916.0\n", + "Epoch 221: Loss = 235838464.0\n", + "Epoch 222: Loss = 172541184.0\n", + "Epoch 223: Loss = 7404227.5\n", + "Epoch 224: Loss = 6032476.0\n", + "Epoch 225: Loss = 33620356.0\n", + "Epoch 226: Loss = 58161032.0\n", + "Epoch 227: Loss = 6120454.0\n", + "Epoch 228: Loss = 2004220.875\n", + "Epoch 229: Loss = 657080.8125\n", + "Epoch 230: Loss = 5642705.0\n", + "Epoch 231: Loss = 4763228.0\n", + "Epoch 232: Loss = 31776292.0\n", + "Epoch 233: Loss = 65007488.0\n", + "Epoch 234: Loss = 77484584.0\n", + "Epoch 235: Loss = 3585655.25\n", + "Epoch 236: Loss = 17067364.0\n", + "Epoch 237: Loss = 9166650.0\n", + "Epoch 238: Loss = 8339791.0\n", + "Epoch 239: Loss = 14555955.0\n", + "Epoch 240: Loss = 40074312.0\n", + "Epoch 241: Loss = 23534336.0\n", + "Epoch 242: Loss = 4477015.0\n", + "Epoch 243: Loss = 31477884.0\n", + "Epoch 244: Loss = 10155824.0\n", + "Epoch 245: Loss = 11160846.0\n", + "Epoch 246: Loss = 13042034.0\n", + "Epoch 247: Loss = 2841601.75\n", + "Epoch 248: Loss = 43013616.0\n", + "Epoch 249: Loss = 7460937.0\n", + "Epoch 250: Loss = 30927802.0\n", + "Epoch 251: Loss = 12506443.0\n", + "Epoch 252: Loss = 15761238.0\n", + "Epoch 253: Loss = 9420556.0\n", + "Epoch 254: Loss = 10614524.0\n", + "Epoch 255: Loss = 41148184.0\n", + "Epoch 256: Loss = 9866906.0\n", + "Epoch 257: Loss = 6530872.0\n", + "Epoch 258: Loss = 5475881.5\n", + "Epoch 259: Loss = 4417406.5\n", + "Epoch 260: Loss = 8015231.5\n", + "Epoch 261: Loss = 19830106.0\n", + "Epoch 262: Loss = 34233740.0\n", + "Epoch 263: Loss = 33586196.0\n", + "Epoch 264: Loss = 56163200.0\n", + "Epoch 265: Loss = 72808664.0\n", + "Epoch 266: Loss = 37919452.0\n", + "Epoch 267: Loss = 90733528.0\n", + "Epoch 268: Loss = 3429886.25\n", + "Epoch 269: Loss = 44704472.0\n", + "Epoch 270: Loss = 15747013.0\n", + "Epoch 271: Loss = 28768746.0\n", + "Epoch 272: Loss = 32492992.0\n", + "Epoch 273: Loss = 27031230.0\n", + "Epoch 274: Loss = 21846418.0\n", + "Epoch 275: Loss = 4649849.0\n", + "Epoch 276: Loss = 7733873.5\n", + "Epoch 277: Loss = 13470125.0\n", + "Epoch 278: Loss = 10613280.0\n", + "Epoch 279: Loss = 36575448.0\n", + "Epoch 280: Loss = 19551678.0\n", + "Epoch 281: Loss = 17854220.0\n", + "Epoch 282: Loss = 15834977.0\n", + "Epoch 283: Loss = 32908400.0\n", + "Epoch 284: Loss = 13467092.0\n", + "Epoch 285: Loss = 14299426.0\n", + "Epoch 286: Loss = 10788824.0\n", + "Epoch 287: Loss = 10841810.0\n", + "Epoch 288: Loss = 58854748.0\n", + "Epoch 289: Loss = 60941764.0\n", + "Epoch 290: Loss = 61065320.0\n", + "Epoch 291: Loss = 33045146.0\n", + "Epoch 292: Loss = 32921238.0\n", + "Epoch 293: Loss = 34047964.0\n", + "Epoch 294: Loss = 35546632.0\n", + "Epoch 295: Loss = 33580868.0\n", + "Epoch 296: Loss = 31460306.0\n", + "Epoch 297: Loss = 48280976.0\n", + "Epoch 298: Loss = 12115497.0\n", + "Epoch 299: Loss = 7208291.5\n", + "Epoch 300: Loss = 1766983.0\n", + "Epoch 301: Loss = 6763603.0\n", + "Epoch 302: Loss = 11206675.0\n", + "Epoch 303: Loss = 9650744.0\n", + "Epoch 304: Loss = 25572510.0\n", + "Epoch 305: Loss = 9444142.0\n", + "Epoch 306: Loss = 11093033.0\n", + "Epoch 307: Loss = 10070954.0\n", + "Epoch 308: Loss = 59487976.0\n", + "Epoch 309: Loss = 41377592.0\n", + "Epoch 310: Loss = 27515682.0\n", + "Epoch 311: Loss = 63783832.0\n", + "Epoch 312: Loss = 19595784.0\n", + "Epoch 313: Loss = 4278891.5\n", + "Epoch 314: Loss = 7336858.5\n", + "Epoch 315: Loss = 124383816.0\n", + "Epoch 316: Loss = 21640474.0\n", + "Epoch 317: Loss = 176682096.0\n", + "Epoch 318: Loss = 169359104.0\n", + "Epoch 319: Loss = 217748176.0\n", + "Epoch 320: Loss = 213649504.0\n", + "Epoch 321: Loss = 11420248.0\n", + "Epoch 322: Loss = 20710246.0\n", + "Epoch 323: Loss = 28334560.0\n", + "Epoch 324: Loss = 31568188.0\n", + "Epoch 325: Loss = 82415568.0\n", + "Epoch 326: Loss = 105856440.0\n", + "Epoch 327: Loss = 43879480.0\n", + "Epoch 328: Loss = 27950824.0\n", + "Epoch 329: Loss = 10049555.0\n", + "Epoch 330: Loss = 17207532.0\n", + "Epoch 331: Loss = 15334850.0\n", + "Epoch 332: Loss = 75185920.0\n", + "Epoch 333: Loss = 2053800.125\n", + "Epoch 334: Loss = 3618750.25\n", + "Epoch 335: Loss = 27956748.0\n", + "Epoch 336: Loss = 12379736.0\n", + "Epoch 337: Loss = 12098196.0\n", + "Epoch 338: Loss = 7388391.5\n", + "Epoch 339: Loss = 6162855.5\n", + "Epoch 340: Loss = 5634845.0\n", + "Epoch 341: Loss = 3414655.0\n", + "Epoch 342: Loss = 2931523.0\n", + "Epoch 343: Loss = 17941050.0\n", + "Epoch 344: Loss = 25871864.0\n", + "Epoch 345: Loss = 37890684.0\n", + "Epoch 346: Loss = 13986114.0\n", + "Epoch 347: Loss = 13123363.0\n", + "Epoch 348: Loss = 11382073.0\n", + "Epoch 349: Loss = 31477172.0\n", + "Epoch 350: Loss = 7196466.0\n", + "Epoch 351: Loss = 18594956.0\n", + "Epoch 352: Loss = 23716518.0\n", + "Epoch 353: Loss = 16498504.0\n", + "Epoch 354: Loss = 30585646.0\n", + "Epoch 355: Loss = 37859912.0\n", + "Epoch 356: Loss = 8174270.0\n", + "Epoch 357: Loss = 18000748.0\n", + "Epoch 358: Loss = 6179393.5\n", + "Epoch 359: Loss = 9815300.0\n", + "Epoch 360: Loss = 13170956.0\n", + "Epoch 361: Loss = 34797720.0\n", + "Epoch 362: Loss = 14839481.0\n", + "Epoch 363: Loss = 11062543.0\n", + "Epoch 364: Loss = 1226162.125\n", + "Epoch 365: Loss = 1730673.0\n", + "Epoch 366: Loss = 2638962.25\n", + "Epoch 367: Loss = 3740686.5\n", + "Epoch 368: Loss = 2295863.0\n", + "Epoch 369: Loss = 7822918.5\n", + "Epoch 370: Loss = 6592415.5\n", + "Epoch 371: Loss = 5863917.0\n", + "Epoch 372: Loss = 3220520.25\n", + "Epoch 373: Loss = 3901127.75\n", + "Epoch 374: Loss = 7227896.5\n", + "Epoch 375: Loss = 4244708.0\n", + "Epoch 376: Loss = 1960855.5\n", + "Epoch 377: Loss = 44605084.0\n", + "Epoch 378: Loss = 37953028.0\n", + "Epoch 379: Loss = 38479128.0\n", + "Epoch 380: Loss = 1646036.25\n", + "Epoch 381: Loss = 1956850.375\n", + "Epoch 382: Loss = 1022255.125\n", + "Epoch 383: Loss = 17024442.0\n", + "Epoch 384: Loss = 18889852.0\n", + "Epoch 385: Loss = 13461972.0\n", + "Epoch 386: Loss = 82066912.0\n", + "Epoch 387: Loss = 6709552.0\n", + "Epoch 388: Loss = 23933834.0\n", + "Epoch 389: Loss = 14408879.0\n", + "Epoch 390: Loss = 21427828.0\n", + "Epoch 391: Loss = 40592940.0\n", + "Epoch 392: Loss = 27474848.0\n", + "Epoch 393: Loss = 18541048.0\n", + "Epoch 394: Loss = 6633277.5\n", + "Epoch 395: Loss = 7380019.5\n", + "Epoch 396: Loss = 12679058.0\n", + "Epoch 397: Loss = 25765614.0\n", + "Epoch 398: Loss = 24309706.0\n", + "Epoch 399: Loss = 8185821.0\n", + "Epoch 400: Loss = 13782796.0\n", + "Epoch 401: Loss = 20877706.0\n", + "Epoch 402: Loss = 10918741.0\n", + "Epoch 403: Loss = 12428180.0\n", + "Epoch 404: Loss = 12314490.0\n", + "Epoch 405: Loss = 9034409.0\n", + "Epoch 406: Loss = 11179762.0\n", + "Epoch 407: Loss = 1332685.75\n", + "Epoch 408: Loss = 8724377.0\n", + "Epoch 409: Loss = 4092440.5\n", + "Epoch 410: Loss = 7746171.0\n", + "Epoch 411: Loss = 3990658.0\n", + "Epoch 412: Loss = 9052532.0\n", + "Epoch 413: Loss = 5382648.5\n", + "Epoch 414: Loss = 6087593.0\n", + "Epoch 415: Loss = 10909400.0\n", + "Epoch 416: Loss = 13880742.0\n", + "Epoch 417: Loss = 10404677.0\n", + "Epoch 418: Loss = 22503978.0\n", + "Epoch 419: Loss = 30100348.0\n", + "Epoch 420: Loss = 4746040.5\n", + "Epoch 421: Loss = 5709309.0\n", + "Epoch 422: Loss = 5332604.0\n", + "Epoch 423: Loss = 6832333.0\n", + "Epoch 424: Loss = 7631865.0\n", + "Epoch 425: Loss = 3771762.75\n", + "Epoch 426: Loss = 18801092.0\n", + "Epoch 427: Loss = 55575752.0\n", + "Epoch 428: Loss = 97920264.0\n", + "Epoch 429: Loss = 61876276.0\n", + "Epoch 430: Loss = 29736144.0\n", + "Epoch 431: Loss = 40055184.0\n", + "Epoch 432: Loss = 28055472.0\n", + "Epoch 433: Loss = 12496342.0\n", + "Epoch 434: Loss = 18982382.0\n", + "Epoch 435: Loss = 10846186.0\n", + "Epoch 436: Loss = 14282407.0\n", + "Epoch 437: Loss = 37909076.0\n", + "Epoch 438: Loss = 20137116.0\n", + "Epoch 439: Loss = 9262172.0\n", + "Epoch 440: Loss = 3640067.0\n", + "Epoch 441: Loss = 10816868.0\n", + "Epoch 442: Loss = 18398186.0\n", + "Epoch 443: Loss = 3821556.5\n", + "Epoch 444: Loss = 12209163.0\n", + "Epoch 445: Loss = 9349880.0\n", + "Epoch 446: Loss = 5125670.5\n", + "Epoch 447: Loss = 37675156.0\n", + "Epoch 448: Loss = 18691106.0\n", + "Epoch 449: Loss = 9890120.0\n", + "Epoch 450: Loss = 8104408.0\n", + "Epoch 451: Loss = 10571805.0\n", + "Epoch 452: Loss = 4060703.75\n", + "Epoch 453: Loss = 6327300.0\n", + "Epoch 454: Loss = 5932917.0\n", + "Epoch 455: Loss = 11192619.0\n", + "Epoch 456: Loss = 14876193.0\n", + "Epoch 457: Loss = 10281366.0\n", + "Epoch 458: Loss = 5453881.0\n", + "Epoch 459: Loss = 13143906.0\n", + "Epoch 460: Loss = 20262672.0\n", + "Epoch 461: Loss = 7708167.0\n", + "Epoch 462: Loss = 17447026.0\n", + "Epoch 463: Loss = 1170099.125\n", + "Epoch 464: Loss = 14493766.0\n", + "Epoch 465: Loss = 3540527.75\n", + "Epoch 466: Loss = 4028082.0\n", + "Epoch 467: Loss = 8608558.0\n", + "Epoch 468: Loss = 10065666.0\n", + "Epoch 469: Loss = 8405355.0\n", + "Epoch 470: Loss = 12151652.0\n", + "Epoch 471: Loss = 16991180.0\n", + "Epoch 472: Loss = 9371812.0\n", + "Epoch 473: Loss = 19665128.0\n", + "Epoch 474: Loss = 5872520.0\n", + "Epoch 475: Loss = 13190856.0\n", + "Epoch 476: Loss = 7332938.0\n", + "Epoch 477: Loss = 6324096.5\n", + "Epoch 478: Loss = 6623219.0\n", + "Epoch 479: Loss = 6425566.0\n", + "Epoch 480: Loss = 9061003.0\n", + "Epoch 481: Loss = 3552659.5\n", + "Epoch 482: Loss = 4545801.5\n", + "Epoch 483: Loss = 2553218.75\n", + "Epoch 484: Loss = 821733.375\n", + "Epoch 485: Loss = 8598632.0\n", + "Epoch 486: Loss = 8665224.0\n", + "Epoch 487: Loss = 4746739.5\n", + "Epoch 488: Loss = 1781845.375\n", + "Epoch 489: Loss = 1323368.0\n", + "Epoch 490: Loss = 829634.375\n", + "Epoch 491: Loss = 1419806.125\n", + "Epoch 492: Loss = 20782330.0\n", + "Epoch 493: Loss = 11469326.0\n", + "Epoch 494: Loss = 14554182.0\n", + "Epoch 495: Loss = 12838631.0\n", + "Epoch 496: Loss = 11325082.0\n", + "Epoch 497: Loss = 13525978.0\n", + "Epoch 498: Loss = 27821814.0\n", + "Epoch 499: Loss = 9435000.0\n", + "Epoch 500: Loss = 20394206.0\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "loss_values = history.history['loss']\n", + "print(loss_values)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "My8by2_2DI_X", + "outputId": "f696d0f4-2591-4271-e7ce-719f7e48a721" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[13978865.0, 13661791.0, 13745915.0, 14039383.0, 14036662.0, 13992389.0, 14043848.0, 13798370.0, 13376729.0, 13109994.0, 13637852.0, 13281099.0, 12732879.0, 11649245.0, 12006907.0, 10077946.0, 6745423.5, 8057920.0, 7560234.0, 10751578.0, 7243948.5, 7888572.0, 8588810.0, 8419626.0, 9516969.0, 7365000.0, 7175318.0, 9339095.0, 8668128.0, 7203061.5, 8713561.0, 9448430.0, 9513725.0, 6670869.5, 10145086.0, 6996037.5, 8719094.0, 9057428.0, 7909514.0, 10276208.0, 9739874.0, 10149930.0, 8913145.0, 10026408.0, 8749553.0, 9029780.0, 9004435.0, 9100776.0, 10185200.0, 10122906.0, 8880246.0, 8821126.0, 8521718.0, 8372325.5, 8121804.5, 8525467.0, 8518840.0, 8578520.0, 8065098.5, 7953030.5, 7886762.5, 7736829.5, 7885539.5, 8038061.0, 7792236.5, 7960796.0, 7895030.0, 7796317.5, 7477304.0, 8136023.0, 8435440.0, 8509963.0, 9771523.0, 10068050.0, 10016277.0, 10018746.0, 9927969.0, 9876155.0, 9829617.0, 9834552.0, 9743723.0, 9708187.0, 9673909.0, 9640575.0, 9607001.0, 9573277.0, 9538612.0, 9519751.0, 9463637.0, 9405359.0, 9351933.0, 9333471.0, 9251945.0, 9175816.0, 9133273.0, 9092211.0, 9026029.0, 8972206.0, 8917377.0, 8855146.0, 8817475.0, 8767893.0, 8704868.0, 8672368.0, 8623803.0, 8594071.0, 8551559.0, 8497334.0, 8350219.5, 8291855.0, 8181426.0, 8152970.0, 9679971.0, 9600615.0, 9520171.0, 8666106.0, 7868696.0, 8550929.0, 8475719.0, 8423616.0, 7516146.0, 8298322.0, 8117534.5, 8174611.5, 8131674.5, 8084244.5, 8049593.5, 7999823.5, 7967148.5, 7924028.0, 7876899.5, 7842282.0, 7801153.5, 7763562.5, 7723649.0, 7688537.5, 7653228.5, 7620349.5, 7590787.5, 7560942.0, 7530991.0, 7501377.0, 7471123.0, 7446005.5, 7411576.0, 7382610.0, 7355635.5, 7322470.5, 7322630.5, 7260817.0, 7230733.0, 7197820.0, 7166958.0, 7129025.5, 7092078.0, 7065559.0, 7030418.0, 6997822.5, 7857188.0, 6936069.0, 6907201.0, 6877264.5, 6851487.0, 6826318.0, 6801646.5, 6775227.5, 6749586.0, 6723898.5, 6692865.5, 6664151.0, 6631443.0, 6594502.5, 6556715.5, 6509205.5, 6480022.5, 6434694.0, 6394368.0, 6357692.5, 6316935.5, 6289429.5, 6248276.0, 6222152.5, 6186493.0, 6155007.5, 6119027.5, 6094129.0, 6062169.5, 6032828.5, 6004689.5, 5974583.5, 5951585.0, 5917849.5, 5894174.0, 5858341.0, 5828297.0, 5789473.5, 5757150.5, 5716894.5, 5683586.5, 5637409.5]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Escalar los datos entre 0 y 1scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_X = MinMaxScaler(feature_range=(0, 1))\n", + "scaler_y = MinMaxScaler(feature_range=(0, 1))\n", + "train_X_scaled = scaler_X.fit_transform(train_X)\n", + "test_X_scaled = scaler_X.transform(test_X)\n", + "train_y_scaled = scaler_y.fit_transform(train_y.values.reshape(-1, 1))\n", + "test_y_scaled = scaler_y.transform(test_y.values.reshape(-1, 1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + }, + "id": "ji9qjt_SCrvY", + "outputId": "7610dff1-9cc5-4bba-92ea-a0b93fdf3a09" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mscaler_X\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mscaler_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_range\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mtrain_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mtest_X_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_X\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mtrain_y_scaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscaler_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/_set_output.py\u001b[0m in \u001b[0;36mwrapped\u001b[0;34m(self, X, *args, **kwargs)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mdata_to_wrap\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_to_wrap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[0;31m# only wrap the first output for cross decomposition\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 876\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0my\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 877\u001b[0m \u001b[0;31m# fit method of arity 1 (unsupervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 878\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 879\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 880\u001b[0m \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 425\u001b[0m \u001b[0;31m# Reset internal state before fitting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 426\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 427\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 428\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpartial_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py\u001b[0m in \u001b[0;36mpartial_fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 464\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 465\u001b[0m \u001b[0mfirst_pass\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"n_samples_seen_\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 466\u001b[0;31m X = self._validate_data(\n\u001b[0m\u001b[1;32m 467\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[0mreset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfirst_pass\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36m_validate_data\u001b[0;34m(self, X, y, reset, validate_separately, **check_params)\u001b[0m\n\u001b[1;32m 563\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Validation should be done on X, y or both.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 564\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 565\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"X\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mcheck_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 566\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 567\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_array\u001b[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator, input_name)\u001b[0m\n\u001b[1;32m 776\u001b[0m )\n\u001b[1;32m 777\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtype_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdtype_iter\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 778\u001b[0;31m \u001b[0mdtype_orig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mdtypes_orig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 779\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 780\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"iloc\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"dtype\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numpy/core/overrides.py\u001b[0m in \u001b[0;36mresult_type\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: at least one array or dtype is required" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Definir el modelo LSTM\n", + "model_lstm = Sequential()\n", + "model_lstm.add(LSTM(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "model_lstm.add(Dense(1))\n", + "model_lstm.compile(optimizer='adam', loss='mse')\n", + "\n", + "#/ Definir el modelo GRU\n", + "#model_gru = Sequential()\n", + "#model_gru.add(GRU(50, activation='relu', input_shape=(train_scaled.shape[1], 1)))\n", + "#model_gru.add(Dense(1))\n", + "#model_gru.compile(optimizer='adam', loss='mse')\n", + "#" + ], + "metadata": { + "id": "CaTJQmj33IvW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model_lstm.fit(train_X, train_y, epochs=10, verbose=0)\n", + "#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\n", + "\n", + "# Evaluar los modelos\n", + "mse_lstm = model_lstm.evaluate(test_X, test_y)\n", + "#mse_gru = model_gru.evaluate(test_X, test_y)\n", + "\n", + "print(f'Test MSE LSTM: {mse_lstm}')\n", + "#print(f'Test MSE GRU: {mse_gru}')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 245 + }, + "id": "3wBcalVC41ED", + "outputId": "671dcbb9-7d07-4da9-b9e3-1c52a5f16ef9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;31m#model_gru.fit(train_X, train_y, epochs=10, verbose=0)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Evaluar los modelos\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mmse_lstm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel_lstm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'train_X' is not defined" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "hasta aca\n" + ], + "metadata": { + "id": "keXYd4TrurKV" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Convertir los datos a un formato largo usando melt de pandas\n", + "new_data = pd.melt(data, id_vars=['Country', 'Latitude', 'Longitude', 'Features', 'Region'], var_name='Year', value_name='Value')\n", + "\n", + "# Convertir las columnas al tipo de datos correcto\n", + "new_data['Year'] = new_data['Year'].astype(int)\n", + "new_data['Latitude'] = pd.to_numeric(new_data['Latitude'])\n", + "new_data['Longitude'] = pd.to_numeric(new_data['Longitude'])" + ], + "metadata": { + "id": "Xd6En43Apl_Z", + "outputId": "ff66b8ad-695e-4976-8859-ea466bc350cc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\"", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Convertir las columnas al tipo de datos correcto\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Latitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numeric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Longitude'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/tools/numeric.py\u001b[0m in \u001b[0;36mto_numeric\u001b[0;34m(arg, errors, downcast)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[0mcoerce_numeric\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0merrors\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"ignore\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"raise\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 184\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 185\u001b[0;31m values, _ = lib.maybe_convert_numeric(\n\u001b[0m\u001b[1;32m 186\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcoerce_numeric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 187\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.maybe_convert_numeric\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unable to parse string \" -24.653257\" at position 161" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Reordenar los niveles de 'Features' en la secuencia deseada\n", + "feature_order = [\"imports\", \"exports\", \"net imports\", \"installed capacity\", \"net generation\", \"net consumption\", \"distribution losses\"]\n", + "new_data['Features'] = pd.Categorical(new_data['Features'], categories=feature_order, ordered=True)\n", + "\n", + "custom_palette = [\"red\", \"blue\", \"green\",\"purple\", \"#FF7F00\", \"cyan\", \"brown\"]\n", + "\n", + "# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\n", + "region_features = new_data.groupby(['Year', 'Region', 'Features']).agg(Total_Value=('Value', 'sum')).reset_index()\n", + "\n", + "# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "# Crear el gráfico de líneas con la paleta de colores personalizada\n", + "sns.lineplot(data=region_features, x='Year', y='Total_Value', hue='Region')\n", + "plt.title('Total Values by Region Over Time')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('Total')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 390 + }, + "id": "cYzGOiNeVfY7", + "outputId": "d3044941-773c-479f-a4bf-7e86be3e6785" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m# Agrupar los datos por 'Year' y 'Region' y calcular la suma de valores\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mregion_features\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Region'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0magg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTotal_Value\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Value'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sum'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m# Establecer el estilo de los gráficos en Seaborn a \"whitegrid\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36mgroupby\u001b[0;34m(self, by, axis, level, as_index, sort, group_keys, squeeze, observed, dropna)\u001b[0m\n\u001b[1;32m 8400\u001b[0m \u001b[0maxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_axis_number\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8401\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 8402\u001b[0;31m return DataFrameGroupBy(\n\u001b[0m\u001b[1;32m 8403\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8404\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/groupby.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, obj, keys, axis, level, grouper, exclusions, selection, as_index, sort, group_keys, squeeze, observed, mutated, dropna)\u001b[0m\n\u001b[1;32m 963\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrouper\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mget_grouper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 964\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 965\u001b[0;31m grouper, exclusions, obj = get_grouper(\n\u001b[0m\u001b[1;32m 966\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 967\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/groupby/grouper.py\u001b[0m in \u001b[0;36mget_grouper\u001b[0;34m(obj, key, axis, level, sort, observed, mutated, validate, dropna)\u001b[0m\n\u001b[1;32m 886\u001b[0m \u001b[0min_axis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 888\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 889\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGrouper\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mgpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkey\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 890\u001b[0m \u001b[0;31m# Add key to exclusions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "custom_palette = [\"#E41A1C\", \"#377EB8\", \"#4DAF4A\", \"#984EA3\", \"#FF7F00\", \"#FFFF33\", \"#A65628\"]\n", + "\n", + "# Filter the data for the past five years and 'exports'\n", + "export_data = new_data[(new_data['Features'] == \"exports\") & (new_data['Year'] >= (new_data['Year'].max() - 4))]\n", + "\n", + "# Group by 'Country' and calculate the total export value\n", + "top_exporting_countries = export_data.groupby('Country')['Value'].sum().reset_index().sort_values(by='Value', ascending=False).head(10)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(x='Value', y='Country', data=top_exporting_countries, palette=custom_palette)\n", + "print(top_exporting_countries)\n", + "\n", + "plt.xlabel('Total Exports')\n", + "plt.ylabel('Country')\n", + "plt.title('Exports - Last 5 Years - Top Ten Countries')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 512 + }, + "id": "pEGfENwGVhHK", + "outputId": "2dc0d837-10ef-4939-a46a-d36246f692a7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3801\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3802\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Filter the data for the past five years and 'exports'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mexport_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Features'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"exports\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnew_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Year'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# Group by 'Country' and calculate the total export value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3805\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3807\u001b[0;31m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3808\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3809\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3802\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3803\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3804\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3805\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3806\u001b[0m \u001b[0;31m# If we have a listlike key, _check_indexing_error will raise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Year'" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "RQfTp3HSXLqQ" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file