Funciones de activación

Estas son mis respuestas 😄

# relu
def relu(x):
  return np.piecewise(x, [x < 0, x > 0], [0, lambda x: x])

# para tanh use la funcion tanh que trae numpy :')
np.tanh(x)

Existen diferentes funciones de activación que pueden ser discretas o continuas:

• Escalón
  
  
• Signo
  
  
• Sigmoid
  
  
• Tanh
  
  
• ReLU
  
  
• Softmax
  
  

ReLu function

def relu(a):
  return np.maximum(0, x)

plt.plot(x, relu(x))

Tanh function*
tanh(x)

def tanh(a):
  return np.tanh(a)

plt.plot(x, tanh(x))

Softmax function

def softmax(a):
  expo = np.exp(x)
  expo_sum = np.sum(np.exp(x))
  return expo/expo_sum

plt.plot(x, softmax(x))

Hola comparto mis funciones:

<code> 
# definicion de la funcion sigmoide
sigmoid = lambda x: 1 / (1+np.exp(-x))

step = lambda x: np.piecewise(x, [x<0.0, x>0.0], [0,1])

relu = lambda x: np.piecewise(x, [x<0, x>0], [0, lambda x:x])

tanh = lambda x: ( np.exp(x) - np.exp(-x) ) / (np.exp(-x) + np.exp(x))

softmax = lambda x: np.exp(x) / np.sum(np.exp(x))

Cordial saludo.
Solución a las funciones de activación:

Hola a todos,
dejo mi respuestas :3

def relu(x):  
    return np.piecewise(x,[x<0.0,x>=0.0],[0,lambda x: x])

def tanh(x):
    #solo aplique la igualdad de tanh  
    n=np.exp(x)-np.exp(-x)
    d=np.exp(x)+np.exp(-x)
    return n/d

En la formula de la función tangente hiperbólica /tan h hay un error, están poniendo la misma fórmula de la función sigmoidal ,la correcta fórmula y su derivada es la siguiente:

Les dejo mi función relu resuelto un poco diferente pero sencillo:

def relu(x):
  return [0 if k<0 else k for k in x]

Mi funcion tangente

def tanh(x):
  return (np.exp(x)- np.exp(-x))/(np.exp(-x)+np.exp(x))

En redes computacionales, la Función de Activación de un nodo define la salida de un nodo dada una entrada o un conjunto de entradas. Se podría decir que un circuito estándar de computador se comporta como una red digital de funciones de activación al activarse como “ON” u “OFF”, dependiendo de la entrada.

!(

!(

Comparto por acá la ELU:

def elu(x, alpha):  
    return np.piecewise(x,[alpha*(np.exp(x)-1)<=0.0,x>0.0],
    [lambda x: alpha*(np.exp(x)-1),lambda x: x])

#Funcion de Activación Relu
import numpy as np
import matplotlib.pyplot as plt

def relu(x):
return np.piecewise(x, [x<0.0, x>0.0],[0,x])

x = np.linspace(10,-10,100)

plt.plot(x, relu(x))

Mis funciones ReLU y tanh

def relu(a):
  return np.piecewise(x, [x >=0.0, x < 0.0], [lambda x : x, 0])

def tanh(a):
  return np.tanh(a)

Mis respuestas al desafio

def relu(x):
    return np.maximum(0,x)
def tanh(x):
    return np.tanh(x)

def relu(x):
  return np.piecewise(x,[x<=0.0,x>0.0],[0,lambda x:x])

def tanh(x):
  return np.tanh(x)

La función ReLU en 4:12 tiene un pequeño error en el signo de comparación: es z >= 0, no <=

Destacar las dos formas para obtener la función relu:

def relu(a):
  return np.piecewise(a, [a <= 0, a > 0], [0, lambda a: a])

def relu2(a):
    return np.maximum(0, a)

seguramente deben haber más.

Como fact, es importante tener en cuenta que numpy retorna el argumento sin definirlo exactamente dentro del scope…!

def relu(x, derivate= False):
  return np.piecewise(x, [x<0.0,x>=0.0],[0,lambda x: x] )

funciona, pero no entiendo ¿por qué funciona?

Mis graficas 😄

Luego de investigar, creo que la forma de utilizar funciones de activacion es asi:

Capas internas tienen buen rendimiento con funcion activacion relu

Cuando la salida es binaria (0,1)

• Ultima capa con activacion sigmoid (obliga a salida binaria 0,1)
• loss = ‘binary_crossentropy’

Cuando la salida es 0-9 (10 categorias)

• Ultima capa con activacion softmax
• loss = ‘categorical_crossentropy’

Si la salida es valores -1,1, es tipo binario

• Ultima capa con activacion tanh (obliga a salida -1 o 1)
• loss = ‘binary_crossentropy’

Resolución:

def relu(a):
  return np.piecewise(a, [a<0.0, a>0.0], [0,lambda x: x])

plt.plot(x, relu(x))

Cuando los valores sean menores a 0, la gráfica irá en 0. Cuando sea mayor a cero, f(x) = x; es decir, f(1) = 1, f(2) = 2, f(3) = 3…
Los valores tanto de y como de x serán los mismos, entonces se trazará una función lineal. En python esta relación se puede establecer con lambda.

def tangente(a):
  return np.tanh(a)

plt.plot(x, tangente(x))

Numpy ya cuenta con esta función, así que es más fácil.

Los aportes de los compañeros son más directos, sin embargo hice este más manual para relu:

def relu(x):
  l1=[]
  for i in x:
    if i < 0:
      result=0
      l1.append(result)
    else:
      l1.append(i)
  return l1

def tangh(x):
f1=(np.exp(x)/(np.exp(-x)+np.exp(x)))
f2=(np.exp(-x)/(np.exp(-x)+np.exp(x)))
return f1-f2

Yo hice la función del relu a la antigua:

x = np.linspace(10,-10,100)

def eval(vtemp):

  if vtemp<=0:
    return 0
  else:
    return vtemp

r1=np.zeros((len(x)))

for i in range(len(x)):
    vtemp = x[i]
    val = eval(vtemp)
    r1[i] = val

plt.plot(x,r1)

Y la tangente hiperbólica si con la función de numpy:

r2 = np.tanh(x)
plt.plot(x,r2)

Un saludo a todos!

lambda x: np.sinh(x)/np.cosh(x)

x = np.linspace(-10,10,100)

plt.plot(x, tanh(x));

def relu(x):
    return np.piecewise(x, [x<0, x>0],[0, lambda x: x])

x = np.linspace(-10,10,100)

plt.plot(relu(x));

Introducción a Redes Neuronales
https://towardsdatascience.com/machine-learning-for-beginners-an-introduction-to-neural-networks-d49f22d238f9

def tanh(a): return np.tanh(a)
def relu(x): return np.piecewise(x, [x < 0.0, x >= 0.0], [0, lambda x: x])

Aquí mis aportes: 😁
.

.

.

.

Buenas tardes:
Primeramente quisiera comentar que la identidad trigonométrica de la tangente hiperbólica puede ser errónea.
Aquí comparto mi solución de la función ReLU y de tangente hiperbólica:

def relu(z):
    return np.piecewise(z, [z<0, z>0], [0, lambda x:x])   
plt.plot(x,relu(x))

plt.plot(x,np.tanh(x))

relu

def relu(x):
  rel = []
  for i in x:
    if i <= 0:
      rel.append(0)
    else:
      rel.append(i)
  return rel