# Redes Neuronales

Inicialmente, las redes neuronales fueron inspiradas en el cerebro humano. Sin embargo, después de cierto tiempo se ha dejado de tratar de emular cómo funciona el cerebro y se ha tomado un enfoque en encontrar las configuraciones más apropiadas de las redes neuronales para desarrollar diferentes tareas, incluyendo visión artificial, procesamiento de lenguaje natural y reconocimiento de voz. 
    
    
Se puede describir una red neuronal como un modelo matemático para procesamiento de información. 

- El procesamiento de información se realiza en las neuronas.
- Las neuronas son conectadas e intercambian información y señales entre ellas a través de enlaces de conexión. 
- Los enlaces de conexión entre las neuronas pueden ser fuertes o débiles y esto determina cómo la información es procesada. 
- Cada neurona tiene un estado interno que es determinado por todas las conexiones con otras neuronas. 
- Cada neurona tiene una función de activación que es calculada en su estado y determina la señal de salida de la neurona. 
    
Se pueden identificar dos características principales para una red neuronal.

- Arquitectura de la red: Esto describe el conjunto de conexiones, es decir "feedforward", "recurrent", "multi/single layered" y así.  
- El aprendizaje: Describe lo que comúnmente se denomina entrenamiento. La forma más común es descenso de gradiente y backpropagation. 

Una neurona es una función matemática que toma uno o más valores de entrada y calcula una salida como un valor numérico.
   
   
    
Una neurona está definida como

\begin{equation}
y=f(\sum_{i} x_i w_i +b)
\end{equation}
    
1. Primero se calcula el valor $\sum x_i w_i$ de las entradas $x_i$ y los pesos $w_i$. Aquí $x_i$ son los valores de entrada numéricos o las salidas de otras neuronas.
2. Los pesos $w_i$ son valores numéricos que representan la fuerza de las entradas o, alternativamente, la fuerza de las conexiones entre las neuronas. 
3. Los pesos $b$ son los valores especiales cuya entrada es 1. 

Luego se utiliza la suma pesada de una entrada hacia la función de activación $f$, cuyo valor es conocido como función de transferencia. Hay muchos tipos de funciones de activación, pero en general tienen el requerimiento de ser no lineales. 


# Tipos de funciones de activación. 

- f(a)=a. Esta función de activación es conocida como la identidad. 
- f(a)=0 o 1. 
- f(a)=$\frac{1}{1+exp(-a)}$. Esta función es la más usada comunmente, uede ser interpretada como la probabilidad de una neurona de activarse. 
- f(a)=$\frac{2}{1+exp(-a)}-1$: Esta función de activación es llamada sigmoide bipolar y es simplemente una sigmoide logística reescalada y traducida al rango {-1,1}
- f(a)=$\frac{exp(a)-exp(-a)}{exp(a)+exp(-a)}$. Esta función de activación es llamada tangente hiperbólica. 
- f(a)=$a$ si $a\geq 0$, o $0$ si $a<0$. Esta función de activación es probablemente la más cercana a su contraparte biológica. Es una mezcla de la identidad y una función de umbral. 



```python
# Ejercicio: Hacer las funciones de activación previas

import numpy as np
import matplotlib.pyplot as plt
a=np.linspace(-5,5,100)

def ida(a):
    return a
def taf(a):
    return np.sign(a)
    
def sigmoid(a):
    return 1/(1+np.exp(-a))

def bip(a):
    return 2/(1+np.exp(-a))-1

def tanh(a):
    return np.tanh(a)
def relu(a):
    return a*(np.sign(a)*0.5+0.5)



plt.plot(a,relu(a))


plt.show()
```


```python
import matplotlib.pyplot as plt
import numpy 

weight_value=1000

#Se modifica para cambiar donde empieza la función de escalón
bias_value_1=5000

# Dice dónde el escalóln termina
bias_value_2=-5000

plt.axis([-10,10,-1,10])

print("la función de escalon empieza en {0} y termina en {1}".format(-bias_value_1/weight_value,-bias_value_2/weight_value))

inputs=numpy.arange(-10,10,0.01)
outputs=list()

for x in inputs:
    y1=1.0/(1.0+numpy.exp(-weight_value*x-bias_value_1))
    y2=1.0/(1.0+numpy.exp(-weight_value*x-bias_value_2))
    
    w=7
    y=y1*w-y2*w
    
    outputs.append(y)
plt.plot(inputs,outputs,lw=2,color="black")
plt.show()

```


