Mostrar los tags: relu

Aplicación de la función ReLU a cada píxel.

Python

Publicado el 29 de Abril del 2024 por Hilario (126 códigos)

131 visualizaciones desde el 29 de Abril del 2024

******************************************************
********************************************************

Aula_28_Aplicar_Relu.py
*****************************
Este ejercicio que proponemos es sumamente sencillo. No por ello es importante dentro del desarrollo de redes neuronales.
Lo hacemos con el fin de aplicar una funcion Relu auna imagen, en un proceso usual dentro de las redes neuronales.

Indiquemos brevemente lo que es una funcion RELU.
---------------------------------------------------------------------
La función ReLU (Rectified Linear Unit) es una función de activación comúnmente utilizada en redes neuronales
y otras técnicas de aprendizaje automático. Se define matemáticamente de la siguiente manera:

f(x)={ 0,x
si x≤0
si x>0
O en otras palabras, de forma más sencilla,
la función ReLU devuelve 0 para todos los valores de entrada que son negativos o iguales a cero,
y devuelve el mismo valor de entrada para valores positivos.

En el contexto de redes neuronales, la función ReLU se utiliza típicamente como función de activación
en las capas ocultas debido a su simplicidad y eficiencia computacional. Permite la introducción
de no linealidades en el modelo, lo que ayuda a que la red neuronal pueda aprender
representaciones más complejas de los datos de entrada.
*************************************************************************************************
En este ejercicio pretendemos aplicar esta función a una imagen dimensionada previamente.

Pasamos a explicar el mismo con poco de detalle.
1-Importa las bibliotecas necesarias:
numpy para el procesamiento numérico y matplotlib.pyplot para visualizar la imagen.

import numpy as np
import matplotlib.pyplot as plt
-------------------------------------------------------------------------
2-Definimos una función llamada apply_relu que toma
una imagen como entrada y aplica la función ReLU a cada píxel de la imagen.

def apply_relu(imagen):
alto, ancho, canales = imagen.shape
imagen_relu = np.zeros_like(imagen)
for i in range(alto):
for j in range(ancho):
for k in range(canales):
imagen_relu[i, j, k] = max(0, imagen[i, j, k])
return imagen_relu
-----------------------------------------------------------------------------------------
3- Carga la imagen desde un archivo. En este caso, la ruta del archivo es
/home/margarito/python/imagen.jpg.
En vuestro caso deberéis modificar esta ruta con la situación del archivo imagen.
imagen = plt.imread('/home/margarito/python/imagen.jpg')
-----------------------------------------------------------------------------------------

4-Obtiene las dimensiones de la imagen (alto y ancho) utilizando la función shape.

alto, ancho, _ = imagen.shape
----------------------------------------------------------------------------------
5-Muestra la imagen original utilizando plt.imshow.

plt.imshow(imagen)
plt.title('Imagen Original')
plt.axis('off')
plt.show()
-----------------------------------------------------------------------------------
6-Aplica la función ReLU a la imagen cargada utilizando la función apply_relu definida anteriormente

imagen_relu = apply_relu(imagen)
---------------------------------------------------------------------------------------
7-Muestra la imagen después de aplicar la función ReLU utilizando plt.imshow.
plt.imshow(imagen_relu)
plt.title('Imagen aplicando la función ReLU')
plt.axis('off')
plt.show()
*************************************************************************************

Como se puede comprobar apenas existe una modificación visible, entre las dos
imagenes, antes y después de aplicar la función Relu.
Esto puede ser debido a que los valores negativos son escasos en el array 2D de la imagen.
********************************************************************************************************
---------------------------------------------------------------------------------------------------
Este ejercicio fue ejecutado en una plataforma Linux, Ubuntu 20.04.6 LTS.
Editado con Sublime Text.

Para que su funcionamiento y ejecucion sea correcto
se deberá de tener instalado en vuestro sistema
la versión numpy-1.24.4.
Es conveniente hacer este comando en consola, para actualizarlo:

pip install --upgrade numpy
************************************************************************
Ejecución del ejercicio en linea bajo consola:
python3 Aula_28_Aplicar_Relu.py
-----------------------------------------------------------------------

CLASES EN PYTHON.

Python

Publicado el 2 de Agosto del 2023 por Hilario (126 códigos)

326 visualizaciones desde el 2 de Agosto del 2023

---------------------------------------------------------------------
In vino veritas

////////////////////////////////////////////////////////////////////
Hilario Iglesias Martínez.
////////////////////////////////////////////////////////////////////

Archivo de clase NeuralNetwork.py
********************************
Descripción:
***********
Este archivo contiene la implementación de la clase NeuralNetwork, que representa una red neuronal básica con una capa oculta y una capa de salida. La clase está diseñada para ser utilizada en problemas de clasificación binaria, donde se tienen características de entrada y se desea predecir una salida binaria. He adoptado la predicción binaria por ser la más usual para el ejemplo.

Dentro de NeuralNetwork.py, encontrarás las siguientes partes:

Importaciones:
El archivo puede comenzar con importaciones de bibliotecas necesarias, como NumPy, para realizar operaciones matemáticas en matrices.

Definición de funciones de activación:
Es probable que encuentres las definiciones de funciones de activación como ReLU, sigmoid, y sigmoid_derivative. Estas funciones son esenciales para realizar las operaciones en las capas oculta y de salida de la red neuronal.

Definición de la clase NeuralNetwork:
Dentro de la clase NeuralNetwork, encontrarás el constructor __init__, donde se definen los atributos de la red neuronal, como el tamaño de entrada, el tamaño de la capa oculta y el tamaño de salida. También se inicializan los pesos y sesgos aleatoriamente para la capa oculta y de salida.

Métodos de la clase:
En la clase, encontrarás métodos que son esenciales para el funcionamiento de la red neuronal, como forward para propagar hacia adelante, backward para propagar hacia atrás y actualizar los pesos, train para entrenar la red neuronal con datos de entrenamiento y predict para hacer predicciones con datos de entrada nuevos.

Datos de entrenamiento y prueba:
Es posible que encuentres una sección con datos de entrenamiento y prueba, que se utiliza para entrenar y probar la red neuronal. Con ellos podrás jugar con esta red neuronal modificando parámetros y viendo los resultados.

La clase NeuralNetwork proporcionada en NeuralNetwork.py debería estar bien implementada y lista para ser utilizada en otro script, como se muestra en tu archivo neuro.py.

************************************************************************************

Archivo: neuro.py
****************

Descripción:
El archivo neuro.py es el script principal que utiliza la clase NeuralNetwork definida en el archivo NeuralNetwork.py. En este archivo, se lleva a cabo la creación de una instancia de la red neuronal, se realiza el entrenamiento y se hace una predicción con la red entrenada.

Contenido:

Importaciones:
En el archivo neuro.py, probablemente encontrarás algunas importaciones de bibliotecas necesarias para que el código funcione correctamente. Por ejemplo, es posible que encuentres una importación de NumPy para trabajar con matrices y realizar operaciones matemáticas.

Datos de entrenamiento y prueba:
El archivo contendrá una sección donde se definen los datos de entrenamiento y prueba. En el ejemplo proporcionado, los datos de entrenamiento X y y son matrices NumPy que representan características de entrada y resultados esperados (etiquetas) para una tarea de clasificación binaria.

Creación de la instancia de la red neuronal:
En este archivo, se creará una instancia de la clase NeuralNetwork definida en NeuralNetwork.py. Esto se hace mediante la creación de un objeto de la clase con los tamaños de entrada, capa oculta y capa de salida adecuados.

Entrenamiento de la red neuronal:
Una vez creada la instancia de la red neuronal, se procede a entrenarla utilizando el método train. En el ejemplo proporcionado, se entrena la red durante 10000 épocas (iteraciones) con una tasa de aprendizaje de 0.01. Durante el entrenamiento, los pesos y sesgos de la red se ajustarán para reducir la pérdida y mejorar el rendimiento de la red en la tarea de clasificación.

Predicción con la red neuronal entrenada:
Después de entrenar la red, se realiza una predicción utilizando el método predict de la red neuronal con datos de entrada nuevos o de prueba. En el ejemplo proporcionado, se hace una predicción con un conjunto de datos de entrada input_data utilizando la red neuronal previamente entrenada.

Es importante tener en cuenta que el contenido específico del archivo neuro.py puede variar según el problema que se esté abordando y cómo se haya implementado la clase NeuralNetwork en el archivo NeuralNetwork.py. Sin embargo, la estructura general debería seguir siendo similar a lo que se describió anteriormente.

*******************************************************************************
Programa realizado en una plataforma linux, en concreto Ubuntu 20.04.6 LTS.
Se ha utilizado como editor, IDE: Sublime Text.
Realizado bajo Python 3.8.10

Se entiende que los archivos: neuro.py y la clase NeuralNetwork.py deben estar
bajo el mismo directorio.

EJECUCIÓN.
-----------------
Bajo consola linux.
mismo directorio.
python3 neuro.py

El resultado que debería dar es una Predicción semejante a esta:

Predicción: [[0.50623887]]