{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Crea una Red Neuronal Artificial en Python" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Crearemos una red neuronal simple, con 3 capas, neuronas con valores de entrada/salida -1 a 1" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2018-07-25T10:30:57.447541Z", "start_time": "2018-07-25T10:30:56.855041Z" } }, "outputs": [], "source": [ "import numpy as np\n", "\n", "def sigmoid(x):\n", " return 1.0/(1.0 + np.exp(-x))\n", "\n", "def sigmoid_derivada(x):\n", " return sigmoid(x)*(1.0-sigmoid(x))\n", "\n", "def tanh(x):\n", " return np.tanh(x)\n", "\n", "def tanh_derivada(x):\n", " return 1.0 - x**2\n", "\n", "\n", "class NeuralNetwork:\n", "\n", " def __init__(self, layers, activation='tanh'):\n", " if activation == 'sigmoid':\n", " self.activation = sigmoid\n", " self.activation_prime = sigmoid_derivada\n", " elif activation == 'tanh':\n", " self.activation = tanh\n", " self.activation_prime = tanh_derivada\n", "\n", " # inicializo los pesos\n", " self.weights = []\n", " self.deltas = []\n", " # capas = [2,3,2]\n", " # rando de pesos varia entre (-1,1)\n", " # asigno valores aleatorios a capa de entrada y capa oculta\n", " for i in range(1, len(layers) - 1):\n", " r = 2*np.random.random((layers[i-1] + 1, layers[i] + 1)) -1\n", " self.weights.append(r)\n", " # asigno aleatorios a capa de salida\n", " r = 2*np.random.random( (layers[i] + 1, layers[i+1])) - 1\n", " self.weights.append(r)\n", "\n", " def fit(self, X, y, learning_rate=0.2, epochs=100000):\n", " # Agrego columna de unos a las entradas X\n", " # Con esto agregamos la unidad de Bias a la capa de entrada\n", " ones = np.atleast_2d(np.ones(X.shape[0]))\n", " X = np.concatenate((ones.T, X), axis=1)\n", " \n", " for k in range(epochs):\n", " i = np.random.randint(X.shape[0])\n", " a = [X[i]]\n", "\n", " for l in range(len(self.weights)):\n", " dot_value = np.dot(a[l], self.weights[l])\n", " activation = self.activation(dot_value)\n", " a.append(activation)\n", " # Calculo la diferencia en la capa de salida y el valor obtenido\n", " error = y[i] - a[-1]\n", " deltas = [error * self.activation_prime(a[-1])]\n", " \n", " # Empezamos en el segundo layer hasta el ultimo\n", " # (Una capa anterior a la de salida)\n", " for l in range(len(a) - 2, 0, -1): \n", " deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_prime(a[l]))\n", " self.deltas.append(deltas)\n", "\n", " # invertir\n", " # [level3(output)->level2(hidden)] => [level2(hidden)->level3(output)]\n", " deltas.reverse()\n", "\n", " # backpropagation\n", " # 1. Multiplcar los delta de salida con las activaciones de entrada \n", " # para obtener el gradiente del peso.\n", " # 2. actualizo el peso restandole un porcentaje del gradiente\n", " for i in range(len(self.weights)):\n", " layer = np.atleast_2d(a[i])\n", " delta = np.atleast_2d(deltas[i])\n", " self.weights[i] += learning_rate * layer.T.dot(delta)\n", "\n", " if k % 10000 == 0: print('epochs:', k)\n", "\n", " def predict(self, x): \n", " ones = np.atleast_2d(np.ones(x.shape[0]))\n", " a = np.concatenate((np.ones(1).T, np.array(x)), axis=0)\n", " for l in range(0, len(self.weights)):\n", " a = self.activation(np.dot(a, self.weights[l]))\n", " return a\n", "\n", " def print_weights(self):\n", " print(\"LISTADO PESOS DE CONEXIONES\")\n", " for i in range(len(self.weights)):\n", " print(self.weights[i])\n", "\n", " def get_deltas(self):\n", " return self.deltas" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Creamos una Primer Red emulando a la función XOR" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2018-07-25T10:30:58.202079Z", "start_time": "2018-07-25T10:30:57.449918Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epochs: 0\n", "Entrdas: [0 0] Salidas: [0.00118339]\n", "Entrdas: [0 1] Salidas: [0.97403459]\n", "Entrdas: [1 0] Salidas: [0.96119404]\n", "Entrdas: [1 1] Salidas: [0.00257987]\n" ] } ], "source": [ "# funcion XOR\n", "nn = NeuralNetwork([2,2,1])\n", "X = np.array([[0, 0],\n", " [0, 1],\n", " [1, 0],\n", " [1, 1]])\n", "y = np.array([0, 1, 1, 0])\n", "nn.fit(X, y,epochs=2000)\n", "for e in X:\n", " print(\"Entrdas:\",e,\"Salidas:\",nn.predict(e))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Comportamiento de un Coche Robot" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Crearemos una red neuronal que nos dará los pesos para las conexiones que utilizaremos en un coche robot Arduino" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2018-07-25T10:30:58.780875Z", "start_time": "2018-07-25T10:30:58.204952Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epochs: 0\n", "epochs: 10000\n", "X: [0. 0.] y: [0 1] Network: [-0.00419241 0.99998706]\n", "X: [0. 1.] y: [0 1] Network: [0.00213055 0.99997811]\n", "X: [ 0. -1.] y: [0 1] Network: [-3.09682297e-04 9.99951487e-01]\n", "X: [0.5 1. ] y: [-1 1] Network: [-0.94914109 0.94511784]\n", "X: [ 0.5 -1. ] y: [1 1] Network: [0.95643017 0.95122983]\n", "X: [1. 1.] y: [ 0 -1] Network: [-0.00427929 -0.95818922]\n", "X: [ 1. -1.] y: [ 0 -1] Network: [ 0.00966145 -0.96866856]\n" ] } ], "source": [ "# funcion Coche Evita obstáculos\n", "nn = NeuralNetwork([2,3,2],activation ='tanh')\n", "X = np.array([[0, 0], # sin obstaculos\n", " [0, 1], # sin obstaculos\n", " [0, -1], # sin obstaculos\n", " [0.5, 1], # obstaculo detectado a derecha\n", " [0.5,-1], # obstaculo a izq\n", " [1,1], # demasiado cerca a derecha\n", " [1,-1]]) # demasiado cerca a izq\n", "\n", "y = np.array([[0,1], # avanzar\n", " [0,1], # avanzar\n", " [0,1], # avanzar\n", " [-1,1], # giro izquierda\n", " [1,1], # giro derecha\n", " [0,-1], # retroceder\n", " [0,-1]]) # retroceder\n", "nn.fit(X, y, learning_rate=0.03,epochs=15001)\n", "\n", "index=0\n", "for e in X:\n", " print(\"X:\",e,\"y:\",y[index],\"Network:\",nn.predict(e))\n", " index=index+1\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2018-07-25T10:30:58.790786Z", "start_time": "2018-07-25T10:30:58.783641Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "LISTADO PESOS DE CONEXIONES\n", "[[ 0.0493491 -1.57512575 -1.55094348 -1.21806285]\n", " [ 0.15904356 3.2306243 3.02890889 -0.88735754]\n", " [ 0.92710662 -0.81186343 0.73500885 -0.05581318]]\n", "[[ 0.8537068 0.30089786]\n", " [ 1.88818793 -2.09159023]\n", " [-1.94124822 -2.65951456]\n", " [ 0.10419137 -1.91738651]]\n" ] } ], "source": [ "nn.print_weights()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Graficamos la función coste " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vemos como el gradiente desciende y disminuye el error a medida que pasan las iteraciones de aprendizaje" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2018-07-25T10:31:40.473536Z", "start_time": "2018-07-25T10:31:40.183342Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "deltas = nn.get_deltas()\n", "valores=[]\n", "index=0\n", "for arreglo in deltas:\n", " valores.append(arreglo[1][0] + arreglo[1][1])\n", " index=index+1\n", "\n", "plt.plot(range(len(valores)), valores, color='b')\n", "plt.ylim([0, 1])\n", "plt.ylabel('Cost')\n", "plt.xlabel('Epochs')\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "ExecuteTime": { "end_time": "2018-07-25T10:25:56.999747Z", "start_time": "2018-07-25T10:25:56.975198Z" } }, "source": [ "Lee el artículo completo en www.aprendemachinelearning.com" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sigeme en Twitter @jbagnato" ] }, { "cell_type": "code", "execution_count": null, "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 }