```python
from matplotlib.colors import ListedColormap
import numpy as np


def tanh(x): return (1.0-np.exp(-2*x))/(1.0+np.exp(-2*x))
def tanh_derivative(x): 
    return (1+tanh(x))*(1-tanh(x))

class NeuralNetwork:
    def __init__(self, net_arch):
        self.activation_func = tanh
        self.activation_derivative = tanh_derivative
        self.layers = len(net_arch)
        self.steps_per_epoch = 1000
        self.net_arch = net_arch
        self.weights=[]
        
        for layer in range(len(net_arch) - 1):
            w = 2 * np.random.rand(net_arch[layer] + 1,net_arch[layer + 1]) - 1
            self.weights.append(w)
        
    def fit(self, data, labels, learning_rate=0.1, epochs=10):
        ones = np.ones((1, data.shape[0]))
        Z = np.concatenate((ones.T, data), axis=1)
        training = epochs * self.steps_per_epoch
        for k in range(training):
            if k % self.steps_per_epoch == 0:
                print("epochs: {}".format(k/self.steps_per_epoch))
                for s in data:
                    print(s,nn.predict(s))
        sample=np.random.randint(data.shape[0])
        y=[Z[sample]]

        for i in range(len(self.weights) - 1):
            activation = np.dot(y[i], self.weights[i])
            activation_f = self.activation_func(activation)

            activation_f = np.concatenate((np.ones(1), np.array(activation_f)))
            y.append(activation_f)

        activation = np.dot(y[-1], self.weights[-1])
        activation_f = self.activation_func(activation)
        y.append(activation_f)
        
        error = labels[sample] - y[-1]
        delta_vec = [error * self.activation_derivative(y[-1])]        
        
        for i in range(self.layers - 2, 0, -1):
            error = delta_vec[-1].dot(self.weights[i][1:].T)
            error = error * self.activation_derivative(y[i][1:])
            delta_vec.append(error)
        delta_vec.reverse()
            
        for i in range(len(self.weights)):
            layer = y[i].reshape(1, nn.net_arch[i] + 1)
            delta = delta_vec[i].reshape(1,nn.net_arch[i + 1] )
            self.weights[i] += learning_rate * layer.T.dot(delta)
                
    def predict(self, x):
        val=np.concatenate((np.ones(1).T,np.array(x)))
        for i in range(0,len(self.weights)):
            val = self.activation_func(np.dot(val, self.weights[i]))
            val = np.concatenate((np.ones(1).T, np.array(val)))
        return val[1]
    
    def plot_decision_regions(self,X,y,points=200):
        markers=('o','^')
        colors=('red','blue')
        cmap=ListedColormap(colors)
        
        x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
        x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
        
        resolution=max(x1_max-x1_min,x2_max-x2_min)/float(points)
        
        xx1, xx2 = np.meshgrid(np.arange(x1_min,x1_max,resolution),np.arange(x2_min, x2_max,resolution))

        input=np.array([xx1.ravel(),xx2.ravel()]).T
        Z=np.empty(0)
        for i in range(input.shape[0]):
            val=nn.predict(np.array(input[i]))
            if val < 0.5:
                val = 0
            if val >= 0.5:
                val = 1
            Z = np.append(Z, val)
        Z = Z.reshape(xx1.shape)
        plt.pcolormesh(xx1, xx2, Z, cmap=cmap)
        plt.xlim(xx1.min(), xx1.max())
        plt.ylim(xx2.min(), xx2.max())

        classes = ["False", "True"]
        for idx, cl in enumerate(np.unique(y)):
            plt.scatter(x=X[y == cl, 0],
            y=X[y == cl, 1],
            alpha=1.0,
            c=colors[idx],
            edgecolors='black',
            marker=markers[idx],
            s=80,
            label=classes[idx])
        plt.xlabel('x-axis')
        plt.ylabel('y-axis')
        plt.legend(loc='upper left')
        plt.show()
        
        
if __name__=='__main__':
    np.random.seed(0)
    nn = NeuralNetwork([2, 2, 1])
    X = np.array([[0, 0],
    [0, 1],
    [1, 0],
    [1, 1]])
    y = np.array([0, 0, 1, 1])
    nn.fit(X, y, epochs=10)
    print("Final prediction")
    for s in X:
        print(s, nn.predict(s))
        nn.plot_decision_regions(X, y)
```

# Aprendizaje de características

Para ilustrar cómo funciona el aprendizaje profundo, consideremos la tarea de reconocer una simple figura geométrica, por ejemplo, un cubo, como se ve en el siguiente diagrama. El cubo es compuesto de bordes (o líneas), que se cruzan en vértices. Digamos que cada punto posible en el espacio tridimensional está asociado con una neurona (olvide por un momento que esto requerirá un número infinito de neuronas). Todos los puntos / neuronas están en la primera (entrada) capa de una red de alimentación de múltiples capas. Un punto de entrada / neurona está activo si el punto correspondiente se encuentra en una línea. Los puntos / neuronas que se encuentran en una línea común (borde) tener fuertes conexiones positivas con un solo borde / neurona común en la siguiente capa. Por el contrario, tienen conexiones negativas con todas las demás neuronas en la siguiente capa. Lo único excepción son las neuronas que se encuentran en los vértices. Cada una de esas neuronas se encuentra simultáneamente en tres bordes, y está conectado a sus tres neuronas correspondientes en la capa posterior. 


Ahora tenemos dos capas ocultas, con diferentes niveles de abstracción: la primera para los puntos. y el segundo para bordes. Pero esto no es suficiente para codificar un cubo completo en la red. Probemos con otra capa para vértices. Aquí, cada tres bordes activos / neuronas del segundo capa, que forma un vértice, tiene una conexión positiva significativa a un único común vértice / neurona de la tercera capa. Como un borde del cubo forma dos vértices, cada uno borde / neurona tendrá conexiones positivas a dos vértices / neuronas y negativas conexiones a todos los demás. Finalmente, presentaremos la última capa oculta (cubo). El cuatro los vértices / neuronas que forman un cubo tendrán conexiones positivas con un solo cubo / neurona del cubo /capa:



