Código de Python - Función Softmax

Imágen de perfil

Función Softmaxgráfica de visualizaciones


Python

Publicado el 30 de Enero del 2024 por Hilario (126 códigos)
268 visualizaciones desde el 30 de Enero del 2024
*******************************************************************************************************************
Figure_1
Figure_2
Figure_3
Figure_4
Figure_5
Figure_6

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

Ejercicios:Aula_28_Softmax.py - Aula_28_softmax_pooling.py

Proponemos dos ejemplos en los utilizamos la función softmax, en una sencilla red convolucional CNN
En el primer ejemplo lo hacemos sin aplicar maxpooling, en el segundo ejemplo lo hacemos aplicando maxpooling

La función Softmax toma un vector de logits y produce una distribución de probabilidad sobre las clases. Esto es útil en problemas de clasificación, ya que permite interpretar las salidas de la red como la probabilidad de que una entrada pertenezca a cada clase posible. La clase con la probabilidad más alta se considera la predicción final de la red. Este enfoque es especialmente útil en problemas de clasificación multiclase, como el reconocimiento de dígitos en el conjunto de datos MNIST.


La función Softmax se utiliza para calcular probabilidades finales en el contexto de clasificación. Después de aplicar Softmax a los logits (las salidas de la red antes de aplicar ninguna función de activación en la capa de salida), obtienes un conjunto de valores que representan las probabilidades de pertenencia a cada clase posible.

Estas probabilidades están normalizadas de manera que sumen 1. Cada valor indica la probabilidad estimada de que la entrada pertenezca a la clase correspondiente. La clase con la probabilidad más alta se considera la predicción final del modelo.

Entonces, en resumen, Softmax toma los logits y los convierte en una distribución de probabilidad sobre las clases, lo que facilita la interpretación y la toma de decisiones al seleccionar la clase con la probabilidad más alta como la predicción final del modelo.

La aplicación de la función Softmax generalmente se realiza en la capa de salida de la red neuronal, justo antes de tomar la decisión final sobre la clase a la que pertenece la entrada. En términos de programación, esto se realiza comúnmente como parte de la definición del modelo en el código.
********************************************************************************************************************

Para realizar este ejercicio tomamos datos MNIST.
MNIST es un conjunto de datos ampliamente utilizado en el campo de la visión por computadora y el aprendizaje profundo. Este conjunto de datos consiste en imágenes en escala de grises de dígitos escritos a mano (0 al 9), cada una de 28x28 píxeles. MNIST se utiliza comúnmente como un punto de partida para probar y desarrollar algoritmos de reconocimiento de imágenes utilizando redes neuronales convolucionales.

El objetivo típico es entrenar un modelo para clasificar correctamente las imágenes en sus respectivas categorías de dígitos. Muchos investigadores y desarrolladores utilizan MNIST como una especie de "Hello World" para la visión por computadora, ya que proporciona un caso de prueba relativamente simple pero efectivo para evaluar el rendimiento de modelos de aprendizaje profundo en tareas de clasificación de imágenes.
********************************************************************************************************************
Ejercicio realizado bajo plataforma Linux.
Ubuntu 20.04.6 LTS

---------------------------------------------------------------
Ejecución bajo consola Linux:
python3 Aula_28_softmax_pooling.py
python3 Aula_28_softmax_pooling.py

