Funciones de activación

Clase 15 de 18 • Curso de Funciones Matemáticas para Data Science e Inteligencia Artificial

Alfonso Palacio

student•

Si desean ver el consolidado de las funciones de activación que nombraron en la clase y otras utilizadas en el ambito

Patricia Carolina Perez Felibert

student•

excelente, gracias!

Ruddy Ramos

student•

Buen aporte. Gracias.

Joseph Lázaro Ricardo

student•

Hay un error en la función Signoide, en un signo

Le dí valores con mi calculadora y no me resultaba, asi que mejor googleé la formula.

Antonio Demarco Bonino

student•

Funciones de activación == Darle un valor de salida diferente a todo el proceso del perceptrón

Jeisson Espinosa

student•

Información resumida de esta clase #EstudiantesDePlatzi

Utilizamos las funciones de activación para valores de salida diferentes a los datos que vienen de la unión sumatoria
La función lineal nos permite mantener valores a lo largo de un proceso y nos regresa el mismo valor de entrada
Cuando necesitamos hacer una clasificación utilizamos la función de escalón, ya que esta nos regresa datos de 1 y 0
La función sigmoide nos sirve para un proceso llamado regresión logística, su valor lo definimos en términos de probabilidades, es decir, nos ayuda a encontrar probabilidades
La función tangente hiperbólica tiene su rango de -1 a 1 y es conocida como función de escalamiento
La función ReLu podemos usarla como un filtro antes de los pesos sinápticos, es decir, esta función toma un valor o lo identifica si es mayor a 0, si es menor a 0 decide no tomar el valor
La función Leaky ReLu toma los valores negativos y los multiplica por un coeficiente rectificativo y los positivos los deja pasar tranquilamente

José Rodrigo Arana Hi

student•

Funciones de activación

Nos sirven para darles diferentes valores de salida a todo el proceso que surge de la combinación lineal (Unión sumadora) en el perceptrón.

Función lineal: mantener valores a lo largo de un proceso, predecir venta
Función escalón o de Heaviside: clasificaciones categóricas, ej. si está apagado o prendido, si existe o no existe. Utiliza valores binarios.
Función sigmoide: regresión logística, sirve cuando hablamos de probabilidades. Su rango va de 0 a 1. Cuando un valor es 0, su función será 0.5.
Función tangente hiperbólica: conocida como función de escalamiento, va de -1 a 1.
Función ReLU: simulación de “neuronas muertas”

Alvaro Daniel Pita Peralta

student•

Hola platzinautas, encontré este post relacionado con las Funciones de activación https://lamaquinaoraculo.com/computacion/la-funcion-de-activacion/

Carlos Eduardo Bracho Rosales

student•

Freddy Vega sobre las redes neuronales y las funciones de activacion

Daniel Parra

student•

Función Leaky ReLU:

def f(x):
  Y = np.zeros(len(x))
  for idx, x in enumerate(x):
    if x >= 0:
      Y[idx] = x
    else:
      Y[idx] = x * 0.01
  return Y

Y = f(x)

plt.grid()
plt.plot(x, Y)
plt.ylim(-2,10)
plt.xlim(-50, 20)

Robert Junior Buleje del Carpio

student•

Función sigmoide.

Marcelo Soto Moreno

student•

Sólo precisar que la fórmula de la función sigmoide en su denominador debe decir 1 + e**-x, y no 1 - e**-x (fórmula antes del código)

Diego López

student•

Funciones de Activación en Redes Neuronales

Las funciones de activación transforman la salida de la unión sumatoria de una neurona, proporcionando la capacidad de manejar datos complejos y no lineales. Aquí tienes una explicación detallada de varias funciones de activación utilizadas en redes neuronales, junto con usos fáciles de entender:

Función Lineal

Descripción: Mantiene los valores a lo largo del proceso, devolviendo el mismo valor de entrada.
Uso**: Ideal para tareas donde la salida necesita ser proporcional a la entrada, como en problemas de regresión lineal.
Ejemplo: Predecir precios de viviendas donde la salida es un valor continuo.

Función de Escalón

Descripción: Clasifica las entradas devolviendo 0 o 1.
Uso: Ideal para tareas de clasificación binaria.
Ejemplo: Determinar si un correo electrónico es spam (1) o no (0).

Función Sigmoide

Descripción: Produce una salida en términos de probabilidades, con un rango de 0 a 1.
Uso: Común en regresión logística, ayuda a encontrar probabilidades.
Ejemplo: Predecir la probabilidad de que un cliente compre un producto.

Función Tangente Hiperbólica (tanh)