El ejemplo de representación del cubo está demasiado simplificado, pero podemos sacar varias conclusiones
de eso. Una de ellas es que las redes neuronales profundas se prestan bien jerárquicamente datos organizados Por ejemplo, una imagen consta de píxeles, que forman líneas, bordes, regiones, y así. Esto también es cierto para el habla, donde los bloques de construcción se llaman fonemas; como así como texto, donde tenemos caracteres, palabras y oraciones. En el ejemplo anterior, dedicamos capas a entidades de cubo específicas deliberadamente, pero en practica, no haríamos eso. En cambio, una red profunda "descubrirá" características automáticamente durante el entrenamiento. Estas características pueden no ser inmediatamente obvias y, en en general, no sería interpretable por los humanos. Además, no sabríamos el nivel de características codificadas en las diferentes capas de la red. Nuestro ejemplo es más parecido al clásico. algoritmos de aprendizaje automático, donde el usuario tiene que usar su propia experiencia para seleccionar lo que ellos piensan son las mejores características. Este proceso se llama ingeniería de características, y puede ser laborioso y lento. Permitir que una red descubra automáticamente las características no solo son más fáciles, sino que son muy abstractas, lo que las hace menos sensible al ruido. Por ejemplo, la visión humana puede reconocer objetos de diferentes formas, tamaños, en diferentes condiciones de iluminación, e incluso cuando su vista está parcialmente oscurecida. Podemos reconocer a las personas con diferentes cortes de pelo, rasgos faciales e incluso cuando usan un sombrero o un bufanda que les cubre la boca. Del mismo modo, las características abstractas que aprende la red lo ayudarán para reconocer mejor las caras, incluso en condiciones más difíciles.

# Algoritmos de Deep Learning

Podríamos definir el aprendizaje profundo como una clase de técnicas de aprendizaje automático, donde la información se procesa en capas jerárquicas para comprender las representaciones y características de los datos en niveles crecientes de complejidad. En la práctica, todos los algoritmos de aprendizaje profundo son redes neuronales, que comparten algunas propiedades básicas comunes. Todos consisten en neuronas interconectadas que están organizadas en capas. En lo que difieren es en la arquitectura de la red (o la forma en que las neuronas están organizadas en la red) y, a veces, en la forma en que se entrenan. Con eso en mente, echemos un vistazo a las principales clases de redes neuronales. La siguiente lista no es exhaustiva, pero representa la gran mayoría de los algoritmos en uso hoy en día:

- Perceptrones multicapa (MLP): una red neuronal con propagación de alimentación directa, capas completamente conectadas y al menos una capa oculta. 

- Redes neuronales convolucionales (CNN): una CNN es una red neuronal con varios tipos de capas especiales. Por ejemplo, las capas convolucionales aplican un filtro a la imagen de entrada (o sonido) deslizando ese filtro por toda la señal entrante, para producir un mapa de activación n-dimensional. Existe alguna evidencia de que las neuronas en las CNN se organizan de manera similar a cómo se organizan las células biológicas en la corteza visual del cerebro. Hemos mencionado CNN varias veces hasta ahora, y eso no es una coincidencia: hoy, superan a todos los demás algoritmos de ML en una gran cantidad de tareas de visión por computadora y PNL.

- Redes recurrentes: este tipo de red tiene un estado interno (o memoria), que se basa en la totalidad o en parte de los datos de entrada ya alimentados a la red. La salida de una red recurrente es una combinación de su estado interno (memoria de entradas) y la última muestra de entrada. Al mismo tiempo, el estado interno cambia para incorporar datos recién ingresados. Debido a estas propiedades, las redes recurrentes son buenas candidatas para tareas que funcionan en datos secuenciales, como texto o datos de series de tiempo.

- Codificadores automáticos: una clase de algoritmos de aprendizaje no supervisados, en los que la forma de salida es la misma que la entrada que permite a la red aprender mejor las representaciones básicas.


```python

```

# Softmax y entropía cruzada
La función softmax es una generalización del concepto de regresión logística para múltiples clases. Veamos la siguiente fórmula: 

\begin{equation}
F(x_i)=\frac{e^{x_i}}{\sum_{j=1}^{n}e^{x_j}}
\end{equation}


Aquí, i, j = 0, 1, 2, ... ny xi representan cada uno de n valores reales arbitrarios, correspondientes a n clases mutuamente excluyentes. El softmax "aplasta" los valores de entrada en el intervalo (0, 1), similar a la función logística. Pero tiene la propiedad adicional de que la suma de todas las salidas aplastadas suma 1. Podemos interpretar las salidas softmax como una distribución de probabilidad normalizada de las clases. Entonces, tiene sentido usar una función de pérdida, que compara la diferencia entre las probabilidades de clase estimadas y la distribución de clase real (la diferencia se conoce como crossentropía). Como mencionamos en el paso 5 de esta sección, la distribución real suele ser un vector codificado en caliente, donde la clase real tiene una probabilidad de 1, y todos los demás tienen una probabilidad de 0. La función de pérdida que hace esto se llama Pérdida de entropía cruzada: 

\begin{equation}
H(p,q)=\sum_{i=1}^{n}{p_i(x)log(q_i (x))}
\end{equation}

