Redes Neuronales Utilidades

Contents

Redes Neuronales Utilidades#

En esta carpeta se encuentran una serie de utilidades necesarias para los cuadernos sobre Redes Neuronales (RNN)

Utilidad que dibuja las curvas de nivel que determina el valor y en la region X#

Las funciones contour y contourf#

La función contour(X, Y, Z) tiene los siguientes parámetros de entrada

X : Matriz 2D con los valores X de los puntos de una malla creada con numpy.meshgrid()
Y : Matriz 2D con los valores Y de los puntos de una malla creada con numpy.meshgrid()
Z : Matriz 2D con el valor de la función

Contour dibuja la curva de nivel. Contourf dibuja la curva de nivel rellenada con color

Se dibujan las curvas de nivel del paraboloide elíptico \(y=x^2+y^2\) y del paraboloide hiperbólico \(y=x^2-y^2\)

## Curvas de nivel de la función 
import matplotlib.pyplot as plt
import numpy as np
A=np.array([-3,-2,-1,0,1,2,3])
B=A
A,B=np.meshgrid(A,B)
fig = plt.figure()
#plt.contour(A,B,A**2+B**2)  # Paraboloide elíptico. Curvas de nivel estándar
#plt.contour(A,B,A**2-B**2)  # Paraboloide hiperbólico. Curvas de nivel estándar
#plt.contourf(A,B,A**2+B**2)  # Paraboloide elíptico. Curvas de nivel con contorno relleno de color
#plt.contourf(A,B,A**2-B**2)  # Paraboloide hiperbólico. Curvas de nivel con contorno relleno de color
#plt.show()

<Figure size 640x480 with 0 Axes>

Función para imprimir una cifra manuscrita y su predicción#

Utilidades para pruebas con pytorch#

Show code cell content Hide code cell content

import matplotlib.pyplot as plt
import numpy as np
from torch import nn, optim
from torch.autograd import Variable


def test_network(net, trainloader):

    criterion = nn.MSELoss()
    optimizer = optim.Adam(net.parameters(), lr=0.001)

    dataiter = iter(trainloader)
    images, labels = dataiter.next()

    # Create Variables for the inputs and targets
    inputs = Variable(images)
    targets = Variable(images)

    # Clear the gradients from all Variables
    optimizer.zero_grad()

    # Forward pass, then backward pass, then update weights
    output = net.forward(inputs)
    loss = criterion(output, targets)
    loss.backward()
    optimizer.step()

    return True


def imshow(image, ax=None, title=None, normalize=True):
    """Imshow for Tensor."""
    if ax is None:
        fig, ax = plt.subplots()
    image = image.numpy().transpose((1, 2, 0))

    if normalize:
        mean = np.array([0.485, 0.456, 0.406])
        std = np.array([0.229, 0.224, 0.225])
        image = std * image + mean
        image = np.clip(image, 0, 1)

    ax.imshow(image)
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.spines['left'].set_visible(False)
    ax.spines['bottom'].set_visible(False)
    ax.tick_params(axis='both', length=0)
    ax.set_xticklabels('')
    ax.set_yticklabels('')

    return ax


def view_recon(img, recon):
    ''' Function for displaying an image (as a PyTorch Tensor) and its
        reconstruction also a PyTorch Tensor
    '''

    fig, axes = plt.subplots(ncols=2, sharex=True, sharey=True)
    axes[0].imshow(img.numpy().squeeze())
    axes[1].imshow(recon.data.numpy().squeeze())
    for ax in axes:
        ax.axis('off')
        ax.set_adjustable('box-forced')
        
def view_classify(img, ps, version="MNIST"):
    ''' Function for viewing an image and it's predicted classes.
    '''
    ps = ps.data.numpy().squeeze()

    fig, (ax1, ax2) = plt.subplots(figsize=(6,9), ncols=2)
    ax1.imshow(img.resize_(1, 28, 28).numpy().squeeze())
    ax1.axis('off')
    ax2.barh(np.arange(10), ps)
    ax2.set_aspect(0.1)
    ax2.set_yticks(np.arange(10))
    if version == "MNIST":
        ax2.set_yticklabels(np.arange(10))
    elif version == "Fashion":
        ax2.set_yticklabels(['Camiseta/top',
                            'Pantalones',
                            'Jersey',
                            'Vestido',
                            'Abrigo',
                            'Sandalia',
                            'Camisa',
                            'Deportivas',
                            'Maleta',
                            'Bota'], size='small');
    ax2.set_title('Probabilidad')
    ax2.set_xlim(0, 1.1)

    plt.tight_layout()

print("load done!")

load done!