Función de activación de ocultador Theano

¿Hay alguna forma de usar la Unidad lineal rectificada (ReLU) como la función de activación de la capa oculta en lugar de tanh() o sigmoid() en Theano? La implementación de la capa oculta es la siguiente y, en la medida en que he buscado en Internet, ReLU no está implementado dentro de Theano.

 class HiddenLayer(object): def __init__(self, rng, input, n_in, n_out, W=None, b=None, activation=T.tanh): pass 

Relu es fácil de hacer en Theano:

 switch(x<0, 0, x) 

Para usarlo en su caso, haga una función de python que implementará relu y la pase a la activación:

 def relu(x): return theano.tensor.switch(x<0, 0, x) HiddenLayer(..., activation=relu) 

Algunas personas usan esta implementación: x * (x > 0)

ACTUALIZACIÓN: La versión más nueva de Theano tiene theano.tensor.nnet.relu (x) disponible.

ACTUALIZACIÓN: la última versión de theano tiene soporte nativo de ReLU: T.nnet.relu , que debería ser preferible a las soluciones personalizadas.

Decidí comparar la velocidad de las soluciones, ya que es muy importante para las NN. Comparada la velocidad de la función en sí misma y su gradiente, en el primer caso se prefiere el cambio, el gradiente es más rápido para x * (x> 0). Todos los gradientes calculados son correctos.

 def relu1(x): return T.switch(x<0, 0, x) def relu2(x): return T.maximum(x, 0) def relu3(x): return x * (x > 0) z = numpy.random.normal(size=[1000, 1000]) for f in [relu1, relu2, relu3]: x = theano.tensor.matrix() fun = theano.function([x], f(x)) %timeit fun(z) assert numpy.all(fun(z) == numpy.where(z > 0, z, 0)) Output: (time to compute ReLU function) >100 loops, best of 3: 3.09 ms per loop >100 loops, best of 3: 8.47 ms per loop >100 loops, best of 3: 7.87 ms per loop for f in [relu1, relu2, relu3]: x = theano.tensor.matrix() fun = theano.function([x], theano.grad(T.sum(f(x)), x)) %timeit fun(z) assert numpy.all(fun(z) == (z > 0) Output: time to compute gradient >100 loops, best of 3: 8.3 ms per loop >100 loops, best of 3: 7.46 ms per loop >100 loops, best of 3: 5.74 ms per loop 

Finalmente, comparemos cómo se debe calcular el gradiente (la forma más rápida)

 x = theano.tensor.matrix() fun = theano.function([x], x > 0) %timeit fun(z) Output: >100 loops, best of 3: 2.77 ms per loop 

Entonces theano genera código inoptimo para gradiente. En mi humilde opinión, cambiar la versión de hoy debe ser preferido.

Creo que es más preciso escribirlo de esta manera:

 x * (x > 0.) + 0. * (x < 0.) 

Lo escribí así:

 lambda x: T.maximum(0,x) 

o:

 lambda x: x * (x > 0) 

La función es muy simple en Python:

 def relu(input): output = max(input, 0) return(output)