Aquí, qi (x) es la probabilidad estimada de que la salida pertenezca a la clase i (de n clases totales) y pi (x) es la probabilidad real. Cuando utilizamos valores objetivo codificados en caliente para pi (x), solo la clase objetivo tiene un valor distinto de cero (1) y todos los demás son ceros. En este caso, la pérdida de entropía cruzada solo capturará el error en la clase de destino y descartará todos los demás errores. En aras de la simplicidad, asumiremos que aplicamos la fórmula
sobre una sola muestra de entrenamiento.


```python
import warnings
warnings.filterwarnings("ignore")
```


```python
import tensorflow
with tensorflow.device("/gpu:1"):
    pass
# model definition here
#Here's an example:
#"/cpu:0": the main CPU of your machine
#"/gpu:0": the first GPU of your machine, if one exists
#"/gpu:1": the second GPU of your machine, if a second exists
#"/gpu:2": the third GPU of your machine, if a third exists, and so on

```


```python
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.utils import np_utils

(X_train,Y_train),(X_test,Y_test)=mnist.load_data()
plt.imshow(X_test[0])
X_train=X_train.reshape(60000,784)
X_test=X_test.reshape(10000,784)

import matplotlib.pyplot as plt



classes=10
Y_train=np_utils.to_categorical(Y_train,classes)
Y_test=np_utils.to_categorical(Y_test,classes)
print(Y_test[0])
input_size=784
batch_size=100
hidden_neurons=100
epochs=10

model=Sequential([Dense(hidden_neurons,input_dim=input_size), Activation('sigmoid'),Dense(classes),Activation('softmax')])

model.compile(loss='categorical_crossentropy',metrics=['accuracy'],optimizer='sgd')

model.fit(X_train,Y_train,batch_size=batch_size,nb_epoch=epochs,verbose=1)

score=model.evaluate(X_test,Y_test,verbose=1)

print('Test accuracy:',score)

weights=model.layers[0].get_weights()


```


```python

```


```python
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy
fig = plt.figure()
w = weights[0].T
for neuron in range(hidden_neurons):
    ax = fig.add_subplot(10, 10, neuron + 1)
    ax.axis("off")
    ax.imshow(numpy.reshape(w[neuron], (28, 28)), cmap=cm.Greys_r)
plt.show()
```


