[PYTHON] Numpy에서 ReLU 기능을 구현하는 방법

Numpy에서 ReLU 기능을 구현하는 방법

나는 간단한 신경망을 만들고 싶다. ReLU 기능을 사용하고 싶다. 누군가가 numpy를 사용하여 함수를 구현할 수있는 방법에 대한 단서를 제공 할 수 있습니까? 시간 내 줘서 고마워!

해결법

1. ==============================

   1.몇 가지 방법이 있습니다.

   몇 가지 방법이 있습니다.

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

   결과에 다음 코드를 사용하여 타이밍을 지정하는 경우

   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
   

   우리는 얻는다 :

   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
   

   그래서 곱셈이 가장 빠를 것 같습니다.

2. ==============================

   2.x가 수정되는 것에 신경 쓰지 않는다면 np.maximum (x, 0, x)을 사용하십시오. 이것은 Daniel S.에 의해 지적되었습니다. 사람들이 그것을 간과하기 때문에 훨씬 더 빠르며, 대답으로 다시 게시 할 것입니다. 비교 결과는 다음과 같습니다.

   x가 수정되는 것에 신경 쓰지 않는다면 np.maximum (x, 0, x)을 사용하십시오. 이것은 Daniel S.에 의해 지적되었습니다. 사람들이 그것을 간과하기 때문에 훨씬 더 빠르며, 대답으로 다시 게시 할 것입니다. 비교 결과는 다음과 같습니다.

   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
   

3. ==============================

   3.나는 numLpy로 ReLU를위한 더 빠른 방법을 발견했다. numpy의 멋진 색인 기능을 사용할 수도 있습니다.

   나는 numLpy로 ReLU를위한 더 빠른 방법을 발견했다. numpy의 멋진 색인 기능을 사용할 수도 있습니다.

   공상 색인 :

   루프 당 20.3ms ± 272μs (평균 ± 표준 편차 7 회, 각각 10 회 반복)

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

   여기 내 벤치 마크입니다 :

   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)
   

4. ==============================

   4.훨씬 쉬운 방법으로 numpy없이 할 수 있습니다.

   훨씬 쉬운 방법으로 numpy없이 할 수 있습니다.

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

5. ==============================

   5.Richard Möhn의 비교는 공평하지 않습니다. Andrea Di Biagio의 의견에 따르면, in-place 방식 인 np.maximum (x, 0, x)은 첫 번째 루프에서 x를 수정할 것입니다. 그래서 여기 내 벤치 마크입니다 :

   Richard Möhn의 비교는 공평하지 않습니다. Andrea Di Biagio의 의견에 따르면, in-place 방식 인 np.maximum (x, 0, x)은 첫 번째 루프에서 x를 수정할 것입니다. 그래서 여기 내 벤치 마크입니다 :

   import numpy as np
   
   def baseline():
       x = np.random.random((5000, 5000)) - 0.5
       return x
   
   def relu_mul():
       x = np.random.random((5000, 5000)) - 0.5
       out = x * (x > 0)
       return out
   
   def relu_max():
       x = np.random.random((5000, 5000)) - 0.5
       out = np.maximum(x, 0)
       return out
   
   def relu_max_inplace():
       x = np.random.random((5000, 5000)) - 0.5
       np.maximum(x, 0, x)
       return x 
   

   타이밍 :

   print("baseline:")
   %timeit -n10 baseline()
   print("multiplication method:")
   %timeit -n10 relu_mul()
   print("max method:")
   %timeit -n10 relu_max()
   print("max inplace method:")
   %timeit -n10 relu_max_inplace()
   

   결과 얻기 :

   baseline:
   10 loops, best of 3: 425 ms per loop
   multiplication method:
   10 loops, best of 3: 596 ms per loop
   max method:
   10 loops, best of 3: 682 ms per loop
   max inplace method:
   10 loops, best of 3: 602 ms per loop
   

   In-place 최대 방법은 최대 방법보다 약간 빠르며 'out'에 대한 변수 할당을 생략하기 때문에 가능합니다. 그리고 그것은 여전히 ​​곱셈 방법보다 느립니다. 그리고 ReLU 함수를 구현하고 있기 때문에. relu를 통해 백 드롭을 위해 'x'를 저장해야 할 수도 있습니다. 예 :

   def relu_backward(dout, cache):
       x = cache
       dx = np.where(x > 0, dout, 0)
       return dx
   

   그래서 곱셈 방법을 사용하는 것이 좋습니다.

6. ==============================

   6.이것은보다 정확한 구현입니다.

   이것은보다 정확한 구현입니다.

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

7. ==============================

   7.Relu에 3 개의 매개 변수 (t0, a0, a1)가 있다면, 우리는

   Relu에 3 개의 매개 변수 (t0, a0, a1)가 있다면, 우리는

   if x > t0:
       x = x * a1
   else:
       x = x * a0
   

   다음 코드를 사용할 수 있습니다.

   X = X * (X > t0) * a1 +  X * (X < t0) * a0
   

   X에는 ​​행렬이 있습니다.

from https://stackoverflow.com/questions/32109319/how-to-implement-the-relu-function-in-numpy by cc-by-sa and MIT license