Jak zaimplementować funkcję ReLU w Numpy

Question

Chcę utworzyć prostą sieć neuronową i chcę użyć funkcji ReLU. Czy ktoś może mi dać wskazówki, w jaki sposób mogę zaimplementować tę funkcję za pomocą numpy. Dziękujemy za poświęcony czas!

Answer 1

Istnieje kilka sposobów.

>>> x = np.random.random((3, 2)) - 0.5 
>>> x 
array([[-0.00590765, 0.18932873], 
     [-0.32396051, 0.25586596], 
     [ 0.22358098, 0.02217555]]) 
>>> np.maximum(x, 0) 
array([[ 0.  , 0.18932873], 
     [ 0.  , 0.25586596], 
     [ 0.22358098, 0.02217555]]) 
>>> x * (x > 0) 
array([[-0.  , 0.18932873], 
     [-0.  , 0.25586596], 
     [ 0.22358098, 0.02217555]]) 
>>> (abs(x) + x)/2 
array([[ 0.  , 0.18932873], 
     [ 0.  , 0.25586596], 
     [ 0.22358098, 0.02217555]]) 

Jeśli rozrządu wyniki z następującego kodu:

import numpy as np 

x = np.random.random((5000, 5000)) - 0.5 
print("max method:") 
%timeit -n10 np.maximum(x, 0) 

print("multiplication method:") 
%timeit -n10 x * (x > 0) 

print("abs method:") 
%timeit -n10 (abs(x) + x)/2 

otrzymujemy:

max method: 
10 loops, best of 3: 239 ms per loop 
multiplication method: 
10 loops, best of 3: 145 ms per loop 
abs method: 
10 loops, best of 3: 288 ms per loop 

więc mnożenie wydaje się być najszybszy.

Answer 2

Użyj np.maximum(x, 0, x). Zostało to wskazane przez Daniel S. Jest o wiele szybszy i dlatego, że ludzie mogą to przeoczyć, przekażę to jako odpowiedź. Oto porównanie:

max method: 
10 loops, best of 3: 238 ms per loop 
multiplication method: 
10 loops, best of 3: 128 ms per loop 
abs method: 
10 loops, best of 3: 311 ms per loop 
in-place max method: 
10 loops, best of 3: 38.4 ms per loop 

Answer 3

Znalazłem szybszą metodę ReLU z numpy. Możesz również użyć funkcji indeksowania fantazyjnego dla numpy.

ozdobnego index:

20,3 ms ± 272 mikrosekund w każdej pętli (średnia ± standardowym dev 7 zapewnia, 10 pętli każda.).

>>> x = np.random.random((5,5)) - 0.5 
>>> x 
array([[-0.21444316, -0.05676216, 0.43956365, -0.30788116, -0.19952038], 
     [-0.43062223, 0.12144647, -0.05698369, -0.32187085, 0.24901568], 
     [ 0.06785385, -0.43476031, -0.0735933 , 0.3736868 , 0.24832288], 
     [ 0.47085262, -0.06379623, 0.46904916, -0.29421609, -0.15091168], 
     [ 0.08381359, -0.25068492, -0.25733763, -0.1852205 , -0.42816953]]) 
>>> x[x<0]=0 
>>> x 
array([[ 0.  , 0.  , 0.43956365, 0.  , 0.  ], 
     [ 0.  , 0.12144647, 0.  , 0.  , 0.24901568], 
     [ 0.06785385, 0.  , 0.  , 0.3736868 , 0.24832288], 
     [ 0.47085262, 0.  , 0.46904916, 0.  , 0.  ], 
     [ 0.08381359, 0.  , 0.  , 0.  , 0.  ]]) 

jest mój odniesienia:

import numpy as np 
x = np.random.random((5000, 5000)) - 0.5 
print("max method:") 
%timeit -n10 np.maximum(x, 0) 
print("max inplace method:") 
%timeit -n10 np.maximum(x, 0,x) 
print("multiplication method:") 
%timeit -n10 x * (x > 0) 
print("abs method:") 
%timeit -n10 (abs(x) + x)/2 
print("fancy index:") 
%timeit -n10 x[x<0] =0 

max method: 
241 ms ± 3.53 ms per loop (mean ± std. dev. of 7 runs, 10 loops each) 
max inplace method: 
38.5 ms ± 4 ms per loop (mean ± std. dev. of 7 runs, 10 loops each) 
multiplication method: 
162 ms ± 3.1 ms per loop (mean ± std. dev. of 7 runs, 10 loops each) 
abs method: 
181 ms ± 4.18 ms per loop (mean ± std. dev. of 7 runs, 10 loops each) 
fancy index: 
20.3 ms ± 272 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 

Answer 4

Możesz to zrobić w znacznie prostszy sposób bez numpy:

def ReLU(x): 
    return x * (x > 0) 

def dReLU(x): 
    return 1. * (x > 0) 

Answer 5

To jest bardziej precyzyjna realizacja:

def ReLU(x): 
    return abs(x) * (x > 0)