Genetic_Algorithms_For_Trading.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOkf+4perUO50kWhYG3B4aO",
      "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": [
        "<a href=\"https://colab.research.google.com/github/samuelqian01/Genetic-Algorithms-For-Portfolio-Management/blob/main/Genetic_Algorithms_For_Trading.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **SECTION 1: Basic Brute Force Example with items that have a value and volume**"
      ],
      "metadata": {
        "id": "DJMwVMf4XDbk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Suppose we want to maximize the value (in dollars) for a set of items, but the maximum volume inside of a shipping truck is X cubic meters. This lets us most efficiently ship things inside the truck to get the most value out of the shipment. Let's brute force this."
      ],
      "metadata": {
        "id": "-cvtXPseXLhz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "ifqrLfWBYeAt"
      },
      "execution_count": 264,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 265,
      "metadata": {
        "id": "pI_UrghzW_2H"
      },
      "outputs": [],
      "source": [
        "class Item:\n",
        "  def __init__(self, value, volume):\n",
        "    self.value = value\n",
        "    self.volume = volume\n",
        "\n",
        "items = [Item(value=random.uniform(5, 500), volume=random.uniform(1,200)) for _ in range(20)]"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Randomly generating 1000 weight combinations for the set of items to try out\n",
        "weight_combinations = [[] for _ in range(1000)]\n",
        "for n in range(1000):\n",
        "  for _ in items:\n",
        "    #create 1000 different combinations of weights of 0 or 1 for each item\n",
        "    weight_combinations[n].append(np.random.choice([0,1]))\n"
      ],
      "metadata": {
        "id": "xoUiMu9mYroL"
      },
      "execution_count": 266,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Limitation of 700 cubic meters, print the best combination through brute force\n",
        "limitation = 700\n",
        "best_combination = []\n",
        "max_value = 0\n",
        "max_volume = 0\n",
        "for i in range(len(weight_combinations)):\n",
        "  volume = 0\n",
        "  value = 0\n",
        "  for n in range(len(weight_combinations[i])):\n",
        "    volume += items[n].volume * weight_combinations[i][n]\n",
        "    value += items[n].value * weight_combinations[i][n]\n",
        "\n",
        "  if value > max_value and volume <= limitation:\n",
        "    max_value = value\n",
        "    best_combination = weight_combinations[i]\n",
        "    max_volume = volume\n",
        "\n",
        "print(max_value)\n",
        "print(max_volume)\n",
        "print(best_combination)\n",
        "item_values = []\n",
        "item_volumes = []\n",
        "for n in range(len(items)):\n",
        "  item_values.append(items[n].value)\n",
        "  item_volumes.append(items[n].volume)\n",
        "print(item_values)\n",
        "print(item_volumes)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LYhTzD96Z-V6",
        "outputId": "56c6f44e-a88c-4029-a180-3a76620b8ac9"
      },
      "execution_count": 267,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2668.9136051509267\n",
            "598.1105406243598\n",
            "[1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1]\n",
            "[64.00183065143179, 208.27009289079078, 180.80342812422384, 447.7697201484011, 304.529297647852, 214.6511611816151, 338.14368172734896, 117.62652399983932, 349.25237178495865, 182.80517347925553, 385.16676062338536, 149.48627913928155, 240.93018676152428, 365.13117198137235, 371.2668595209644, 420.0493719156957, 343.21598542774933, 30.060072338256134, 209.14677666376235, 270.2054551499311]\n",
            "[8.739095120856984, 148.23917694322964, 135.54445757900328, 32.12051985160477, 21.824910396612538, 193.55873812608914, 186.77669041984464, 127.23090443694379, 117.40978683022334, 48.36976655556895, 102.32313232077898, 156.321221912046, 25.747407129931478, 8.651989508699515, 14.345404274548018, 180.56514586066467, 153.36748602644357, 78.9856710452017, 163.53570382958296, 129.50709868787175]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **SECTION 2: Crossover example with two random individuals**"
      ],
      "metadata": {
        "id": "kL_UlhTgvBRE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Suppose we generate two individuals. Let's get their weights and do a crossover. First we create a function to get the two best combinations in two runs but you can just pick two random ones for this section."
      ],
      "metadata": {
        "id": "galZiqsHvRM2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def best_combination_for_run(limitations):\n",
        "  items = [Item(value=random.uniform(5, 500), volume=random.uniform(1,200)) for _ in range(20)]\n",
        "  weight_combinations = [[] for _ in range(1000)]\n",
        "  for n in range(1000):\n",
        "    for _ in items:\n",
        "      #create 1000 different combinations of weights of 0 or 1 for each item\n",
        "      weight_combinations[n].append(np.random.choice([0,1]))\n",
        "  best_combination = []\n",
        "  max_value = 0\n",
        "  max_volume = 0\n",
        "  for i in range(len(weight_combinations)):\n",
        "    volume = 0\n",
        "    value = 0\n",
        "    for n in range(len(weight_combinations[i])):\n",
        "      volume += items[n].volume * weight_combinations[i][n]\n",
        "      value += items[n].value * weight_combinations[i][n]\n",
        "\n",
        "    if value > max_value and volume <= limitation:\n",
        "      max_value = value\n",
        "      best_combination = weight_combinations[i]\n",
        "      max_volume = volume\n",
        "  print(best_combination)\n",
        "  return best_combination\n",
        "\n",
        "\n",
        "combo_one = best_combination_for_run(700)\n",
        "combo_two = best_combination_for_run(700)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6qqQjXJ2vO9n",
        "outputId": "2f11d956-8b51-4c3e-f5ef-9c71a494c563"
      },
      "execution_count": 280,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1]\n",
            "[1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we perform the crossover. ONLY RUN THIS if you get two populated list of weights above!!!!"
      ],
      "metadata": {
        "id": "GeH8kRO-w1I7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#ONLY RUN THIS CODE IF YOU HAVE TWO POPULATED LIST OF WEIGHTS ABOVE OTHERWISE YOU CANNOT FORM CHILDREN\n",
        "length = len(combo_one)\n",
        "#Crossover point in this example is right side inclusive, right half starts at crossover point\n",
        "crossover_point = random.randint(0, length)\n",
        "print(crossover_point)\n",
        "combo_one_left = combo_one[0:crossover_point]\n",
        "combo_one_right = combo_one[crossover_point:length]\n",
        "combo_two_left = combo_two[0:crossover_point]\n",
        "combo_two_right = combo_two[crossover_point:length]\n",
        "\n",
        "print(combo_one_left)\n",
        "print(combo_one_right)\n",
        "print(combo_two_left)\n",
        "print(combo_two_right)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lTBrfn_9w34g",
        "outputId": "e4833c24-e8e7-415d-9e75-da6c2a77b544"
      },
      "execution_count": 282,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "14\n",
            "[0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1]\n",
            "[0, 0, 0, 1, 0, 1]\n",
            "[1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0]\n",
            "[0, 1, 1, 0, 0, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we merge to create the children"
      ],
      "metadata": {
        "id": "kUH8Ikq809fZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "child_one = combo_one_left + combo_two_right\n",
        "child_two = combo_two_left + combo_one_right\n",
        "print(child_one)\n",
        "print(child_two)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I8yE7UL61A1B",
        "outputId": "e1786e3f-005c-4dd7-eada-dacc1e07c0d5"
      },
      "execution_count": 283,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0]\n",
            "[1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **SECTION 3: Mutation**"
      ],
      "metadata": {
        "id": "G1cH9Rym2bb1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Mutation creates diversity by randomly changing weights. Not used frequently. Let's give child_one a 75% chance of mutation and child_two a 10% chance of mutation."
      ],
      "metadata": {
        "id": "r9ZgwCqx2f5O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def mutation(weight_list, chance):\n",
        "  for i in range(len(weight_list)):\n",
        "    if random.random() < chance:\n",
        "      if weight_list[i] == 1:\n",
        "        weight_list[i] = 0\n",
        "      else:\n",
        "        weight_list[i] = 1\n",
        "  return weight_list\n",
        "\n",
        "child_one = mutation(child_one, 0.75)\n",
        "child_two = mutation(child_two, 0.1)\n",
        "print(child_one)\n",
        "print(child_two)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kyIFjER42oWI",
        "outputId": "2be1aefe-b186-405c-e788-6f8fca1f6355"
      },
      "execution_count": 284,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1]\n",
            "[1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice how child_two is just slightly mutated while child_one is majorly mutated"
      ],
      "metadata": {
        "id": "jxiW2-hb3Plv"
      }
    }
  ]
}