Funciones de activación

Curso de Funciones Matemáticas para Data Science e Inteligencia Artificial

Contenido del curso

Aprendamos lo elemental

Todo sobre funciones

Funciones en ciencia de datos

Modela tu primer función

Este no es el fin

18
Te has iniciado detrás del secreto de la ciencia de datos
02:22 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:11

Funciones de activación

Curso de Funciones Matemáticas para Data Science e Inteligencia Artificial

Clase 15 de 18

Clase 15 / 18

Comentarios (41)41 comentarios

Alfonso Palacio

Hace 5 años

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

Hace 5 años

excelente, gracias!

Ruddy Ramos

Hace 4 años

Buen aporte. Gracias.

Joseph Lázaro Ricardo

Hace 4 años

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

Hace 5 años

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

Jeisson Espinosa

Hace 4 años

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

Hace 4 años

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

Hace 5 años

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

Diego Ortiz

Hace 9 meses

En la era moderna (2026) ya no se usa ReLU como función de activación, es más común GeLU y SwiGLU es la óptima hoy en día (implementada desde Llama3)

Daniel Parra

Hace 4 años

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)

Arelys Viloria

Hace 3 años

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:

Carlos Eduardo Bracho Rosales

Hace 4 años

Freddy Vega sobre las redes neuronales y las funciones de activacion

Robert Junior Buleje del Carpio

Hace 5 años

Función sigmoide.

Marcelo Soto Moreno

Hace 5 años

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)

José Eduardo Nuñez Arenas

Hace 3 años

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.

Diego López

Hace 2 años

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.

DANIEL RAFAEL MORALES OJEDA

Hace 5 años

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

Hace 5 años

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

Luis Miguel Rodríguez

Hace 6 meses

Daniel Andres Rojas Paredes

Hace 2 años

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

Hace un año

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 Ussa Aponte

Hace un año

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.

Adrianh De Lucio Chavero

Hace 6 meses

Muchas gracias! Intente aprender sobre funciones de activacion hace tiempo y nunca lo termine de entender hasta hoy 💚

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)

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;

Aprendamos lo elemental

Necesitas aprender sobre funciones

¿Qué es una función?

Tipos de variables

Dominio y rango de una función

Cómo leer las matemáticas: Símbolos generales

Cómo leer las matemáticas: Conjuntos

Todo sobre funciones

Funciones algebraicas lineales

Funciones algebraicas polinómicas

Funciones trascendentes

Funciones seccionadas

Funciones compuestas

¿Cómo manipular funciones?

Características de las Funciones Reales

Funciones en ciencia de datos

Conoce al perceptrón

Funciones de activación

Modela tu primer función

Entendiendo la regresión lineal simple

¿Cómo se calcula un error?

Este no es el fin

Te has iniciado detrás del secreto de la ciencia de datos

Funciones de activación

Progreso del curso

Aprendamos lo elemental

Todo sobre funciones

Funciones en ciencia de datos

Modela tu primer función

Este no es el fin

Recursos

Recursos