Descripción: Tiene un rango de -1 a 1, conocido como función de escalamiento.
Uso: Útil cuando las entradas pueden ser negativas y positivas, centrando los datos alrededor de cero.
Ejemplo: Modelar valores que pueden ser tanto positivos como negativos, como ganancias y pérdidas financieras.

#### Función ReLU (Rectified Linear Unit)

- **Descripción**: Toma un valor y si es mayor a 0 lo deja pasar, si es menor a 0 lo descarta (salida 0).

- **Uso**: Común en capas ocultas de redes neuronales profundas, ayuda a evitar el problema de desvanecimiento del gradiente.

- **Ejemplo**: Usada en redes neuronales para reconocimiento de imágenes, mejorando el aprendizaje de características relevantes.

Función Leaky ReLU

Descripción: Similar a ReLU, pero permite que los valores negativos pasen multiplicados por un pequeño coeficiente (a menudo 0.01).
Uso: Soluciona el problema de que ReLU descarta completamente los valores negativos, permitiendo una pequeña cantidad de información negativa.
Ejemplo: Mejor en escenarios donde no queremos perder toda la información negativa, como en análisis de sentimientos donde los valores negativos también aportan información útil.

Arelys Viloria

student•

La Funcióñ Leaky Relu 🤓📰💚

¿Qué es? La función Leaky RELU es similar a la función RELU, pero en lugar de tener una pendiente cero para valores negativos, tiene una pendiente pequeña. Esto significa que la función no se detiene completamente en valores negativos, lo que puede ayudar a evitar la saturación de la neurona. .
Ventajas y desventajas: Esta función presenta sus ventajas y desventajas, por ejemplo una ventaja es que puede evitar la saturación de la neurona, o también que esta función puede ser más efectiva que la función RELU en algunos casos, especialmente cuando se trabaja con grandes conjuntos de datos. Sin embargo, la función Leaky RELU también tiene algunas desventajas. En primer lugar, el valor de alpha debe ser elegido cuidadosamente, ya que si es demasiado grande, puede hacer que la función se comporte como una función lineal. En segundo lugar, la función Leaky RELU no es adecuada para todas las tareas, y puede ser menos efectiva en algunos casos. .
Utilización: La función Leaky RELU se utiliza en muchas aplicaciones de redes neuronales. Por ejemplo, esta función se utiliza en las redes neuronales convolucionales (CNN), que son ampliamente utilizadas en el procesamiento de imágenes. También se utiliza en las redes neuronales recurrentes (RNN), que se utilizan en el procesamiento del lenguaje natural y en la generación de texto. . La función Leaky RELU también se utiliza en las redes neuronales profundas, que son redes neuronales con muchas capas. Estas redes suelen tener problemas de saturación de la neurona, y la función Leaky RELU puede ayudar a evitar este problema. .

La ecuación de la función Leaky RELU es

			 f(x) = { x si x >= 0 ; alpha * x si x < 0}

donde alpha es un número pequeño y positivo. . Representación gráfica:

DANIEL RAFAEL MORALES OJEDA

student•

tengo uan duda, quizás sirva para una corrección, en la funcion sigmoide en el denominador, la formula le resta a 1 la exponencial (e), pero en el colab se lo suma

FELIX DAVID CORDOVA GARCIA

student•

El profe se confundió en el colab , el signo es suma , incluso el se dio cuenta y por eso baja rapido esa parte en el video

Daniel Andres Rojas Paredes

student•

hola le pedi a la IA que me generara un codigo para un perceptron, luego me puse a pasarlo a limpio entendiendo cada una de sus partes, y cambiando nombres . segun yo el codigo esta en congruencia con la teoria, mas sin embargo al entrenarlo con datos de una compuerta and, y preguntarle por eos mismos datos me responde como si fuera una compuerta or , y no entiendo por que

algun curioso me puede resolver la duda?

import numpy as np
class Perceptron:
    def __init__(self,learningRate:float,repetitions:int):
        if not isinstance(learningRate,float)or not isinstance(repetitions,int):
            raise TypeError('arguments most be float and int in that order')
        elif learningRate <= 0 or repetitions<=0 :
            raise ValueError('arguments must be  positive and greater than 0')
        try:

            self.learnningRate=learningRate
            self.repetitions=repetitions
            self.weights=None
            self.bias=None
        except (ValueError,TypeError) as e:
            print(e)
    def step_func(self,x):
        return np.where(x>0,1,0)
    def trainning (self,trainningIn:np.ndarray,trainningOut:np.ndarray):
        samples,features=trainningIn.shape
        self.weights=np.zeros(features);
        self.bias=0;
        for _ in range(self.repetitions):
            for index,sample in enumerate(trainningIn):
                linear_output=np.dot(sample,self.weights+self.bias)
                prediction=self.step_func(linear_output)
                #regla delta usada en problemas de clasificacion no de minimizacion del error o regresion
                update=self.learnningRate*(trainningOut[index]-prediction)
                self.weights+=sample*update
                self.bias+=update
    def predict(self,inputData):
        linearOutput=np.dot(inputData,self.weights+self.bias)
        prediction=self.step_func(linearOutput)
        return prediction