--------------------------------------------------------------------
Se deberá tener cargado en el sistema estos módulos:
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import fashion_mnist
import matplotlib.pyplot as plt
-------------------------------------------------------------------
Para que vustro ordenador no produzca desbordamiento:Instrucción ilegal (`core' generado)

Vuestro ordenador deberá tener una cpu que soprte AVX (Advanced Vector Extensions) que es una extensión de instrucciones introducida por Intel y AMD en sus procesadores para realizar operaciones de manera más eficiente, especialmente en tareas que involucran cálculos en paralelo. Cuando se dice que una CPU "soporta AVX", significa que es capaz de ejecutar las instrucciones AVX.

Las instrucciones AVX permiten realizar operaciones en vectores más grandes de datos simultáneamente, lo que puede mejorar significativamente el rendimiento en aplicaciones que están optimizadas para utilizar estas extensiones. Este tipo de instrucciones son particularmente beneficiosas en tareas intensivas en cálculos, como aquellas encontradas en aplicaciones científicas, de inteligencia artificial, gráficos 3D y procesamiento de señales, entre otras.

En el contexto de programación y desarrollo de software, si un procesador es compatible con AVX, los desarrolladores pueden aprovechar estas instrucciones para optimizar sus programas y mejorar el rendimiento en hardware que admite esta tecnología. Sin embargo, es importante destacar que no todos los procesadores admiten AVX y que la capacidad de aprovechar estas instrucciones depende del soporte tanto del hardware como del software.

*******************************************************************************************************************
Si vuestra CPU, no cubre estos requisitos, también se pueden ejecutar con Google Colab.
******************************************************************************************************************

Requerimientos

*****************************************************************************************************************
********************************************************************************************************************
Ejercicio realizado bajo plataforma Linux.
Ubuntu 20.04.6 LTS

---------------------------------------------------------------
Ejecución bajo consola Linux:
python3 Aula_28_softmax_pooling.py
python3 Aula_28_softmax_pooling.py

--------------------------------------------------------------------
Se deberá tener cargado en el sistema estos módulos:
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import fashion_mnist
import matplotlib.pyplot as plt
-------------------------------------------------------------------
Para que vustro ordenador no produzca desbordamiento:Instrucción ilegal (`core' generado)

Vuestro ordenador deberá tener una cpu que soprte AVX (Advanced Vector Extensions) que es una extensión de instrucciones introducida por Intel y AMD en sus procesadores para realizar operaciones de manera más eficiente, especialmente en tareas que involucran cálculos en paralelo. Cuando se dice que una CPU "soporta AVX", significa que es capaz de ejecutar las instrucciones AVX.

Las instrucciones AVX permiten realizar operaciones en vectores más grandes de datos simultáneamente, lo que puede mejorar significativamente el rendimiento en aplicaciones que están optimizadas para utilizar estas extensiones. Este tipo de instrucciones son particularmente beneficiosas en tareas intensivas en cálculos, como aquellas encontradas en aplicaciones científicas, de inteligencia artificial, gráficos 3D y procesamiento de señales, entre otras.

En el contexto de programación y desarrollo de software, si un procesador es compatible con AVX, los desarrolladores pueden aprovechar estas instrucciones para optimizar sus programas y mejorar el rendimiento en hardware que admite esta tecnología. Sin embargo, es importante destacar que no todos los procesadores admiten AVX y que la capacidad de aprovechar estas instrucciones depende del soporte tanto del hardware como del software.

*******************************************************************************************************************
Si vuestra CPU, no cubre estos requisitos, también se pueden ejecutar con Google Colab.
******************************************************************************************************************

V-0

Publicado el 30 de Enero del 2024gráfica de visualizaciones de la versión: V-0
269 visualizaciones desde el 30 de Enero del 2024
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
*******************************************************************************************************************
 
#Aula_28_Softmax.py
 
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import fashion_mnist
import matplotlib.pyplot as plt
 
# Cargar el conjunto de datos Fashion MNIST
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
 
# Normalizar las imágenes y cambiar su forma
train_images, test_images = train_images / 255.0, test_images / 255.0
 
# Crear el modelo de red neuronal simple
model = models.Sequential([
    layers.Flatten(input_shape=(28, 28)),        # Aplanar la imagen
    layers.Dense(128, activation='relu'),         # Capa oculta con activación ReLU
    layers.Dense(10, activation='softmax')        # Capa de salida con activación Softmax
])
 
# Compilar el modelo
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
 
# Entrenar el modelo
model.fit(train_images, train_labels, epochs=5)
 
# Evaluar el modelo en el conjunto de prueba
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'\nExactitud en el conjunto de prueba: {test_acc}')
 
# Hacer predicciones con el modelo
predictions = model.predict(test_images)
 
# Visualizar algunas predicciones y probabilidades
for i in range(5):
    plt.figure()
    plt.imshow(test_images[i], cmap=plt.cm.binary)
    plt.title(f"Etiqueta real: {test_labels[i]}, Predicción: {tf.argmax(predictions[i])}")
    plt.show()
 
*********************************************************************************************************
 
# Aula_28_softmax_pooling.py
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import fashion_mnist
import matplotlib.pyplot as plt
 
# Cargar el conjunto de datos Fashion MNIST
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
 
# Normalizar las imágenes y cambiar su forma
train_images, test_images = train_images / 255.0, test_images / 255.0
 
# Crear el modelo de red neuronal con MaxPooling
model = models.Sequential([
    layers.Reshape((28, 28, 1), input_shape=(28, 28)),  # Agregar dimensión de canal
    layers.Conv2D(32, (3, 3), activation='relu'),       # Primera capa convolucional
    layers.MaxPooling2D((2, 2)),                       # Capa de MaxPooling
    layers.Conv2D(64, (3, 3), activation='relu'),       # Segunda capa convolucional
    layers.MaxPooling2D((2, 2)),                       # Capa de MaxPooling
    layers.Flatten(),                                  # Aplanar la imagen
    layers.Dense(128, activation='relu'),              # Capa oculta con activación ReLU
    layers.Dense(10, activation='softmax')              # Capa de salida con activación Softmax
])
 
# Compilar el modelo
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
 
# Entrenar el modelo
model.fit(train_images, train_labels, epochs=5)
 
# Evaluar el modelo en el conjunto de prueba
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'\nExactitud en el conjunto de prueba: {test_acc}')
 
#xactitud en el conjunto de prueba: 0.9082000255584717



Comentarios sobre la versión: V-0 (0)


No hay comentarios
 

Comentar la versión: V-0

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s7492