convolucional Archivos - Linux Hispano

Red neuronal convolucional – Theano

Por Manuel Ignacio López Quintero septiembre 2, 2015junio 30, 2015 En Noticias 1 convolucional, red neuronal 0

Aquí os dejo con un ejemplo (red_neuronal_convolucional.py) muy sencillo y claro para realizar una red neuronal convolucional.

import theano
from theano import tensor as T
from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams
import numpy as np
from Load import mnist
from theano.tensor.nnet.conv import conv2d
from theano.tensor.signal.downsample import max_pool_2d

srng = RandomStreams()

def floatX(X):
    return np.asarray(X, dtype=theano.config.floatX)

def init_weights(shape):
    return theano.shared(floatX(np.random.randn(*shape) * 0.01))

def rectify(X):
    return T.maximum(X, 0.)

def softmax(X):
    e_x = T.exp(X - X.max(axis=1).dimshuffle(0, 'x'))
    return e_x / e_x.sum(axis=1).dimshuffle(0, 'x')

def dropout(X, p=0.):
    if p > 0:
        retain_prob = 1 - p
        X *= srng.binomial(X.shape, p=retain_prob, dtype=theano.config.floatX)
        X /= retain_prob
    return X

def RMSprop(cost, params, lr=0.001, rho=0.9, epsilon=1e-6):
    grads = T.grad(cost=cost, wrt=params)
    updates = []
    for p, g in zip(params, grads):
        acc = theano.shared(p.get_value() * 0.)
        acc_new = rho * acc + (1 - rho) * g ** 2
        gradient_scaling = T.sqrt(acc_new + epsilon)
        g = g / gradient_scaling
        updates.append((acc, acc_new))
        updates.append((p, p - lr * g))
    return updates

def model(X, w, w2, w3, w4, p_drop_conv, p_drop_hidden):
    l1a = rectify(conv2d(X, w, border_mode='full'))
    l1 = max_pool_2d(l1a, (2, 2))
    l1 = dropout(l1, p_drop_conv)

    l2a = rectify(conv2d(l1, w2))
    l2 = max_pool_2d(l2a, (2, 2))
    l2 = dropout(l2, p_drop_conv)

    l3a = rectify(conv2d(l2, w3))
    l3b = max_pool_2d(l3a, (2, 2))
    l3 = T.flatten(l3b, outdim=2)
    l3 = dropout(l3, p_drop_conv)

    l4 = rectify(T.dot(l3, w4))
    l4 = dropout(l4, p_drop_hidden)

    pyx = softmax(T.dot(l4, w_o))
    return l1, l2, l3, l4, pyx

trX, teX, trY, teY = mnist(onehot=True)

trX = trX.reshape(-1, 1, 28, 28)
teX = teX.reshape(-1, 1, 28, 28)

X = T.tensor4(dtype='float64')
Y = T.matrix()

w = init_weights((32, 1, 3, 3))
w2 = init_weights((64, 32, 3, 3))
w3 = init_weights((128, 64, 3, 3))
w4 = init_weights((128 * 3 * 3, 625))
w_o = init_weights((625, 10))

noise_l1, noise_l2, noise_l3, noise_l4, noise_py_x = model(X, w, w2, w3, w4, 0.2, 0.5)
l1, l2, l3, l4, py_x = model(X, w, w2, w3, w4, 0., 0.)
y_x = T.argmax(py_x, axis=1)


cost = T.mean(T.nnet.categorical_crossentropy(noise_py_x, Y))
params = [w, w2, w3, w4, w_o]
updates = RMSprop(cost, params, lr=0.001)

train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)
predict = theano.function(inputs=[X], outputs=y_x, allow_input_downcast=True)

for i in range(100):
    for start, end in zip(range(0, len(trX), 128), range(128, len(trX), 128)):
        cost = train(trX[start:end], trY[start:end])
    print(np.mean(np.argmax(teY, axis=1) == predict(teX)))

import theano

from theano import tensor as T

from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams

