Projeto ab2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "92406fc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.datasets import mnist\n",
    "from keras import models\n",
    "from keras import layers\n",
    "from tensorflow.keras.utils import to_categorical"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28b80a02",
   "metadata": {},
   "source": [
    "# Carregamento dos dados de treino e teste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1b364388",
   "metadata": {},
   "outputs": [],
   "source": [
    "(train_images, train_labels), (test_images, test_labels) = mnist.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "90a00eef",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_images = train_images.reshape((60000, 28 * 28))\n",
    "train_images = train_images.astype('float32') / 255\n",
    "test_images = test_images.reshape((10000, 28 * 28))\n",
    "test_images = test_images.astype('float32') / 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e02e3a41",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_labels = to_categorical(train_labels)\n",
    "test_labels = to_categorical(test_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e06cf198",
   "metadata": {},
   "source": [
    "# Definição da classe NeuralNetwork"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5fc3ac39",
   "metadata": {},
   "outputs": [],
   "source": [
    "class NeuralNetwork:\n",
    "    \"\"\"\n",
    "    Esse classe serve apenas para agrupar a rede neural e sua acurácia\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self.network = models.Sequential()\n",
    "        self.network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28,)))\n",
    "        self.network.add(layers.Dense(10, activation='softmax'))\n",
    "        self.network.compile(optimizer='rmsprop',\n",
    "        loss='categorical_crossentropy',\n",
    "        metrics=['accuracy'])\n",
    "        \n",
    "        self.fitness = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cb572b9",
   "metadata": {},
   "source": [
    "# Funções do algoritmo genético"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b77b0db9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_pop(pop_size:int) -> list:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9117d7c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitness(nr:NeuralNetwork) -> int:\n",
    "    \"\"\"\n",
    "    Retorna a acurácia da rede neural nr referente às imagens\n",
    "    de treino\n",
    "    \"\"\"\n",
    "    train_loss, train_acc = network.network.evaluate(train_images, train_labels, verbose = 0)\n",
    "    return train_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c7bf4eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def crossover(parent1:NeuralNetwork, parent2:NeuralNetwork) -> list:\n",
    "    \"\"\"\n",
    "    Realiza o cruzamento entre o parent1 e a parent2 e retorna os dois filhos.\n",
    "    offspring1 possui os pesos da primeira camada de parent1 e da segunda camada de parent2\n",
    "    offspring2 possui os pesos da primeira camada de parent2 e da segunda camada de parent1\n",
    "    \"\"\"\n",
    "    offspring1 = NeuralNetwork()\n",
    "    \n",
    "    offspring2 = NeuralNetwork()\n",
    "\n",
    "    \n",
    "    p1_weights = [parent1.network.layers[0].get_weights(), parent1.network.layers[1].get_weights()]\n",
    "    p2_weights = [parent2.network.layers[0].get_weights(), parent2.network.layers[1].get_weights()]\n",
    "    \n",
    "    offspring1.network.layers[0].set_weights(p1_weights[0])\n",
    "    offspring1.network.layers[1].set_weights(p2_weights[1])\n",
    "    \n",
    "    offspring2.network.layers[0].set_weights(p2_weights[0])\n",
    "    offspring2.network.layers[1].set_weights(p1_weights[1])\n",
    "    \n",
    "    return [offspring1, offspring2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "00ac3980",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Mutação: altera o operador de um nó aleatório\n",
    "def mutation(nr:NeuralNetwork) -> NeuralNetwork:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f7766eef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def selection(pop, max_size, sel_type = 'elit'):\n",
    "    \n",
    "    t = len(pop)\n",
    "    \n",
    "    if(max_size > t ):\n",
    "        raise Exception(\"O tamanho máximo informado é inválido.\")\n",
    "    elif(max_size < 0):\n",
    "        raise Exception(\"O tamanho máximo informado é inválido.\")\n",
    "    \n",
    "    #ordena para executar a seleção elitista    \n",
    "    ordPop = sorted(pop, key = lambda ind: ind.fitness, reverse = True)\n",
    "    ordPop = ordPop[0:max_size]\n",
    "    \n",
    "    return ordPop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "544148d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def selection_parents(pop, rate):\n",
    "    \"\"\"Retorna uma população com número par de pais\"\"\"\n",
    "    #ordena para executar a seleção elitista\n",
    "    pop = sorted(pop, key = lambda ind: ind.fitness, reverse = True)\n",
    "    t = len(pop)\n",
    "    q_ind = math.ceil(t *rate)\n",
    "    \n",
    "    if(q_ind > t ):\n",
    "        raise Exception(\"Quantidade de individuos na população é muito pequena.\")\n",
    "    if (q_ind % 2) != 0:#arredonda para o maior inteiro par mais proximo\n",
    "        q_ind+=1\n",
    "        \n",
    "    parents = pop[0:q_ind]\n",
    "    return parents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20704d6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parents_crossover(parents):\n",
    "    \"Retorna os filhos criados pelos candidatos a pais\"\n",
    "    offsprings_ = []\n",
    "    \n",
    "    \n",
    "    random.shuffle(parents)#embaralha a lista de candidatos a pais\n",
    "    \n",
    "    for i in range(0, len(parents), 2):#cruza os pais 2 a 2\n",
    "        offsprings = crossover(parents[i], parents[i+1])\n",
    "        offsprings[0] = mutation(offsprings[0])#muta o filho\n",
    "        offsprings[1] = mutation(offsprings[1])#muta o filho\n",
    "        offsprings[0].fitness = fitness( offsprings[0])\n",
    "        offsprings[1].fitness = fitness( offsprings[1])\n",
    "        offsprings_.extend(offsprings)\n",
    "        \n",
    "    return offsprings_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54a4f3d5",
   "metadata": {},
   "source": [
    "# Parametros do algoritmo genético"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "24811eba",
   "metadata": {},
   "outputs": [],
   "source": [
    "SIZE_POP = 100 # tamanho da população"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fc94fd0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "CROSS_RATE = 0.6 #taxa de cruzamento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "19290cfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "MUT_CHANCE = 5 #chance de mutação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9b60a590",
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_GEN = 100 # Quantidade máxima de gerações"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efd53e80",
   "metadata": {},
   "source": [
    "# Treino da rede com método padrão"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cd0bed1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "network = NeuralNetwork()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "593f398a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "469/469 [==============================] - 18s 34ms/step - loss: 0.2582 - accuracy: 0.9255\n",
      "Epoch 2/5\n",
      "469/469 [==============================] - 16s 34ms/step - loss: 0.1044 - accuracy: 0.9702\n",
      "Epoch 3/5\n",
      "469/469 [==============================] - 16s 34ms/step - loss: 0.0681 - accuracy: 0.9795\n",
      "Epoch 4/5\n",
      "469/469 [==============================] - 16s 35ms/step - loss: 0.0493 - accuracy: 0.98521s -\n",
      "Epoch 5/5\n",
      "469/469 [==============================] - 16s 35ms/step - loss: 0.0364 - accuracy: 0.9885\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x19b3e79eeb0>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "network.network.fit(train_images, train_labels, epochs=5, batch_size=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3870ecd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 3s 9ms/step - loss: 0.0760 - accuracy: 0.9755\n"
     ]
    }
   ],
   "source": [
    "test_loss, test_acc = network.network.evaluate(test_images, test_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14c231e9",
   "metadata": {},
   "source": [
    "# Treino da rede com algoritmo genético"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb490189",
   "metadata": {},
   "source": [
    "# Testes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b1eff19e",
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = NeuralNetwork()\n",
    "p2 = NeuralNetwork()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "825f4b70",
   "metadata": {},
   "outputs": [],
   "source": [
    "off1, off2 = crossover(p1, p2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "4a8f8a98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 3s 8ms/step - loss: 2.2346 - accuracy: 0.1765\n"
     ]
    }
   ],
   "source": [
    "tloff1, taoff1 = off1.network.evaluate(test_images, test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2da8300",
   "metadata": {},
   "outputs": [],
   "source": [
    "tloff2, taoff2 = off2.network.evaluate(test_images, test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "bd59feba",
   "metadata": {},
   "outputs": [],
   "source": [
    "off1.fitness = fitness(off1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "aedd537f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9922500252723694"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "off1.fitness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "665eede9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}