genetic-algorithm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Genetic Algorithm Approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-03T21:37:10.173141Z",
     "start_time": "2024-03-03T21:37:07.727032Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "from pennylane import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_qubits = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_train = 500\n",
    "n_test = 100\n",
    "batch_size = 32\n",
    "n_epochs = 10\n",
    "\n",
    "resized_dims_xy = 8\n",
    "out_dims_xy = resized_dims_xy // 2\n",
    "\n",
    "lr = 0.005"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(137)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_generations = 10\n",
    "population_size = 500\n",
    "n_gates = 10\n",
    "mutation_rate = .15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Auxiliary Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_population_fitnesses(population):\n",
    "    return list(map(lambda x: x[1], population))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encode_gate(gate):\n",
    "    if isinstance(gate, qml.RX):\n",
    "        return 100 + gate.wires[0] * 10 \n",
    "    elif isinstance(gate, qml.RZ):\n",
    "        return 200 + gate.wires[0] * 10 \n",
    "    elif isinstance(gate, qml.CNOT):\n",
    "        return 300 + gate.wires[0] * 10 + gate.wires[1] * 1 \n",
    "    elif isinstance(gate, qml.Hadamard):\n",
    "        return 400 + gate.wires[0] * 10 \n",
    "    else:\n",
    "        print(gate)\n",
    "        raise Exception(\"Invalid gate\")\n",
    "    \n",
    "def decode_gate(encoded_gate, param):\n",
    "    \"\"\"\n",
    "    D D D\n",
    "        - Gate   [1..4]\n",
    "        - Wire 1 [0..N_QUBITS-1]\n",
    "        - Wire 2 [0..N_QUBITS-1]\n",
    "    \"\"\"\n",
    "    encoded_gate = int(encoded_gate.item()) # Convert tensor to int to be able to use adjoint differentiation\n",
    "    wire2  = encoded_gate % 10\n",
    "    wire1 = (encoded_gate // 10) % 10\n",
    "    gate = (encoded_gate // 100) % 10\n",
    "    \n",
    "    if gate == 1:\n",
    "        return qml.RX(param, wires=wire1)\n",
    "    elif gate == 2:\n",
    "        return qml.RZ(param, wires=wire1)\n",
    "    elif gate == 3:\n",
    "        return qml.CNOT(wires=[wire1, wire2])\n",
    "    elif gate == 4:\n",
    "        return qml.Hadamard(wires=wire1)\n",
    "    else:\n",
    "        print(encoded_gate)\n",
    "        raise Exception(\"Invalid gate\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Genetic Algorithm Components"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rotation      -> RX, RZ.\n",
    "# Entanglement  -> CNOT.\n",
    "# Superposition -> Hadamard.\n",
    "\n",
    "parametrized_gates = [qml.RX, qml.RZ] # 1X0, 2X0\n",
    "gates = parametrized_gates + [qml.Hadamard, qml.CNOT] # 4X0, 3XX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_random_gate():\n",
    "    gate = np.random.randint(1, 5) # 1..4\n",
    "    wire1 = np.random.randint(0, n_qubits) # 0..3\n",
    "    wire2 = np.random.randint(0, n_qubits) # 0..3\n",
    "    if gate == 3:\n",
    "        while wire1 == wire2:\n",
    "            wire2 = np.random.randint(0, n_qubits)\n",
    "              \n",
    "    return 100 * gate + 10 * wire1 + wire2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_circuit(n_gates):\n",
    "    circuit = []\n",
    "    n_weights = 0\n",
    "    fitness = 0\n",
    "    for _ in range(n_gates):\n",
    "        gate = get_random_gate()\n",
    "        if (gate // 100) % 10 in [1, 2]:\n",
    "            n_weights += 1\n",
    "        circuit.append(gate)\n",
    "    return (circuit, fitness, n_weights) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_population(n_circuits, n_gates):\n",
    "    population = [None] * n_circuits\n",
    "    for i in range(n_circuits):\n",
    "        population[i] = generate_circuit(np.random.randint(2, n_gates))\n",
    "    return population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stochastic_universal_sampling(fitness_scores, n_samples):\n",
    "    \"\"\"Performs selection using Stochastic Universal Sampling.\n",
    "\n",
    "    Args:\n",
    "        fitness_scores: A NumPy array of fitness scores.\n",
    "        num_samples: The number of individuals to select.\n",
    "\n",
    "    Returns:\n",
    "        A NumPy array containing the indices of the selected individuals.\n",
    "    \"\"\"\n",
    "\n",
    "    total_fitness = np.sum(fitness_scores)\n",
    "    fitness_scores = np.array(fitness_scores) \n",
    "\n",
    "    fitness_scores = fitness_scores / total_fitness\n",
    "\n",
    "    # Cumulative sum of fitness scores\n",
    "    cumulative_fitness = np.cumsum(fitness_scores)\n",
    "\n",
    "    # Starting point for the first pointer\n",
    "    start_point = np.random.uniform(0, 1/n_samples)\n",
    "\n",
    "    # Generate equally spaced pointers\n",
    "    pointers = np.arange(start_point, 1, 1/n_samples)\n",
    "\n",
    "    # Select individuals based on the pointers' locations\n",
    "    selected_indices = np.searchsorted(cumulative_fitness, pointers)\n",
    "\n",
    "    return selected_indices \n",
    "\n",
    "def boltzmann_selection(fitness_scores, temperature, n_samples):\n",
    "    \"\"\"Selects individuals based on Boltzmann selection probabilities.\n",
    "\n",
    "    Args:\n",
    "        fitness_scores: The fitness scores of each individual.\n",
    "        temperature: The temperature parameter for Boltzmann selection.\n",
    "        n_samples: The number of individuals to select.\n",
    "\n",
    "    Returns:\n",
    "        A list of indices of the selected individuals.\n",
    "    \"\"\"\n",
    "\n",
    "    # Calculate Boltzmann probabilities\n",
    "    probabilities = np.exp(fitness_scores / temperature)\n",
    "    probabilities /= np.sum(probabilities) \n",
    "\n",
    "    # Select individuals based on probabilities\n",
    "    selected_indices = np.random.choice(\n",
    "        len(fitness_scores), size=n_samples, p=probabilities\n",
    "    )\n",
    "\n",
    "    return selected_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_weights(circuit):\n",
    "    return sum([1 for gate in circuit if (gate // 100) % 10 in [1, 2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uniform_crossover(parent1, parent2, mixing_ratio=0.5):\n",
    "    \"\"\"Performs uniform crossover between two parent arrays (potentially different lengths).\"\"\"\n",
    "\n",
    "    size1 = len(parent1)\n",
    "    size2 = len(parent2)\n",
    "    min_size = min(size1, size2)\n",
    "\n",
    "    offspring1 = []\n",
    "    offspring2 = []\n",
    "\n",
    "    # Crossover for the shared portion of the genome\n",
    "    for i in range(min_size):\n",
    "        if np.random.random() < mixing_ratio:\n",
    "            offspring1.append(parent1[i])\n",
    "            offspring2.append(parent2[i])\n",
    "        else:\n",
    "            offspring1.append(parent2[i])\n",
    "            offspring2.append(parent1[i])\n",
    "\n",
    "    # Remaining genes from the longer parent \n",
    "    offspring1.extend(parent1[min_size:])  \n",
    "    offspring2.extend(parent2[min_size:])  \n",
    "\n",
    "    return (offspring1, 999, count_weights(offspring1)), (offspring2, 999, count_weights(offspring2)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_circuits(population, n_selected):\n",
    "    fitness_values = get_population_fitnesses(population)\n",
    "    selected_indices = stochastic_universal_sampling(fitness_values, n_selected)\n",
    "    return [population[i] for i in selected_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('lightning.qubit', wires=4)\n",
    "\n",
    "@qml.qnode(dev, interface=\"torch\", diff_method=\"adjoint\")\n",
    "def circuit(inputs, weights):\n",
    "    # Encoding of 4 classical input values\n",
    "    for j in range(n_qubits):\n",
    "        qml.RY(np.pi * inputs[j], wires=j)\n",
    "    \n",
    "    weight_index = 0\n",
    "    for i in range(n_qubits, len(inputs)):\n",
    "        gate = decode_gate(inputs[i], weights[weight_index])\n",
    "        weight_index += 1\n",
    "        qml.apply(gate)\n",
    "\n",
    "    # Measurement producing 4 classical output values\n",
    "    return [qml.expval(qml.PauliZ(j)) for j in range(n_qubits)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_image_patches(x):\n",
    "    # Do TF 'SAME' Padding\n",
    "    B, C, H, W = x.shape  \n",
    "    #x = torch.arange(B*C*H*W).view(B, C, H, W)\n",
    "    kernel_h, kernel_w = 2, 2\n",
    "    stride = 2\n",
    "\n",
    "    patches = x.unfold(2, kernel_h, stride).unfold(3, kernel_w, stride)\n",
    "      \n",
    "    patches = patches.contiguous().view(B, H // stride, W // stride, -1)\n",
    "\n",
    "    return patches.reshape(-1, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HQNN(nn.Module):\n",
    "    def __init__(self, qlayer, gates):\n",
    "        super(HQNN, self).__init__()\n",
    "\n",
    "        # Quanvolutional layer (Maps 1 input channel to 4 output channels)\n",
    "        self.quanv = qlayer\n",
    "        self.gates = gates\n",
    "\n",
    "        # Fully connected layer to perform the final classification\n",
    "        self.fc1 = nn.Linear(out_dims_xy * out_dims_xy * 4, 10)  # Assuming 10 output classes\n",
    "\n",
    "    def forward(self, input):\n",
    "        patches = extract_image_patches(input)  \n",
    "\n",
    "        tensor_gates = torch.tensor(self.gates)\n",
    "        quanvoluted_patches = torch.stack([self.quanv(torch.cat((patch, tensor_gates))) for patch in patches])\n",
    "        x = quanvoluted_patches.reshape(input.shape[0], out_dims_xy, out_dims_xy, 4)\n",
    "\n",
    "        x = x.view(-1, out_dims_xy * out_dims_xy * 4)  # Flatten for the fully connected layer\n",
    "        x = self.fc1(x)\n",
    "        x = F.softmax(x, dim=1)  # Apply softmax\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training samples: 500\n",
      "Number of test samples: 100\n"
     ]
    }
   ],
   "source": [
    "def load_dataset(n_train, n_test, batch_size):\n",
    "    \"\"\"\n",
    "    Loads train & test sets from MNIST with user-specified sizes.\n",
    "\n",
    "    Args:\n",
    "        n_train (int): Desired number of samples in the training set.\n",
    "        n_test (int): Desired number of samples in the testing set.\n",
    "        batch_size (int): Batch size for the DataLoaders.\n",
    "\n",
    "    Returns:\n",
    "        tuple: (train_loader, test_loader) where each loader is a\n",
    "               torch.utils.data.DataLoader.\n",
    "    \"\"\"\n",
    "    # Define transformations for the dataset\n",
    "    transform = transforms.Compose([transforms.ToTensor(), \n",
    "                                    transforms.Normalize((0.1307,), (0.1381,)),\n",
    "                                    transforms.Lambda(lambda img: F.interpolate(img.unsqueeze(0), size=(resized_dims_xy, resized_dims_xy), \n",
    "                                        mode='bilinear', align_corners=False).squeeze(0))])\n",
    "\n",
    "    train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
    "    test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n",
    "\n",
    "    # Subset the datasets to the desired number of samples\n",
    "    train_subset = torch.utils.data.Subset(train_dataset, range(n_train))\n",
    "    test_subset = torch.utils.data.Subset(test_dataset, range(n_test))\n",
    "\n",
    "    # Create DataLoaders for training and testing sets\n",
    "    train_loader = DataLoader(train_subset, batch_size=batch_size, shuffle=True)\n",
    "    test_loader = DataLoader(test_subset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "    print(\"Number of training samples:\", len(train_subset))\n",
    "    print(\"Number of test samples:\", len(test_subset))\n",
    "\n",
    "    return train_loader, test_loader\n",
    "\n",
    "train_loader, test_loader = load_dataset(n_train, n_test, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitness(individual):\n",
    "    param_shapes = {\"weights\": (len(individual[0]),)}\n",
    "    \n",
    "    qlayer = qml.qnn.TorchLayer(circuit, weight_shapes=param_shapes)\n",
    "    model = HQNN(qlayer, individual[0])\n",
    "    loss_fn = F.cross_entropy\n",
    "    optimizer = optim.Adam(model.parameters(), lr=lr)\n",
    "    scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.94) \n",
    "\n",
    "#    model.fc1.load_state_dict(torch.load(\"mnist_params.pth\"))\n",
    " \n",
    "#    for param in model.fc1.parameters():\n",
    "#        param.requires_grad = False\n",
    "        \n",
    "    for _ in range(n_epochs):\n",
    "        #start_time = time.time()\n",
    "        # ---- Training Phase ----\n",
    "        running_loss = 0.0 \n",
    "\n",
    "        for i, (images, labels) in enumerate(train_loader):\n",
    "            outputs = model(images)\n",
    "            loss = loss_fn(outputs, labels)\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "        scheduler.step()\n",
    "        #print(f\"Time per epoch: {time.time() - start_time}s\")\n",
    "        \n",
    "    model.eval()  # Set model to evaluation mode\n",
    "\n",
    "    with torch.no_grad():  # Disable gradients for evaluation\n",
    "        val_correct = 0\n",
    "        val_total = 0\n",
    "\n",
    "        for images, labels in test_loader:\n",
    "            outputs = model(images)\n",
    "            loss = loss_fn(outputs, labels)\n",
    "\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            val_total += labels.size(0)\n",
    "            val_correct += (predicted == labels).sum().item()\n",
    "\n",
    "    val_acc = val_correct / val_total\n",
    "    \n",
    "    #print(model.quanv.weights)\n",
    "    \n",
    "    return (individual[0], -val_acc, individual[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert_random_gate(circuit):\n",
    "    mutated_circuit = circuit.copy()    \n",
    "    mutated_circuit.append(get_random_gate())\n",
    "    return mutated_circuit\n",
    "\n",
    "def delete_random_gate(circuit):\n",
    "    mutated_circuit = circuit.copy()    \n",
    "    mutated_circuit.remove(random.choice(mutated_circuit))\n",
    "    return mutated_circuit\n",
    "\n",
    "def swap_random_gates(circuit):\n",
    "    mutated_circuit = circuit.copy()    \n",
    "    i, j = np.random.choice(range(len(mutated_circuit)), 2, replace=False)\n",
    "    gate1 = mutated_circuit[i]\n",
    "    gate2 = mutated_circuit[j]\n",
    "    \n",
    "    gate1_1 = (gate1 // 100) % 10\n",
    "    wire1_1 = (gate1 // 10) % 10\n",
    "    wire1_2 = gate1 % 10\n",
    "    \n",
    "    gate2_2 = (gate2 // 100) % 10\n",
    "    wire2_1 = (gate2 // 10) % 10\n",
    "    wire2_2 = gate2 % 10\n",
    "    \n",
    "    if gate1_1 == 3:\n",
    "        while wire2_1 == wire2_2:\n",
    "            wire2_2 = np.random.randint(0, n_qubits)\n",
    "    \n",
    "    if gate2_2 == 3:\n",
    "        while wire1_1 == wire1_2:\n",
    "            wire1_2 = np.random.randint(0, n_qubits)\n",
    "    \n",
    "    mutated_circuit[i] = 100 * gate2_2 + 10 * wire1_1 + wire1_2\n",
    "    mutated_circuit[j] = 100 * gate1_1 + 10 * wire2_1 + wire2_2\n",
    "    return mutated_circuit\n",
    "\n",
    "def move_random_gate(circuit):\n",
    "    mutated_circuit = circuit.copy()    \n",
    "    i = np.random.choice(range(len(mutated_circuit)))\n",
    "    encoded_gate = mutated_circuit[i]\n",
    "    \n",
    "    gate1_1 = (encoded_gate // 100) % 10\n",
    "    wire1_1 = (encoded_gate // 10) % 10\n",
    "    wire1_2 = encoded_gate % 10\n",
    "    \n",
    "    new_wire1 = np.random.choice(range(n_qubits))\n",
    "    new_wire2 = np.random.choice(range(n_qubits))\n",
    "    if gate1_1 == 3:\n",
    "        while new_wire1 == new_wire2:\n",
    "            new_wire2 = np.random.randint(0, n_qubits)\n",
    "    new_gate = 100 * gate1_1 + 10 * new_wire1 + new_wire2\n",
    "    \n",
    "    mutated_circuit[i] = new_gate\n",
    "    return mutated_circuit\n",
    "\n",
    "def replace_random_gate(circuit):\n",
    "    mutated_circuit = circuit.copy()    \n",
    "    i = np.random.choice(range(len(mutated_circuit)))\n",
    "    mutated_circuit[i] = get_random_gate()\n",
    "    return mutated_circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutate_circuit(circuit):  \n",
    "    op_thresholds = [0.2, 0.4, 0.6, 0.8]\n",
    "    #op_choices = [\"insert\", \"delete\", \"swap\", \"replace\"]\n",
    "\n",
    "    n_mutations = 1\n",
    "    while np.random.random() < 0.1:\n",
    "        n_mutations += 1\n",
    "\n",
    "    for _ in range(n_mutations):\n",
    "        op = np.random.random()\n",
    "\n",
    "        # Insert a random gate\n",
    "        if op < op_thresholds[0]:\n",
    "            mutated_circuit = insert_random_gate(circuit)\n",
    "        # Delete a random gate\n",
    "        elif op < op_thresholds[1]:\n",
    "            mutated_circuit = delete_random_gate(circuit)\n",
    "        # Swap two random gates\n",
    "        elif op < op_thresholds[2]:\n",
    "            mutated_circuit = swap_random_gates(circuit)\n",
    "        # Move a random gate to a random position\n",
    "        elif op < op_thresholds[3]:\n",
    "            mutated_circuit = move_random_gate(circuit)\n",
    "        # Replace a random gate \n",
    "        else:\n",
    "            mutated_circuit = replace_random_gate(circuit)\n",
    "\n",
    "    n_weights = count_weights(mutated_circuit)\n",
    "    mutated_indiviual = (mutated_circuit, 999, n_weights)\n",
    "    return fitness(mutated_indiviual)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torchvision.datasets as datasets\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "# Define a custom transform with resize and conversion to tensor\n",
    "transform = transforms.Compose([transforms.ToTensor(), \n",
    "                                    transforms.Normalize((0.1307,), (0.1381,)),\n",
    "                                    transforms.Lambda(lambda img: F.interpolate(img.unsqueeze(0), size=(resized_dims_xy, resized_dims_xy), \n",
    "                                        mode='bilinear', align_corners=False).squeeze(0))\n",
    "])\n",
    "\n",
    "# Load MNIST dataset with the custom transform\n",
    "mnist_train = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
    "\n",
    "# Access a sample for testing\n",
    "image, label = mnist_train[np.random.randint(0, len(mnist_train))]\n",
    "\n",
    "# No need for separate downscaling or conversion\n",
    "plt.imshow(image.squeeze(), cmap='gray')  # Squeeze to remove channel dimension (if needed)\n",
    "plt.title(f'Downscaled Label: {label}')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_population(population):\n",
    "    return list(map(fitness, population))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[t] Time to generate initial population of 500 circuits: 34083.913s\n",
      "\t[i] n_train: 500, n_test: 100,  batch_size: 32, n_epochs: 10\n",
      "\t[f] Best fitness: 64.0%\n",
      "\t[b] Best individual: [303, 211, 210, 323, 313, 312, 320, 323, 212]\n",
      "[i] Generation (1/10)\n",
      "\t[f] Best fitness: 64.0%\n",
      "\t[b] Best individual: [303, 211, 210, 323, 313, 312, 320, 323, 212]\n",
      "\t[f]Average fitness: 58.974000000000196%\n",
      "\t[t] Time per generation: 23893.625s\n",
      "[i] Generation (2/10)\n",
      "\t[f] Best fitness: 64.0%\n",
      "\t[b] Best individual: [303, 211, 210, 323, 313, 312, 320, 323, 212]\n",
      "\t[f]Average fitness: 59.55199999999991%\n",
      "\t[t] Time per generation: 23884.837s\n",
      "[i] Generation (3/10)\n",
      "\t[f] Best fitness: 65.0%\n",
      "\t[b] Best individual: [122, 303, 200, 312, 320, 203, 233, 403]\n",
      "\t[f]Average fitness: 59.98399999999964%\n",
      "\t[t] Time per generation: 24732.293s\n",
      "[i] Generation (4/10)\n"
     ]
    }
   ],
   "source": [
    "def evolve():\n",
    "    time_start = time.time()\n",
    "    population = generate_population(population_size, n_gates)\n",
    "    best_individual = None\n",
    "    best_fitness = float('inf')\n",
    "    population = evaluate_population(population)\n",
    "    population.sort(key=lambda x: x[1])\n",
    "    print(f\"[t] Time to generate initial population of {population_size} circuits: {(time.time() - time_start):.3f}s\")\n",
    "    print(f\"\\t[i] n_train: {n_train}, n_test: {n_test},  batch_size: {batch_size}, n_epochs: {n_epochs}\")\n",
    "    print(f\"\\t[f] Best fitness: {100*-population[0][1]}%\")\n",
    "    print(f\"\\t[b] Best individual: {population[0][0]}\")\n",
    "    \n",
    "    for i in range(n_generations):\n",
    "        start_time = time.time()\n",
    "        print(f\"[i] Generation ({i+1}/{n_generations})\")\n",
    "        selected_population = select_circuits(population, population_size // 2 + 1)\n",
    "        new_population = []\n",
    "\n",
    "        for j in range(0, population_size // 2, 2):\n",
    "            parent1 = selected_population[j]\n",
    "            parent2 = selected_population[j+1]\n",
    "            \n",
    "            offspring1, offspring2 = uniform_crossover(parent1[0], parent2[0])\n",
    "   \n",
    "            new_population.append(offspring1)\n",
    "            new_population.append(offspring2)\n",
    "\n",
    "        new_population = evaluate_population(new_population)\n",
    "        population = population +  new_population\n",
    "\n",
    "        for individual in population:\n",
    "            if np.random.random() < mutation_rate:\n",
    "                new_population.append(mutate_circuit(individual[0]))\n",
    "\n",
    "        population.sort(key=lambda x: x[1])\n",
    "\n",
    "        population = population[:population_size]\n",
    "\n",
    "        best_individual = population[0][0]\n",
    "        best_fitness = population[0][1]\n",
    "\n",
    "        print(f\"\\t[f] Best fitness: {100*-best_fitness}%\")\n",
    "        print(f\"\\t[b] Best individual: {best_individual}\")\n",
    "        print(f\"\\t[f]Average fitness: {100*-sum(get_population_fitnesses(population)) / len(population)}%\")\n",
    "        print(f\"\\t[t] Time per generation: {(time.time() - start_time):.3f}s\")\n",
    "            \n",
    "    return population\n",
    "\n",
    "final_population = evolve()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Individual 1\n",
      "[212, 202]\n",
      "Fitness: 65.0%\n",
      "qml.RZ(weights[0], wires=1)\n",
      "qml.RZ(weights[1], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 2\n",
      "[310, 410, 222, 301, 233, 200, 403, 103]\n",
      "Fitness: 64.0%\n",
      "qml.CNOT(wires=[1, 0])\n",
      "qml.Hadamard(wires=1)\n",
      "qml.RZ(weights[0], wires=2)\n",
      "qml.CNOT(wires=[0, 1])\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.RZ(weights[2], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RX(weights[3], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 3\n",
      "[430, 102, 332, 402, 122, 410, 421, 103]\n",
      "Fitness: 63.0%\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.CNOT(wires=[3, 2])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RX(weights[1], wires=2)\n",
      "qml.Hadamard(wires=1)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RX(weights[2], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 4\n",
      "[100, 312, 331]\n",
      "Fitness: 63.0%\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.CNOT(wires=[1, 2])\n",
      "qml.CNOT(wires=[3, 1])\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 5\n",
      "[403, 223, 403, 420, 210, 233]\n",
      "Fitness: 62.0%\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[0], wires=2)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RZ(weights[1], wires=1)\n",
      "qml.RZ(weights[2], wires=3)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 6\n",
      "[310, 410, 110, 301]\n",
      "Fitness: 62.0%\n",
      "qml.CNOT(wires=[1, 0])\n",
      "qml.Hadamard(wires=1)\n",
      "qml.RX(weights[0], wires=1)\n",
      "qml.CNOT(wires=[0, 1])\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 7\n",
      "[321, 320, 122, 231, 130, 431, 432]\n",
      "Fitness: 62.0%\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.CNOT(wires=[2, 0])\n",
      "qml.RX(weights[0], wires=2)\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.RX(weights[2], wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 8\n",
      "[230, 421, 222, 413, 233, 200, 403, 103]\n",
      "Fitness: 62.0%\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RZ(weights[1], wires=2)\n",
      "qml.Hadamard(wires=1)\n",
      "qml.RZ(weights[2], wires=3)\n",
      "qml.RZ(weights[3], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RX(weights[4], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 9\n",
      "[421, 100, 332, 413, 233, 200, 403, 103]\n",
      "Fitness: 62.0%\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.CNOT(wires=[3, 2])\n",
      "qml.Hadamard(wires=1)\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.RZ(weights[2], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RX(weights[3], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 10\n",
      "[133, 411, 332, 323, 233, 200, 403, 103]\n",
      "Fitness: 62.0%\n",
      "qml.RX(weights[0], wires=3)\n",
      "qml.Hadamard(wires=1)\n",
      "qml.CNOT(wires=[3, 2])\n",
      "qml.CNOT(wires=[2, 3])\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.RZ(weights[2], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RX(weights[3], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 11\n",
      "[431, 222, 232, 110, 321, 101]\n",
      "Fitness: 62.0%\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RZ(weights[0], wires=2)\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.RX(weights[2], wires=1)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.RX(weights[3], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 12\n",
      "[200, 433, 402, 231, 422, 330, 432, 103, 401]\n",
      "Fitness: 62.0%\n",
      "qml.RZ(weights[0], wires=0)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.CNOT(wires=[3, 0])\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RX(weights[2], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 13\n",
      "[431, 222, 403, 420, 233, 200]\n",
      "Fitness: 62.0%\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RZ(weights[0], wires=2)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.RZ(weights[2], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 14\n",
      "[230, 410, 110, 413]\n",
      "Fitness: 62.0%\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.Hadamard(wires=1)\n",
      "qml.RX(weights[1], wires=1)\n",
      "qml.Hadamard(wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 15\n",
      "[413, 202, 432]\n",
      "Fitness: 61.0%\n",
      "qml.Hadamard(wires=1)\n",
      "qml.RZ(weights[0], wires=0)\n",
      "qml.Hadamard(wires=3)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 16\n",
      "[133, 411, 330, 323]\n",
      "Fitness: 61.0%\n",
      "qml.RX(weights[0], wires=3)\n",
      "qml.Hadamard(wires=1)\n",
      "qml.CNOT(wires=[3, 0])\n",
      "qml.CNOT(wires=[2, 3])\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 17\n",
      "[423, 433, 420, 231, 130, 431]\n",
      "Fitness: 61.0%\n",
      "qml.Hadamard(wires=2)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.RX(weights[1], wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 18\n",
      "[323, 331, 411]\n",
      "Fitness: 61.0%\n",
      "qml.CNOT(wires=[2, 3])\n",
      "qml.CNOT(wires=[3, 1])\n",
      "qml.Hadamard(wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 19\n",
      "[310, 320, 102, 400, 423, 402, 432, 203, 411]\n",
      "Fitness: 61.0%\n",
      "qml.CNOT(wires=[1, 0])\n",
      "qml.CNOT(wires=[2, 0])\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RZ(weights[1], wires=0)\n",
      "qml.Hadamard(wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 20\n",
      "[200, 321, 402, 222, 422, 330, 421, 103, 401]\n",
      "Fitness: 61.0%\n",
      "qml.RZ(weights[0], wires=0)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[1], wires=2)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.CNOT(wires=[3, 0])\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RX(weights[2], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 21\n",
      "[321, 320, 110, 301]\n",
      "Fitness: 61.0%\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.CNOT(wires=[2, 0])\n",
      "qml.RX(weights[0], wires=1)\n",
      "qml.CNOT(wires=[0, 1])\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 22\n",
      "[401, 433, 122, 231, 130, 431, 432]\n",
      "Fitness: 61.0%\n",
      "qml.Hadamard(wires=0)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RX(weights[0], wires=2)\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.RX(weights[2], wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 23\n",
      "[100, 401, 303, 421, 312, 401, 101]\n",
      "Fitness: 61.0%\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.CNOT(wires=[0, 3])\n",
      "qml.Hadamard(wires=2)\n",
      "qml.CNOT(wires=[1, 2])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RX(weights[1], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 24\n",
      "[230, 222]\n",
      "Fitness: 61.0%\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.RZ(weights[1], wires=2)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 25\n",
      "[413, 231, 203, 421, 312, 401, 323]\n",
      "Fitness: 61.0%\n",
      "qml.Hadamard(wires=1)\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.RZ(weights[1], wires=0)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.CNOT(wires=[1, 2])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.CNOT(wires=[2, 3])\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 26\n",
      "[230, 321, 331, 222, 312, 401, 211]\n",
      "Fitness: 61.0%\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.CNOT(wires=[3, 1])\n",
      "qml.RZ(weights[1], wires=2)\n",
      "qml.CNOT(wires=[1, 2])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[2], wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 27\n",
      "[401, 321, 332, 403, 130, 331, 313]\n",
      "Fitness: 61.0%\n",
      "qml.Hadamard(wires=0)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.CNOT(wires=[3, 2])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RX(weights[0], wires=3)\n",
      "qml.CNOT(wires=[3, 1])\n",
      "qml.CNOT(wires=[1, 3])\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 28\n",
      "[430, 133, 101, 110, 312, 421, 131]\n",
      "Fitness: 61.0%\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RX(weights[0], wires=3)\n",
      "qml.RX(weights[1], wires=0)\n",
      "qml.RX(weights[2], wires=1)\n",
      "qml.CNOT(wires=[1, 2])\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RX(weights[3], wires=3)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 29\n",
      "[421, 100, 330, 413, 312, 410, 211]\n",
      "Fitness: 61.0%\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.CNOT(wires=[3, 0])\n",
      "qml.Hadamard(wires=1)\n",
      "qml.CNOT(wires=[1, 2])\n",
      "qml.Hadamard(wires=1)\n",
      "qml.RZ(weights[1], wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 30\n",
      "[200, 321, 122, 231, 422, 330, 211, 410, 401]\n",
      "Fitness: 61.0%\n",
      "qml.RZ(weights[0], wires=0)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.RX(weights[1], wires=2)\n",
      "qml.RZ(weights[2], wires=3)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.CNOT(wires=[3, 0])\n",
      "qml.RZ(weights[3], wires=1)\n",
      "qml.Hadamard(wires=1)\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 31\n",
      "[230, 202, 403]\n",
      "Fitness: 61.0%\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.RZ(weights[1], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 32\n",
      "[421, 303, 122, 222, 423, 431, 211]\n",
      "Fitness: 61.0%\n",
      "qml.Hadamard(wires=2)\n",
      "qml.CNOT(wires=[0, 3])\n",
      "qml.RX(weights[0], wires=2)\n",
      "qml.RZ(weights[1], wires=2)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RZ(weights[2], wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 33\n",
      "[200, 321, 402]\n",
      "Fitness: 61.0%\n",
      "qml.RZ(weights[0], wires=0)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 34\n",
      "[401, 211, 122, 313, 101, 232, 422, 201, 320]\n",
      "Fitness: 60.0%\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[0], wires=1)\n",
      "qml.RX(weights[1], wires=2)\n",
      "qml.CNOT(wires=[1, 3])\n",
      "qml.RX(weights[2], wires=0)\n",
      "qml.RZ(weights[3], wires=3)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RZ(weights[4], wires=0)\n",
      "qml.CNOT(wires=[2, 0])\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 35\n",
      "[430, 102, 430, 402, 122, 410, 211, 410]\n",
      "Fitness: 60.0%\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RX(weights[1], wires=2)\n",
      "qml.Hadamard(wires=1)\n",
      "qml.RZ(weights[2], wires=1)\n",
      "qml.Hadamard(wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 36\n",
      "[310, 331, 102, 331, 423, 321, 123, 203, 411]\n",
      "Fitness: 60.0%\n",
      "qml.CNOT(wires=[1, 0])\n",
      "qml.CNOT(wires=[3, 1])\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.CNOT(wires=[3, 1])\n",
      "qml.Hadamard(wires=2)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.RX(weights[1], wires=2)\n",
      "qml.RZ(weights[2], wires=0)\n",
      "qml.Hadamard(wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 37\n",
      "[321, 320, 430, 400, 231, 402, 432]\n",
      "Fitness: 60.0%\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.CNOT(wires=[2, 0])\n",
      "qml.Hadamard(wires=3)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.Hadamard(wires=3)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 38\n",
      "[212, 212]\n",
      "Fitness: 60.0%\n",
      "qml.RZ(weights[0], wires=1)\n",
      "qml.RZ(weights[1], wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 39\n",
      "[401, 433, 122, 231, 130, 431]\n",
      "Fitness: 60.0%\n",
      "qml.Hadamard(wires=0)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RX(weights[0], wires=2)\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.RX(weights[2], wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 40\n",
      "[403, 202, 403]\n",
      "Fitness: 60.0%\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[0], wires=0)\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 41\n",
      "[200, 321, 402, 222, 422, 330, 211, 410, 401]\n",
      "Fitness: 60.0%\n",
      "qml.RZ(weights[0], wires=0)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[1], wires=2)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.CNOT(wires=[3, 0])\n",
      "qml.RZ(weights[2], wires=1)\n",
      "qml.Hadamard(wires=1)\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 42\n",
      "[230, 421, 222, 103]\n",
      "Fitness: 60.0%\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RZ(weights[1], wires=2)\n",
      "qml.RX(weights[2], wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 43\n",
      "[100, 210, 310, 323, 331, 400, 222, 400]\n",
      "Fitness: 60.0%\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.RZ(weights[1], wires=1)\n",
      "qml.CNOT(wires=[1, 0])\n",
      "qml.CNOT(wires=[2, 3])\n",
      "qml.CNOT(wires=[3, 1])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[2], wires=2)\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 44\n",
      "[430, 321, 402, 222, 122, 330, 211, 410]\n",
      "Fitness: 60.0%\n",
      "qml.Hadamard(wires=3)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[0], wires=2)\n",
      "qml.RX(weights[1], wires=2)\n",
      "qml.CNOT(wires=[3, 0])\n",
      "qml.RZ(weights[2], wires=1)\n",
      "qml.Hadamard(wires=1)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 45\n",
      "[321, 320, 430, 400, 231, 402]\n",
      "Fitness: 60.0%\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.CNOT(wires=[2, 0])\n",
      "qml.Hadamard(wires=3)\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[0], wires=3)\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 46\n",
      "[332, 222, 313, 303, 233, 133, 433, 332]\n",
      "Fitness: 60.0%\n",
      "qml.CNOT(wires=[3, 2])\n",
      "qml.RZ(weights[0], wires=2)\n",
      "qml.CNOT(wires=[1, 3])\n",
      "qml.CNOT(wires=[0, 3])\n",
      "qml.RZ(weights[1], wires=3)\n",
      "qml.RX(weights[2], wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.CNOT(wires=[3, 2])\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 47\n",
      "[102, 303, 332, 403, 423, 331, 313]\n",
      "Fitness: 60.0%\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.CNOT(wires=[0, 3])\n",
      "qml.CNOT(wires=[3, 2])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.Hadamard(wires=2)\n",
      "qml.CNOT(wires=[3, 1])\n",
      "qml.CNOT(wires=[1, 3])\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 48\n",
      "[401, 222, 122, 231, 130, 431, 432]\n",
      "Fitness: 60.0%\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[0], wires=2)\n",
      "qml.RX(weights[1], wires=2)\n",
      "qml.RZ(weights[2], wires=3)\n",
      "qml.RX(weights[3], wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 49\n",
      "[401, 321, 402, 222, 130, 431, 211, 410, 401]\n",
      "Fitness: 60.0%\n",
      "qml.Hadamard(wires=0)\n",
      "qml.CNOT(wires=[2, 1])\n",
      "qml.Hadamard(wires=0)\n",
      "qml.RZ(weights[0], wires=2)\n",
      "qml.RX(weights[1], wires=3)\n",
      "qml.Hadamard(wires=3)\n",
      "qml.RZ(weights[2], wires=1)\n",
      "qml.Hadamard(wires=1)\n",
      "qml.Hadamard(wires=0)\n",
      "--------------------\n",
      "\n",
      "\n",
      "Individual 50\n",
      "[421, 100, 330, 413]\n",
      "Fitness: 60.0%\n",
      "qml.Hadamard(wires=2)\n",
      "qml.RX(weights[0], wires=0)\n",
      "qml.CNOT(wires=[3, 0])\n",
      "qml.Hadamard(wires=1)\n",
      "--------------------\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def decode_to_code(encoded_circuit):\n",
    "    weight_idx = 0\n",
    "    for encoded_gate in encoded_circuit:\n",
    "        wire2  = encoded_gate % 10\n",
    "        wire1 = (encoded_gate // 10) % 10\n",
    "        gate = (encoded_gate // 100) % 10\n",
    "\n",
    "        if gate == 1:\n",
    "            print(f\"qml.RX(weights[{weight_idx}], wires={wire1})\")\n",
    "            weight_idx += 1\n",
    "        elif gate == 2: \n",
    "            print(f\"qml.RZ(weights[{weight_idx}], wires={wire1})\")\n",
    "            weight_idx += 1\n",
    "        elif gate == 3:\n",
    "            print(f\"qml.CNOT(wires=[{wire1}, {wire2}])\")\n",
    "        elif gate == 4:\n",
    "            print(f\"qml.Hadamard(wires={wire1})\")\n",
    "\n",
    "\n",
    "for i in range(population_size):\n",
    "    print(f\"Individual {i+1}\")\n",
    "    print(final_population[i][0])\n",
    "    print(f\"Fitness: {100*-final_population[i][1]}%\")\n",
    "    decode_to_code(final_population[i][0])\n",
    "    print(\"-\" * 20)\n",
    "    print(\"\\n\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}