import numpy as np

from Load import mnist

from theano.tensor.nnet.conv import conv2d

from theano.tensor.signal.downsample import max_pool_2d

srng = RandomStreams()

def floatX(X):

return np.asarray(X, dtype=theano.config.floatX)

def init_weights(shape):

return theano.shared(floatX(np.random.randn(*shape) * 0.01))

def rectify(X):

return T.maximum(X, 0.)

def softmax(X):

e_x = T.exp(X - X.max(axis=1).dimshuffle(0, 'x'))

return e_x / e_x.sum(axis=1).dimshuffle(0, 'x')

def dropout(X, p=0.):

if p > 0:

retain_prob = 1 - p

X *= srng.binomial(X.shape, p=retain_prob, dtype=theano.config.floatX)

X /= retain_prob

return X

def RMSprop(cost, params, lr=0.001, rho=0.9, epsilon=1e-6):

grads = T.grad(cost=cost, wrt=params)

updates = []

for p, g in zip(params, grads):

acc = theano.shared(p.get_value() * 0.)

acc_new = rho * acc + (1 - rho) * g ** 2

gradient_scaling = T.sqrt(acc_new + epsilon)

g = g / gradient_scaling

updates.append((acc, acc_new))

updates.append((p, p - lr * g))

return updates

def model(X, w, w2, w3, w4, p_drop_conv, p_drop_hidden):

l1a = rectify(conv2d(X, w, border_mode='full'))

l1 = max_pool_2d(l1a, (2, 2))

l1 = dropout(l1, p_drop_conv)

l2a = rectify(conv2d(l1, w2))

l2 = max_pool_2d(l2a, (2, 2))

l2 = dropout(l2, p_drop_conv)

l3a = rectify(conv2d(l2, w3))

l3b = max_pool_2d(l3a, (2, 2))

l3 = T.flatten(l3b, outdim=2)

l3 = dropout(l3, p_drop_conv)

l4 = rectify(T.dot(l3, w4))

l4 = dropout(l4, p_drop_hidden)

pyx = softmax(T.dot(l4, w_o))

return l1, l2, l3, l4, pyx

trX, teX, trY, teY = mnist(onehot=True)

trX = trX.reshape(-1, 1, 28, 28)

teX = teX.reshape(-1, 1, 28, 28)

X = T.tensor4(dtype='float64')

Y = T.matrix()

w = init_weights((32, 1, 3, 3))

w2 = init_weights((64, 32, 3, 3))

w3 = init_weights((128, 64, 3, 3))

w4 = init_weights((128 * 3 * 3, 625))

w_o = init_weights((625, 10))

noise_l1, noise_l2, noise_l3, noise_l4, noise_py_x = model(X, w, w2, w3, w4, 0.2, 0.5)

l1, l2, l3, l4, py_x = model(X, w, w2, w3, w4, 0., 0.)

y_x = T.argmax(py_x, axis=1)

cost = T.mean(T.nnet.categorical_crossentropy(noise_py_x, Y))

params = [w, w2, w3, w4, w_o]

updates = RMSprop(cost, params, lr=0.001)

train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)

predict = theano.function(inputs=[X], outputs=y_x, allow_input_downcast=True)

for i in range(100):

for start, end in zip(range(0, len(trX), 128), range(128, len(trX), 128)):

cost = train(trX[start:end], trY[start:end])

print(np.mean(np.argmax(teY, axis=1) == predict(teX)))

Recuerda que para ejecutar este ejemplo necesitas preprocesar la base de datos MNIST. Las instrucciones para el archivo Load.py y la base de datos MNIST las puedes encontrar en el tutorial de Theano sobre regresión logística.

Por último, para ejecutar el código simplemente ejecuta: python3 red_neuronal_convolucional.py.

Éste código puede tardar bastantes horas (incluso días dependiendo del ordenador). Puedes configurar Theano para que funcione en la GPU de tu PC y así reducir el tiempo de ejecución.

Seguir leyendo...

Tag Archives convolucional