Alfonso Palacio
student•
hace 4 años
Patricia Carolina Perez Felibert
student•
hace 4 años
Ruddy Ramos
student•
hace 3 años
Alfonso Palacio
Patricia Carolina Perez Felibert
Ruddy Ramos
Joseph Lázaro Ricardo
Antonio Demarco Bonino
Jeisson Espinosa
José Rodrigo Arana Hi
Alvaro Daniel Pita Peralta
Daniel Parra
Carlos Eduardo Bracho Rosales
Robert Junior Buleje del Carpio
Marcelo Soto Moreno
Diego Ortiz
Diego López
Arelys Viloria
DANIEL RAFAEL MORALES OJEDA
FELIX DAVID CORDOVA GARCIA
Daniel Andres Rojas Paredes
Clemente Cosetl Pérez
Juan Diego
José Eduardo Nuñez Arenas
Edgardo Riveros Sepulveda
Daniel Andres Rojas Paredes
Si desean ver el consolidado de las funciones de activación que nombraron en la clase y otras utilizadas en el ambito
excelente, gracias!
Buen aporte. Gracias.
Hay un error en la función Signoide, en un signo
Funciones de activación == Darle un valor de salida diferente a todo el proceso del perceptrón
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
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.
Hola platzinautas, encontré este post relacionado con las Funciones de activación https://lamaquinaoraculo.com/computacion/la-funcion-de-activacion/
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)
Freddy Vega sobre las redes neuronales y las funciones de activacion
Función sigmoide.
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)
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)
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
Función de Escalón
Función Sigmoide
Función Tangente Hiperbólica (tanh)
#### 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
La Funcióñ Leaky Relu 🤓📰💚
.
La ecuación de la función Leaky RELU es
f(x) = { x si x >= 0 ; alpha * x si x < 0}
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
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
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}")  
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:
Posibles desventajas:
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.
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.
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
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