Red neuronal convolucional – Theano

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)))

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. También puedes parar el proceso en cualquier momento con Ctrl + C o simplemente cerrando la terminal.

Red neuronal moderna – Theano

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

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

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 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 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 model(X, w_h, w_h2, w_o, p_drop_input, p_drop_hidden):
    X = dropout(X, p_drop_input)
    h = rectify(T.dot(X, w_h))

    h = dropout(h, p_drop_hidden)
    h2 = rectify(T.dot(h, w_h2))

    h2 = dropout(h2, p_drop_hidden)
    py_x = softmax(T.dot(h2, w_o))
    return h, h2, py_x

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

X = T.fmatrix()
Y = T.fmatrix()

w_h = init_weights((784, 625))
w_h2 = init_weights((625, 625))
w_o = init_weights((625, 10))

noise_h, noise_h2, noise_py_x = model(X, w_h, w_h2, w_o, 0.2, 0.5)
h, h2, py_x = model(X, w_h, w_h2, w_o, 0., 0.)
y_x = T.argmax(py_x, axis=1)

cost = T.mean(T.nnet.categorical_crossentropy(noise_py_x, Y))
params = [w_h, w_h2, 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_moderna.py.

Red neuronal clásica – Theano

Aquí os dejo con un ejemplo (red_neuronal_clasica.py) muy sencillo y claro para realizar una red neuronal clásica.

import theano
from theano import tensor as T
import numpy as np
from Load import mnist
from scipy.misc import imsave

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 sgd(cost, params, lr=0.05):
    grads = T.grad(cost=cost, wrt=params)
    updates = []
    for p, g in zip(params, grads):
        updates.append([p, p - g * lr])
    return updates

def model(X, w_h, w_o):
    h = T.nnet.sigmoid(T.dot(X, w_h))
    pyx = T.nnet.softmax(T.dot(h, w_o))
    return pyx

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

X = T.fmatrix()
Y = T.fmatrix()

w_h = init_weights((784, 625))
w_o = init_weights((625, 10))

py_x = model(X, w_h, w_o)
y_x = T.argmax(py_x, axis=1)

cost = T.mean(T.nnet.categorical_crossentropy(py_x, Y))
params = [w_h, w_o]
updates = sgd(cost, params)

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_clasica.py.

Regresión logística – Theano

Aquí os dejo con un ejemplo (regresion_logistica.py) muy sencillo y claro para realizar una regresión logística.

import numpy as np
import theano
from theano import tensor as T
from Load import mnist

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 model(X, w):
    return T.nnet.softmax(T.dot(X, w))

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

X = T.fmatrix()
Y = T.fmatrix()

w = init_weights((784, 10))

py_x = model(X, w)
y_pred = T.argmax(py_x, axis=1)

cost = T.mean(T.nnet.categorical_crossentropy(py_x, Y))
gradient = T.grad(cost=cost, wrt=w)
update = [[w, w - gradient * 0.05]]

train = theano.function(inputs=[X, Y], outputs=cost, updates=update,
                        allow_input_downcast=True)
predict = theano.function(inputs=[X], outputs=y_pred,
                          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(i, np.mean(np.argmax(teY, axis=1) == predict(teX)))

Para poder ejecutar este ejemplo, necesitas preprocesar la base de datos MNIST. Para ello, crea un archivo Load.py (sitúa dicho archivo en la misma carpeta que regresion_logistica.py) con el siguiente código:

import numpy as np
import os

data_dir = os.getcwd() + '/MNIST/'

def one_hot(x,n):
	if type(x) == list:
		x = np.array(x)
	x = x.flatten()
	o_h = np.zeros((len(x),n))
	o_h[np.arange(len(x)),x] = 1
	return o_h

def mnist(ntrain=60000,ntest=10000,onehot=True):
	fd = open(os.path.join(data_dir,'train-images.idx3-ubyte'))
	loaded = np.fromfile(file=fd,dtype=np.uint8)
	trX = loaded[16:].reshape((60000,28*28)).astype(float)

	fd = open(os.path.join(data_dir,'train-labels.idx1-ubyte'))
	loaded = np.fromfile(file=fd,dtype=np.uint8)
	trY = loaded[8:].reshape((60000))

	fd = open(os.path.join(data_dir,'t10k-images.idx3-ubyte'))
	loaded = np.fromfile(file=fd,dtype=np.uint8)
	teX = loaded[16:].reshape((10000,28*28)).astype(float)

	fd = open(os.path.join(data_dir,'t10k-labels.idx1-ubyte'))
	loaded = np.fromfile(file=fd,dtype=np.uint8)
	teY = loaded[8:].reshape((10000))

	trX = trX/255.
	teX = teX/255.

	trX = trX[:ntrain]
	trY = trY[:ntrain]

	teX = teX[:ntest]
	teY = teY[:ntest]

	if onehot:
		trY = one_hot(trY, 10)
		teY = one_hot(teY, 10)
	else:
		trY = np.asarray(trY)
		teY = np.asarray(teY)

	return trX,teX,trY,teY

En el mismo directorio donde coinciden tu archivo regresion_logistica.py de regresión logística y el archivo Load.py, crea un directorio con el nombre MNIST e introduce en él los siguientes cuatro archivos: 1, 2, 3, 4.

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

Regresión lineal – Theano

Aquí os dejo con un ejemplo (regresion_lineal.py) muy sencillo y claro para realizar una regresión lineal.

import numpy as np
import theano
from theano import tensor as T
import matplotlib.pyplot as plt

trX = np.linspace(-1, 1, 101)
trY = 2 * trX + np.random.randn(*trX.shape) * 0.33

X = T.scalar()
Y = T.scalar()

def model(X, w):
    return X * w

w = theano.shared(np.asarray(0., dtype=theano.config.floatX))
y = model(X, w)

cost = T.mean(T.sqr(y - Y))
gradient = T.grad(cost=cost, wrt=w)
updates = [[w, w - gradient * 0.01]]

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

for i in range(100):
    for x, y in zip(trX, trY):
        train(x, y)

print(w.get_value())  # Resultado alrededor de 2.

plt.plot(trX, trY, 'g.')
plt.plot(trX, model(trX, w.get_value()))
plt.show()

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

Publicado GNU Octave 4.0

octave

Ya tenemos una nueva versión de GNU Octave repleta de novedades. Entre las principales características tenemos:

· Interfaz de usuario por defecto. Esta interfaz integra la mayoría de las funcionalidades para poder trabajar: editor, intérprete, depurador, etc.
· GNU Octave ahora usa OpenGL con Qt Widgets por defecto para las gráficas.
· Nueva sintaxis para la programación orientada a objetos.
· Nuevas funciones como audioread, sound, disable_range, disable_diagonal_matrix, disable_permutation_matrix.
· Mucha mayor compatibilidad con respecto a MATLAB.

Esta es sólo una pequeña lista de la gran cantidad de novedades de GNU Octave 4.0, la lista completa la tenéis aquí.

Edward Snowden recomienda aplicaciones de Open Whisper Systems

wispher

Edward Snowden, exempleado de la CIA y de la NSA, ha recomendado tres aplicaciones de comunicación para móviles: TextSecure (mensajería instantánea para Android), RedPhone (llamadas para Android) y Signal (mensajería instantánea y llamadas para iOS). Todas estas aplicaciones son de la asociación Open Whisper Systems.

Estos tres programas son compatibles entre sí. Además, cada mensaje y cada llamada es encriptado/a por defecto. La única pega que pone Snowden es que pueden obtener los metadatos en nuestro teléfono.

Y tú, ¿has probado alguno de estos programas?, ¿Te parecen una buena alternativa a WhatsApp o Telegram?

MAME será Software Libre

mame

Después de muchos años, MAME Team va a cambiar la anticuada MAME license por una de Software Libre como GPL 2.0 o posterior. El anuncio fue en Twitter y en Github tenéis los detalles.

Actualmente siguen con la licencia antigua, pero quieren pasar por ahora el núcleo a la licencia 3-Clause BSD y algunos drivers a la LGPL version 2.1. Sin embargo, en conjunto quieren sacar todo el proyecto MAME con la licencia antes mencionada: GPL 2.0 o posterior.

Grandes noticias para los amantes de los emuladores, como yo. Por cierto, ¿habéis disfrutado ya de RetroPie en vuestra Raspberry Pi?

Instalar Theano en Ubuntu o Debian

theano

Theano es una librería de matemática para Python, se usa mucho en Deep Learning.

Aquí os dejo los pasos a seguir para instalar Theano en una distribución basada en Debian (o en Ubuntu, claro):

sudo apt-get install build-essential libopenblas-dev git
sudo apt-get install python3 python3-dev python3-pip python3-numpy python3-scipy python3-nose
sudo pip3 install theano

Con estos sencillos pasos ya puedes empezar a usar Theano. ¿No sabes cómo usarlo? ¡Aquí tienes un gran tutorial para empezar!

Disfruta de juegos retro en tu Raspberry Pi gracias a RetroPie

retropie

Hace pocos días me pillé la nueva Raspberry Pi 2 y no puedo estar más contento. Por un módico precio puedo disfrutar de un sistema GNU/Linux prácticamente al completo gracias a Raspbian. Aún así, estoy deseando que la comunidad Debian pueda sacar finalmente su propia imagen para Raspberry Pi 2.

En éste caso uno de los proyectos más interesantes para Raspberry Pi es el Proyecto RetroPie. Este proyecto consiste en crear un sistema de juegos retro para la Raspeberry Pi. La instalación la puedes hacer desde un script o, mucho más fácil, descargando una imagen ya preparada (recomendado porque además prepara Raspbian con RetroPie sólo con lo necesario).

Os animo a que lo probéis y que contéis vuestra experiencia.

Publicado Debian 8.0 “Jessie”

debian-logo

Si no ha habido ningún fallo crítico, el proyecto Debian habrá publicado la nueva versión del Sistema Operativo Universal: Debian 8.0 "Jessie".

Entre la gran cantidad de novedades, a destacar:

- Dos nuevas arquitecturas soportadas: arm64 y ppc64el.
- Demonio de administración de sistema "systemd" por defecto.
- Actualización de la práctita totalidad de los paquetes: Kernel Linux 3.16, GNU GCC 4.9, Apache 2.4.10, , Lighttpd 1.4.35, OpenSSH 6.7p1, PHP 5.6, PostgreSQL9.4, Python 3 3.4, Samba 4.1, etc.

Estoy seguro de que este lanzamiento será mucho más exitoso que el anterior (Wheezy) y hará que Debian siga siendo una de las mejores (y en mi opinión la mejor) distribuciones GNU/Linux del momento.

SuperTuxKart 0.9, con nuevo motor gráfico

maxresdefault

El equipo STK Development Team acaba de anunciar la nueva versión de SuperTuxKart. Entre las principales novedades hay que destacar las siguientes:

- Nuevo motor gráfico.
- Uso de OpenGL 3.1.
- Dos circuitos completamente rediseñados.

La verdad es que si esta versión pinta muy interesante, no me quiero imaginar la versión estable 1.0.

Instalar Intel OpenCL en Ubuntu

beignet_01_projectpage_graphic

Uno de los futuros más prometedores para la programación paralela es OpenCL por su carácter abierto en contraposición a CUDA. La implementación libre para Intel de OpenCL denominada Beignet permite trabajar con dicho estándar de una manera muy eficiente.

Éstos son los pasos para su instalación dependiendo de la versión de Ubuntu:

Ubuntu 14.04:

sudo add-apt-repository ppa:numix/ppa
sudo apt-get update
sudo apt-get install beignet

Ubuntu 15.04 en adelante:

sudo apt-get install beignet

Para Ubuntu 14.10 no he encontrado PPA y el paquete del repositorio es la versión 0.8 que la considero un poco desfasada. Si conocéis una alternativa interesante, además de la de compilar, será bienvenida.

Ángulo de un vector con respecto al eje x en Python

atan2

Aquí os dejo un pequeño script de ejemplo que calcula el ángulo de un vector con respecto al eje x en Python. El vector tiene su origen en el punto (0, 0) y su destino es el punto (2, 3):.

import math

x1 = 0.0
y1 = 0.0
x2 = 2.0
y2 = 3.0

x = x2 - x1
y = y2 - y1

angle = math.atan2(y, x) * (180.0 / math.pi)
print('Ángulo en grados: ' + str(angle))

Publicado Xfce 4.12

xfce

Después de dos años y diez meses de arduo trabajo, el equipo de Xfce publica la versión 4.12 de su entorno de escritorio. Esta nueva versión, ya estable, sustituye a la anterior, 4.10, con jugosas novedades como por ejemplo:

· El Window Manager soporta las denominadas decoraciones. También soporta las nuevas pantallas de alta resolución HiDPI.
· El panel ahora tiene ocultación inteligente y soporta plugins Gtk3.
· El explorador de archivos, Thunar, mejora enormemente: soporte de pestaña, atajos de teclado, mejor nombramiento de ficheros y enlaces, mejorada la navegación por teclado, etc.
· Xfsettingsd ahora soporta libinput.

El número de actualizaciones es enorme. Podéis ver la lista completa de novedades de Xfce 4.12 aquí.

También podéis ver un tour visual de las actualizaciones de Xfce 4.12.

Enlace: Anuncio oficial.