```python
from keras.datasets import cifar10
from keras.layers.core import Dense, Activation
from keras.models import Sequential
from keras.utils import np_utils

(X_train, Y_train), (X_test, Y_test) = cifar10.load_data()

X_train = X_train.reshape(50000, 3072)
X_test = X_test.reshape(10000, 3072)
classes = 10
Y_train = np_utils.to_categorical(Y_train, classes)
Y_test = np_utils.to_categorical(Y_test, classes)
input_size = 3072
batch_size = 100
epochs = 100

model = Sequential([Dense(1024, input_dim=input_size),Activation('relu'),Dense(512),Activation('relu'),Dense(512),Activation('sigmoid'),Dense(classes),Activation('softmax')])

model.compile(loss='categorical_crossentropy',metrics=['accuracy'],optimizer='sgd')

model.fit(X_train, Y_train, batch_size=batch_size, epochs=epochs,validation_data=(X_test, Y_test), verbose=1)

```

    Train on 50000 samples, validate on 10000 samples
    Epoch 1/100
    50000/50000 [==============================] - 5s 100us/step - loss: 2.1783 - acc: 0.1827 - val_loss: 2.0974 - val_acc: 0.2161
    Epoch 2/100
    50000/50000 [==============================] - 4s 76us/step - loss: 2.0231 - acc: 0.2486 - val_loss: 1.9859 - val_acc: 0.2604
    Epoch 3/100
    50000/50000 [==============================] - 4s 77us/step - loss: 1.9524 - acc: 0.2854 - val_loss: 1.9488 - val_acc: 0.2747
    Epoch 4/100
    50000/50000 [==============================] - 4s 77us/step - loss: 1.9187 - acc: 0.3005 - val_loss: 1.8829 - val_acc: 0.3214
    Epoch 5/100
    50000/50000 [==============================] - 4s 78us/step - loss: 1.8811 - acc: 0.3198 - val_loss: 1.8578 - val_acc: 0.3231
    Epoch 6/100
    50000/50000 [==============================] - 4s 76us/step - loss: 1.8533 - acc: 0.3292 - val_loss: 1.8288 - val_acc: 0.3348
    Epoch 7/100
    50000/50000 [==============================] - 4s 79us/step - loss: 1.8185 - acc: 0.3415 - val_loss: 1.8235 - val_acc: 0.3455
    Epoch 8/100
    50000/50000 [==============================] - 4s 77us/step - loss: 1.7925 - acc: 0.3528 - val_loss: 1.7932 - val_acc: 0.3574
    Epoch 9/100
    50000/50000 [==============================] - 4s 79us/step - loss: 1.7643 - acc: 0.3618 - val_loss: 1.7683 - val_acc: 0.3660
    Epoch 10/100
    50000/50000 [==============================] - 4s 79us/step - loss: 1.7477 - acc: 0.3680 - val_loss: 1.7113 - val_acc: 0.3798
    Epoch 11/100
    50000/50000 [==============================] - 4s 83us/step - loss: 1.7303 - acc: 0.3756 - val_loss: 1.7235 - val_acc: 0.3854
    Epoch 12/100
    50000/50000 [==============================] - 4s 79us/step - loss: 1.7080 - acc: 0.3866 - val_loss: 1.6981 - val_acc: 0.3877
    Epoch 13/100
    50000/50000 [==============================] - 4s 78us/step - loss: 1.6914 - acc: 0.3921 - val_loss: 1.6913 - val_acc: 0.3967
    Epoch 14/100
    50000/50000 [==============================] - 4s 78us/step - loss: 1.6767 - acc: 0.3951 - val_loss: 1.6676 - val_acc: 0.4020
    Epoch 15/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.6661 - acc: 0.4009 - val_loss: 1.6577 - val_acc: 0.4085
    Epoch 16/100
    50000/50000 [==============================] - 6s 118us/step - loss: 1.6457 - acc: 0.4126 - val_loss: 1.7004 - val_acc: 0.3944
    Epoch 17/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.6359 - acc: 0.4142 - val_loss: 1.6234 - val_acc: 0.4179
    Epoch 18/100
    50000/50000 [==============================] - 5s 90us/step - loss: 1.6218 - acc: 0.4163 - val_loss: 1.6255 - val_acc: 0.4162
    Epoch 19/100
    50000/50000 [==============================] - 4s 80us/step - loss: 1.6055 - acc: 0.4247 - val_loss: 1.6418 - val_acc: 0.4101
    Epoch 20/100
    50000/50000 [==============================] - 4s 79us/step - loss: 1.5900 - acc: 0.4304 - val_loss: 1.5921 - val_acc: 0.4355
    Epoch 21/100
    50000/50000 [==============================] - 4s 79us/step - loss: 1.5807 - acc: 0.4339 - val_loss: 1.5878 - val_acc: 0.4314
    Epoch 22/100
    50000/50000 [==============================] - 4s 79us/step - loss: 1.5672 - acc: 0.4397 - val_loss: 1.5928 - val_acc: 0.4314
    Epoch 23/100
    50000/50000 [==============================] - 4s 79us/step - loss: 1.5570 - acc: 0.4408 - val_loss: 1.5611 - val_acc: 0.4385
    Epoch 24/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.5523 - acc: 0.4444 - val_loss: 1.5583 - val_acc: 0.4416
    Epoch 25/100
    50000/50000 [==============================] - 4s 80us/step - loss: 1.5449 - acc: 0.4457 - val_loss: 1.5478 - val_acc: 0.4471
    Epoch 26/100
    50000/50000 [==============================] - 4s 80us/step - loss: 1.5267 - acc: 0.4555 - val_loss: 1.5635 - val_acc: 0.4446
    Epoch 27/100
    50000/50000 [==============================] - 4s 78us/step - loss: 1.5233 - acc: 0.4553 - val_loss: 1.5280 - val_acc: 0.4497
    Epoch 28/100
    50000/50000 [==============================] - 4s 88us/step - loss: 1.5114 - acc: 0.4575 - val_loss: 1.5298 - val_acc: 0.4555
    Epoch 29/100
    50000/50000 [==============================] - 4s 81us/step - loss: 1.5086 - acc: 0.4592 - val_loss: 1.5356 - val_acc: 0.4525
    Epoch 30/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.4947 - acc: 0.4649 - val_loss: 1.5176 - val_acc: 0.4576
    Epoch 31/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.4896 - acc: 0.4693 - val_loss: 1.4967 - val_acc: 0.4678
    Epoch 32/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.4837 - acc: 0.4698 - val_loss: 1.5119 - val_acc: 0.4597
    Epoch 33/100
    50000/50000 [==============================] - 5s 90us/step - loss: 1.4720 - acc: 0.4724 - val_loss: 1.4917 - val_acc: 0.4630
    Epoch 34/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.4652 - acc: 0.4748 - val_loss: 1.4913 - val_acc: 0.4689
    Epoch 35/100
    50000/50000 [==============================] - 4s 88us/step - loss: 1.4564 - acc: 0.4777 - val_loss: 1.4959 - val_acc: 0.4650
    Epoch 36/100
    50000/50000 [==============================] - 4s 83us/step - loss: 1.4468 - acc: 0.4819 - val_loss: 1.5042 - val_acc: 0.4574
    Epoch 37/100
    50000/50000 [==============================] - 4s 81us/step - loss: 1.4442 - acc: 0.4832 - val_loss: 1.4873 - val_acc: 0.4634
    Epoch 38/100
    50000/50000 [==============================] - 4s 85us/step - loss: 1.4353 - acc: 0.4842 - val_loss: 1.5064 - val_acc: 0.4617
    Epoch 39/100
    50000/50000 [==============================] - 4s 81us/step - loss: 1.4346 - acc: 0.4874 - val_loss: 1.4934 - val_acc: 0.4643
    Epoch 40/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.4173 - acc: 0.4946 - val_loss: 1.4545 - val_acc: 0.4791
    Epoch 41/100
    50000/50000 [==============================] - 4s 83us/step - loss: 1.4078 - acc: 0.4989 - val_loss: 1.4925 - val_acc: 0.4653
    Epoch 42/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.4132 - acc: 0.4958 - val_loss: 1.4676 - val_acc: 0.4753
    Epoch 43/100
    50000/50000 [==============================] - 5s 95us/step - loss: 1.4011 - acc: 0.4976 - val_loss: 1.4602 - val_acc: 0.4816
    Epoch 44/100
    50000/50000 [==============================] - 5s 100us/step - loss: 1.3979 - acc: 0.4978 - val_loss: 1.4389 - val_acc: 0.4843
    Epoch 45/100
    50000/50000 [==============================] - 5s 108us/step - loss: 1.3876 - acc: 0.5055 - val_loss: 1.4901 - val_acc: 0.4696
    Epoch 46/100
    50000/50000 [==============================] - 5s 96us/step - loss: 1.3902 - acc: 0.5007 - val_loss: 1.5024 - val_acc: 0.4686
    Epoch 47/100
    50000/50000 [==============================] - 5s 96us/step - loss: 1.3798 - acc: 0.5080 - val_loss: 1.4699 - val_acc: 0.4767
    Epoch 48/100
    50000/50000 [==============================] - 5s 97us/step - loss: 1.3802 - acc: 0.5057 - val_loss: 1.4573 - val_acc: 0.4829
    Epoch 49/100
    50000/50000 [==============================] - 4s 88us/step - loss: 1.3720 - acc: 0.5073 - val_loss: 1.4239 - val_acc: 0.4882
    Epoch 50/100
    50000/50000 [==============================] - 4s 86us/step - loss: 1.3632 - acc: 0.5137 - val_loss: 1.4383 - val_acc: 0.4867
    Epoch 51/100
    50000/50000 [==============================] - 4s 88us/step - loss: 1.3547 - acc: 0.5126 - val_loss: 1.4643 - val_acc: 0.4828
    Epoch 52/100
    50000/50000 [==============================] - 4s 90us/step - loss: 1.3466 - acc: 0.5180 - val_loss: 1.4495 - val_acc: 0.4878
    Epoch 53/100
    50000/50000 [==============================] - 5s 99us/step - loss: 1.3442 - acc: 0.5193 - val_loss: 1.4264 - val_acc: 0.4846
    Epoch 54/100
    50000/50000 [==============================] - 5s 96us/step - loss: 1.3385 - acc: 0.5211 - val_loss: 1.4610 - val_acc: 0.4885
    Epoch 55/100
    50000/50000 [==============================] - 5s 94us/step - loss: 1.3282 - acc: 0.5234 - val_loss: 1.4150 - val_acc: 0.4972
    Epoch 56/100
    50000/50000 [==============================] - 5s 97us/step - loss: 1.3255 - acc: 0.5248 - val_loss: 1.4380 - val_acc: 0.4874
    Epoch 57/100
    50000/50000 [==============================] - 5s 105us/step - loss: 1.3170 - acc: 0.5295 - val_loss: 1.3911 - val_acc: 0.5089
    Epoch 58/100
    50000/50000 [==============================] - 5s 96us/step - loss: 1.3143 - acc: 0.5304 - val_loss: 1.4412 - val_acc: 0.4866
    Epoch 59/100
    50000/50000 [==============================] - 4s 85us/step - loss: 1.3120 - acc: 0.5307 - val_loss: 1.4223 - val_acc: 0.4957
    Epoch 60/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.3089 - acc: 0.5336 - val_loss: 1.4069 - val_acc: 0.5013
    Epoch 61/100
    50000/50000 [==============================] - 4s 83us/step - loss: 1.2988 - acc: 0.5352 - val_loss: 1.4492 - val_acc: 0.4865
    Epoch 62/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.2934 - acc: 0.5361 - val_loss: 1.4143 - val_acc: 0.4940
    Epoch 63/100
    50000/50000 [==============================] - 4s 83us/step - loss: 1.2871 - acc: 0.5398 - val_loss: 1.3954 - val_acc: 0.5039
    Epoch 64/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.2796 - acc: 0.5413 - val_loss: 1.3905 - val_acc: 0.5097
    Epoch 65/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.2686 - acc: 0.5461 - val_loss: 1.4012 - val_acc: 0.5004
    Epoch 66/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.2606 - acc: 0.5502 - val_loss: 1.3996 - val_acc: 0.5117
    Epoch 67/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.2595 - acc: 0.5502 - val_loss: 1.4035 - val_acc: 0.5005
    Epoch 68/100
    50000/50000 [==============================] - 4s 83us/step - loss: 1.2558 - acc: 0.5513 - val_loss: 1.3989 - val_acc: 0.5105
    Epoch 69/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.2517 - acc: 0.5542 - val_loss: 1.4048 - val_acc: 0.5075
    Epoch 70/100
    50000/50000 [==============================] - 4s 83us/step - loss: 1.2454 - acc: 0.5569 - val_loss: 1.3911 - val_acc: 0.5111
    Epoch 71/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.2354 - acc: 0.5582 - val_loss: 1.3855 - val_acc: 0.5111
    Epoch 72/100
    50000/50000 [==============================] - 5s 94us/step - loss: 1.2333 - acc: 0.5568 - val_loss: 1.4110 - val_acc: 0.5014
    Epoch 73/100
    50000/50000 [==============================] - 5s 95us/step - loss: 1.2267 - acc: 0.5635 - val_loss: 1.4218 - val_acc: 0.5005
    Epoch 74/100
    50000/50000 [==============================] - 4s 87us/step - loss: 1.2239 - acc: 0.5626 - val_loss: 1.3804 - val_acc: 0.5072
    Epoch 75/100
    50000/50000 [==============================] - 5s 96us/step - loss: 1.2105 - acc: 0.5689 - val_loss: 1.3710 - val_acc: 0.5146
    Epoch 76/100
    50000/50000 [==============================] - 5s 91us/step - loss: 1.2092 - acc: 0.5706 - val_loss: 1.3825 - val_acc: 0.5142
    Epoch 77/100
    50000/50000 [==============================] - 6s 113us/step - loss: 1.2020 - acc: 0.5693 - val_loss: 1.4336 - val_acc: 0.4964
    Epoch 78/100
    50000/50000 [==============================] - 4s 88us/step - loss: 1.1982 - acc: 0.5705 - val_loss: 1.3763 - val_acc: 0.5213
    Epoch 79/100
    50000/50000 [==============================] - 4s 85us/step - loss: 1.1940 - acc: 0.5742 - val_loss: 1.3887 - val_acc: 0.5137
    Epoch 80/100
    50000/50000 [==============================] - 6s 122us/step - loss: 1.1866 - acc: 0.5778 - val_loss: 1.3790 - val_acc: 0.5155
    Epoch 81/100
    50000/50000 [==============================] - 4s 84us/step - loss: 1.1849 - acc: 0.5749 - val_loss: 1.4099 - val_acc: 0.5047
    Epoch 82/100
    50000/50000 [==============================] - 4s 86us/step - loss: 1.1762 - acc: 0.5804 - val_loss: 1.3757 - val_acc: 0.5191
    Epoch 83/100
    50000/50000 [==============================] - 4s 88us/step - loss: 1.1732 - acc: 0.5806 - val_loss: 1.3690 - val_acc: 0.5169
    Epoch 84/100
    50000/50000 [==============================] - 5s 93us/step - loss: 1.1674 - acc: 0.5845 - val_loss: 1.4169 - val_acc: 0.5098
    Epoch 85/100
    50000/50000 [==============================] - 5s 95us/step - loss: 1.1631 - acc: 0.5835 - val_loss: 1.3976 - val_acc: 0.5095
    Epoch 86/100
    50000/50000 [==============================] - 5s 98us/step - loss: 1.1570 - acc: 0.5871 - val_loss: 1.3729 - val_acc: 0.5203
    Epoch 87/100
    50000/50000 [==============================] - 5s 94us/step - loss: 1.1518 - acc: 0.5909 - val_loss: 1.3584 - val_acc: 0.5223
    Epoch 88/100
    50000/50000 [==============================] - 5s 93us/step - loss: 1.1447 - acc: 0.5916 - val_loss: 1.3580 - val_acc: 0.5280
    Epoch 89/100
    50000/50000 [==============================] - 5s 93us/step - loss: 1.1411 - acc: 0.5917 - val_loss: 1.4336 - val_acc: 0.5034
    Epoch 90/100
    50000/50000 [==============================] - 6s 123us/step - loss: 1.1349 - acc: 0.5958 - val_loss: 1.3716 - val_acc: 0.5118
    Epoch 91/100
    50000/50000 [==============================] - 4s 83us/step - loss: 1.1276 - acc: 0.5975 - val_loss: 1.3844 - val_acc: 0.5163
    Epoch 92/100
    50000/50000 [==============================] - 4s 85us/step - loss: 1.1183 - acc: 0.6021 - val_loss: 1.3758 - val_acc: 0.5182
    Epoch 93/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.1191 - acc: 0.5991 - val_loss: 1.3949 - val_acc: 0.5174
    Epoch 94/100
    50000/50000 [==============================] - 4s 86us/step - loss: 1.1087 - acc: 0.6046 - val_loss: 1.3686 - val_acc: 0.5222
    Epoch 95/100
    50000/50000 [==============================] - 5s 110us/step - loss: 1.0997 - acc: 0.6100 - val_loss: 1.3793 - val_acc: 0.5196
    Epoch 96/100
    50000/50000 [==============================] - 4s 82us/step - loss: 1.0935 - acc: 0.6097 - val_loss: 1.3982 - val_acc: 0.5105
    Epoch 97/100
    50000/50000 [==============================] - 5s 102us/step - loss: 1.0914 - acc: 0.6116 - val_loss: 1.3512 - val_acc: 0.5242
    Epoch 98/100
    50000/50000 [==============================] - 6s 127us/step - loss: 1.0754 - acc: 0.6188 - val_loss: 1.3880 - val_acc: 0.5252
    Epoch 99/100
    50000/50000 [==============================] - 5s 92us/step - loss: 1.0730 - acc: 0.6177 - val_loss: 1.3652 - val_acc: 0.5225
    Epoch 100/100
    50000/50000 [==============================] - 4s 83us/step - loss: 1.0640 - acc: 0.6201 - val_loss: 1.3744 - val_acc: 0.5254





    <keras.callbacks.History at 0x27059a17e88>