# Datos de entrenamiento
y = np.array([0, 0, 0, 1])
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])

# Inicializar y entrenar el perceptrón
perceptron = Perceptron(0.09, 50)
perceptron.trainning(X, y)
print(f'trainning data input{X} output{y}')
# Hacer predicciones
predicciones = perceptron.predict(X)
print(f"Predicciones para el conjunto d eentrenamiento: {predicciones}")

X = np.array([[1, 1], [1,0], [0, 0], [0, 1]])
predicciones = perceptron.predict(X)
print(f"Predicciones para un nuevo conjunto {X} : {predicciones}")
        
```import numpy as npclass Perceptron:    def \_\_init\_\_(self,learningRate:float,repetitions:int):        if not isinstance(learningRate,float)or not isinstance(repetitions,int):            raise TypeError('arguments most be float and int in that order')        elif learningRate <= 0 or repetitions<=0 :            raise ValueError('arguments must be  positive and greater than 0')        try:
            self.learnningRate=learningRate            self.repetitions=repetitions            self.weights=None            self.bias=None        except (ValueError,TypeError) as e:            print(e)    def step\_func(self,x):        return np.where(x>0,1,0)    def trainning (self,trainningIn:np.ndarray,trainningOut:np.ndarray):        samples,features=trainningIn.shape        self.weights=np.zeros(features);        self.bias=0;        for \_ in range(self.repetitions):            for index,sample in enumerate(trainningIn):                linear\_output=np.dot(sample,self.weights+self.bias)                prediction=self.step\_func(linear\_output)                #regla delta usada en problemas de clasificacion no de minimizacion del error o regresion                update=self.learnningRate\*(trainningOut\[index]-prediction)                self.weights+=sample\*update                self.bias+=update    def predict(self,inputData):        linearOutput=np.dot(inputData,self.weights+self.bias)        prediction=self.step\_func(linearOutput)        return prediction# Datos de entrenamientoy = np.array(\[0, 0, 0, 1])X = np.array(\[\[0, 0], \[0, 1], \[1, 0], \[1, 1]])
\# Inicializar y entrenar el perceptrónperceptron = Perceptron(0.09, 50)perceptron.trainning(X, y)print(f'trainning data input{X} output{y}')# Hacer prediccionespredicciones = perceptron.predict(X)print(f"Predicciones para el conjunto d eentrenamiento: {predicciones}")
X = np.array(\[\[1, 1], \[1,0], \[0, 0], \[0, 1]])predicciones = perceptron.predict(X)print(f"Predicciones para un nuevo conjunto {X} : {predicciones}")       &#x20;

Clemente Cosetl Pérez

student•

Leaky ReLU (Rectified Linear Unit con fuga) es una función de activación que mejora una limitación importante de la función ReLU tradicional: el problema de las "neuronas muertas".

En ReLU todo lo que esté por debajo de 0 da como resultado 0. Si una neurona recibe entradas negativas constantemente, su salida será siempre cero, y no se actualizará durante el entrenamiento. A esto se le llama una neurona muerta.

Leaky ReLU introduce una pequeña pendiente (en lugar de un 0 total) para los valores negativos:

Donde α es un número pequeño positivo, típicamente 0.01.

Ventajas de Leaky ReLU:

Reduce el problema de las neuronas muertas
Introduce algo de no linealidad incluso en la parte negativa
Mantiene la eficiencia de ReLU

Posibles desventajas:

El valor de α debe ser bien elegido (si es muy grande, puede afectar el rendimiento)
No es tan ampliamente adoptado como ReLU, pero se usa bastante en algunos contextos

Juan Diego

student•

El proceso de normalización de datos y las funciones de activación están relacionados en la preparación y el procesamiento de datos para modelos de aprendizaje automático. La normalización ajusta los datos a un rango específico, lo que mejora la convergencia durante el entrenamiento. Las funciones de activación, como la sigmoide o ReLU, transforman la salida de las neuronas, introduciendo no linealidades al modelo. Ambas técnicas buscan optimizar el rendimiento del modelo, asegurando que las entradas estén en un rango adecuado y que las salidas tengan la capacidad de capturar patrones complejos.

José Eduardo Nuñez Arenas

student•

Un ejemplo en "la vida real" de cada una de las funciones

Función Lineal: Imagina que estás midiendo la cantidad de agua que sale de un grifo en función del tiempo. Si solo quieres una relación directa donde cada segundo aumente la cantidad de agua de manera constante, podrías usar una función de activación lineal para modelar este comportamiento.

Función de Escalón: Supongamos que tienes un sensor que detecta si una habitación está iluminada o no. Si solo te interesa saber si la habitación está suficientemente iluminada o no, podrías usar una función de escalón para encender una lámpara si la habitación está oscura y apagarla si está iluminada.

Función Sigmoide: Imagina que estás desarrollando un sistema de recomendación para una plataforma de streaming de películas. Podrías usar una función sigmoide en la capa de salida para predecir la probabilidad de que un usuario le guste una película, generando una puntuación de "me gusta" entre 0 y 1.

Función Hiperbólica (Tanh): Supongamos que estás creando un chatbot que responde a las emociones del usuario. Podrías usar una función hiperbólica para mapear las respuestas emocionales de los usuarios en un rango entre -1 (emoción negativa) y 1 (emoción positiva), lo que ayudaría al chatbot a responder de manera más apropiada.

Función ReLU (Rectified Linear Activation): Imagina que estás entrenando un modelo para reconocer dígitos escritos a mano. Si usas una función ReLU en las capas ocultas, la neurona se activaría solo si la entrada es positiva, lo que permitiría que el modelo se concentre en las partes relevantes de la imagen y ignore las partes en blanco.

Edgardo Riveros Sepulveda

student•

La clase en un código solo quiero presumir jajaja:

# Dependencias
import numpy as np
import matplotlib.pyplot as plt

import os
import sys
os.system('clear') # Limpiar la consola en macOS

# Variables    <================================================================================================ 
N = 1000
x = np.linspace(-5,5, num=N)

# FUNCIONES    <================================================================================================ 

# Función lineal    <====================================================
# sirve para mantener valores a lo proceso
# 𝑦=𝑚𝑥+𝑏

def f_l(x):
  return  (1/4) * x  # 1/ 4 es para compresion para que se vea bien en graficacion
 
# Función escalón o de Heaviside     <====================================
# valores menosre que cero seran cero  los superiores seran uno
# clasificacion categoricas
# 𝐻(𝑥)={0,1,para, 𝑥<0para. 𝑥≥0

def H(x):
  Y = np.zeros(len(x))
  for idx,x in enumerate(x):
    if x>=0:
      Y[idx]=1
  return Y

y_Heaviside = H(x)
 
# Función sigmoide    <===================================================
# regresan valores de 0 a 1
# mas la variable independiente sera 1
# 𝑓(𝑥)=11−𝑒−𝑥

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

y_sigmoide = f_s(x)
 
# Función tangente hiperbólica    <=======================================
# ya implementada
# algoritmo de backpropecion
# parecida a sigmoide
# 𝑓(𝑥)=21+𝑒−2𝑥−1

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

y_tanh = f_tanh(x)

# Función ReLU     <=======================================================
# valores menores de cero seran cero
# para descibir neuronas muertas
# 𝑅(𝑥)=𝑚𝑎𝑥(0,𝑥)

def f_Re(x):  
  return np.maximum(x,0)   

y_Re = (1/4) * f_Re(x) # 1/ 4 es para compresion para que se vea bien en graficacion

# zona ploteo <==================================================================================================

plt.plot(x,f_l(x),      'b', lw=1, label='Función lineal') # <=================== • Función lineal

plt.plot(x,y_Heaviside, 'r', lw=1, label='Función escalón o de Heaviside') # <=== • Función escalón o de Heaviside

plt.plot(x,y_sigmoide,  'g', lw=1, label='Función sigmoide') # <================= • Función sigmoide

plt.plot(x,y_tanh,      'c', lw=1, label='Función tangente hiperbólica') # <===== • Función tangente hiperbólica

plt.plot(x,y_Re,        'k', lw=1, label='Función ReLU') # <===================== • Función ReLU

plt.title('=> Ejemplos de Funciones de activacion <=')
plt.xlabel('eje X')
plt.ylabel('ejej Y')
plt.grid()
plt.legend()
plt.show() # <= pata que aparesca en panatalla

Daniel Andres Rojas Paredes

student•

Estas funciones de activacion son necesarias para convertir la sumatoria de varios modelos lineales en algo no lineal (suma y multiplicacion son operaciones lineales) sin complejisar demaciado el bloque inicial (perseptron) de no usarse toda agrupacion de perceptrones colapsaria a un perseptron

Daniel Andres Rojas Paredes

student•

les recomiendo pensar en estas funciones como una alfombra vista de perfil