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

Leer más » 1 Comentario

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

Leer más » Comentar

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

Leer más » 3 Comentarios

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() read more

Leer más » Comentar

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. read more

Leer más » 1 Comentario

Á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))
Leer más » 3 Comentarios

amule crash

Aunque para algunos el amule a muerto , para muchos sigue siendo un sistema de p2p para compartir información. por es motivo he escrito este pequeño post para dar dos soluciones que he encontrado y me han funcionado para evitar que se cierre inesperadamente o se quede en un proceso zombi.

Existen varias razones que por las que se cierra el amule. Primero se debe de tener en cuenta. si la tarjeta gráfica esta integrado o no.

Si no esta integrado, osea que es aparte de la placa base. la solución que se propone es reiniciar el amule. Se le pregunta cada cierto tiempo si esta activo y ya estaría. read more

Leer más » 2 Comentarios

Less CSS Primeros Pasos

¿Qué es Less?

LESS CSS es una ampliación de las hojas de estilo CSS, pero a diferencia de éstas, funciona como un lenguaje de programación, permitiendo el uso de variables, funciones etc.

Perfecto para programadores intrépidos…

LESS CSS no reemplaza a CSS. De hecho, el resultado final es una hoja de estilos CSS completamente funcional.

Less simplemente ofrece una maquetación más ordenada, lógica y que permite programarse en menos tiempo, indicando el nombre de la variable y su valor.

@variable: valor;
// Por ejemplo: //
@color: #333333;
read more

Leer más » 3 Comentarios

Latino – Nuevo lenguaje de programación con sintaxis en español

Hola les hago una invitación a todos los desarrolladores y al público en general para la creación de un nuevo lenguaje de programción con sintaxis en español y que sea lo más natural posible.

Este proyecto nace de la necesidad de incrementar la educación de nivel básico (primaria y secundaria) debido a que los niños tienen la capacidad de entender la lógica a muy temprana edad y es en esta edad cuando más aprenden, esto motivará a los niños y jovenes por interesarse en el mundo del desarrollo de aplicaciones. read more

Leer más » 15 Comentarios

Instalar Julia

julia

Últimamente estoy muy interesado en Julia, un prometedor lenguaje de programación con licencia libre que le deseo un gran futuro.

Estos días estoy probándolo y quería compartir la instalación, que es muy sencilla.

Sólo tienes que dirigirte a la página oficial de descargas de Julia y descargar el archivo correspondiente a tu sistema operativo. Al ser multiplataforma, Julia está disponible para Windows, Mac OS y Linux.

Si estás usando Linux puedes instalarlo con los repositorios de tu distribución. Para Ubuntu/Debian el comando sería el siguiente: read more

Leer más » Comentar