```python

print(model.predict_classes(X_test))

print(Y_test.reshape(-1))

cm=confusion_matrix(Y_test.reshape(-1), model.predict_classes(X_test))
cm/np.sum(cm,axis=1)*100


```

    [3 8 0 ... 3 4 7]
    [3 8 8 ... 5 1 7]





    array([[64.1,  5.6,  3.5,  1.4,  3.6,  0.9,  1.8,  3.8, 12.7,  2.6],
           [ 3.3, 71.1,  1.1,  1.2,  1.1,  1.3,  1. ,  2.7,  6.8, 10.4],
           [10.9,  2.4, 33.1,  5.7, 17.4,  8.4,  7.1, 11.5,  2. ,  1.5],
           [ 4.4,  3.3,  6.1, 27.5,  9.3, 21.1,  9.2, 12.1,  3.3,  3.7],
           [ 7. ,  2.1,  9.4,  4.3, 46.6,  4.9,  6.4, 15.2,  2.5,  1.6],
           [ 2.8,  0.9,  7.3, 14.1,  9.5, 42.1,  6. , 13.4,  2.6,  1.3],
           [ 2.2,  2.5,  5.4,  5.9, 14.3,  7.3, 53.4,  5.7,  1.1,  2.2],
           [ 5.1,  1.5,  2.6,  3.1,  5.6,  5.3,  1.7, 70.8,  1.2,  3.1],
           [10.7,  8.2,  1.2,  1.5,  2.8,  1.2,  0.7,  1.9, 67.9,  3.9],
           [ 4.8, 25.9,  1. ,  1.7,  0.6,  2.3,  1.5,  6.9,  6.5, 48.8]])




