Sign up with your email address to be the first to know about new products, VIP offers, blog features & more.

You are viewing Tutoriales

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,

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,

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],

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,

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.

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