```python
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import matplotlib.gridspec as gridspec
import numpy
import random

fig = plt.figure()
outer_grid = gridspec.GridSpec(10, 10, wspace=0.0, hspace=0.0)
weights = model.layers[0].get_weights()
w = weights[0].T

for i, neuron in enumerate(random.sample(range(0, 1023), 100)):
    ax = plt.Subplot(fig, outer_grid[i])
    ax.imshow(numpy.mean(numpy.reshape(w[i], (32, 32, 3)), axis=2),
    cmap=cm.Greys_r)
    ax.set_xticks([])
    ax.set_yticks([])
    fig.add_subplot(ax)
plt.show()
```


```python
# Ejercicio Utilicen Redes neuronales para clasificar 
```


```python

```


```python

```


```python
import matplotlib.pyplot as plt
import numpy as np
mean = [0, 0]
cov = [[1, 0], [0, 100]]  # diagonal covariance

cov2 = [[2, 0], [0, 1]]  # diagonal covariance

x1, x2 = np.random.multivariate_normal(mean, cov, 100).T
x3, x4 = np.random.multivariate_normal(mean, cov2, 100).T
```


```python
from mpl_toolkits import mplot3d


zdata = 15 * np.random.random(1000)
xdata = np.sin(zdata) + 0.1 * np.random.randn(1000)
ydata = np.cos(zdata) + 0.1 * np.random.randn(1000)

fig = plt.figure()
ax = plt.axes(projection='3d')

ax.scatter3D(xdata, ydata, zdata, cmap='Greens');
```


```python
print(X.shape)
covX=np.cov(X)
print(covX)
```

    (3, 1000)
    [[ 2.79463640e-02 -4.03523147e-04 -6.37819697e-03]
     [-4.03523147e-04  2.63174637e-02  6.63009104e-03]
     [-6.37819697e-03  6.63009104e-03  9.83000217e-01]]



```python
from numpy import linalg as LA

w, v = LA.eig(covX)
print(v)
```

    [[ 0.00668036 -0.97855495 -0.20587761]
     [-0.00693215  0.20583193 -0.9785628 ]
     [-0.99995366 -0.00796433  0.00540845]]



```python

```


```python
print(w)
print(v)
```

    [0.98308879 0.02797933 0.02619592]
    [[ 0.00668036 -0.97855495 -0.20587761]
     [-0.00693215  0.20583193 -0.9785628 ]
     [-0.99995366 -0.00796433  0.00540845]]



```python
fig = plt.figure(figsize=(10,10))
ax = plt.axes(projection='3d')

ax.scatter3D(xdata, ydata, zdata, cmap='Greens');
for i in range(len(v)):
    ax.plot([0,v[i][2]],[0,v[i][1]],[0,v[i][0]])
plt.show()
```


```python
print(v.shape)
dat=np.dot(X.T,v)
plt.scatter(dat[:,0],dat[:,1])
```


```python

```

7fba0ed6bf74292628f87845be7ab372cebb6127
ipynb
Jupyter Notebook
12NNs/1_IntroNNs.ipynb
sergiogaitan/Study_Guides
083acd23f5faa6c6bc404d4d53df562096478e7c
MIT
2020-09-12T17:16:12.000Z
2021-02-03T01:37:02.000Z
12NNs/1_IntroNNs.ipynb
sergiogaitan/Study_Guides
083acd23f5faa6c6bc404d4d53df562096478e7c
MIT
12NNs/1_IntroNNs.ipynb
sergiogaitan/Study_Guides
083acd23f5faa6c6bc404d4d53df562096478e7c
MIT
2020-05-22T12:57:49.000Z
2021-02-03T01:37:07.000Z
Qwen/Qwen-72B
1. YES
2. YES