Actividad - 1 - JupyterLab

22/10/23, 23:31 Actividad_1_Redes_Neuronales_Artificiales_ANN
REDES NEURONALES
VERGARA TABOADA. - JOSÉ MIGUEL
En esta actividad vamos a utilizar una red neuronal para clasificar imágenes de prendas de
ropa. Para ello, utilizaremos Keras con TensorFlow.
El dataset a utilizar es Fashion MNIST, un problema sencillo con imágenes pequeñas de
ropa, pero más interesante que el dataset de MNIST. Puedes consultar más información
sobre el dataset en este enlace.
El código utilizado para contestar tiene que quedar claramente reflejado en el Notebook.
Puedes crear nuevas celdas si así lo deseas para estructurar tu código y sus salidas. A la
hora de entregar el notebook, asegúrate de que los resultados de ejecutar tu código han
quedado guardados. Por ejemplo, a la hora de entrenar una red neuronal tiene que verse
claramente un log de los resultados de cada epoch.
In [1]: import keras
from keras.datasets import fashion_mnist
from keras.models import Sequential
from keras.layers import Dense
import tensorflow as tf
import pandas as pd
import matplotlib.pyplot as plt
import time
En primer lugar vamos a importar el dataset Fashion MNIST (recordad que este es uno de
los dataset de entranamiento que estan guardados en keras) que es el que vamos a utilizar
en esta actividad:
In [2]: mnist = tf.keras.datasets.fashion_mnist
Llamar a load_data en este dataset nos dará dos conjuntos de dos listas, estos serán los
valores de entrenamiento y prueba para los gráficos que contienen las prendas de vestir y
sus etiquetas.
Nota: Aunque en esta actividad lo veis de esta forma, también lo vais a poder encontrar
como 4 variables de esta forma: training_images, training_labels, test_images, test_labels =
mnist.load_data()
In [3]: (training_images, training_labels), (test_images, test_labels) = mnist.load_dat
Antes de continuar vamos a dar un vistazo a nuestro dataset, para ello vamos a ver una
imagen de entrenamiento y su etiqueta o clase.
localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Actividad… 1/57
In [4]: import numpy as np

np.set_printoptions(linewidth=200)
import matplotlib.pyplot as plt
plt.imshow(training_images[0], cmap="gray") # recordad que siempre es preferibl
#
print(training_labels[0])
print(training_images[0])

9
[[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 13 73 0 0
1 4 0 0 0 0 1 1 0]
[ 0 0 0 0 0 0 0 0 0 0 0 0 3 0 36 136 127 62 54
0 0 0 1 3 4 0 0 3]
[ 0 0 0 0 0 0 0 0 0 0 0 0 6 0 102 204 176 134 144
123 23 0 0 0 0 12 10 0]
[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 155 236 207 178 107
156 161 109 64 23 77 130 72 15]
[ 0 0 0 0 0 0 0 0 0 0 0 1 0 69 207 223 218 216 216
163 127 121 122 146 141 88 172 66]
[ 0 0 0 0 0 0 0 0 0 1 1 1 0 200 232 232 233 229 223
223 215 213 164 127 123 196 229 0]
[ 0 0 0 0 0 0 0 0 0 0 0 0 0 183 225 216 223 228 235
227 224 222 224 221 223 245 173 0]
[ 0 0 0 0 0 0 0 0 0 0 0 0 0 193 228 218 213 198 180
212 210 211 213 223 220 243 202 0]
[ 0 0 0 0 0 0 0 0 0 1 3 0 12 219 220 212 218 192 169
227 208 218 224 212 226 197 209 52]
[ 0 0 0 0 0 0 0 0 0 0 6 0 99 244 222 220 218 203 198
221 215 213 222 220 245 119 167 56]
[ 0 0 0 0 0 0 0 0 0 4 0 0 55 236 228 230 228 240 232
213 218 223 234 217 217 209 92 0]
[ 0 0 1 4 6 7 2 0 0 0 0 0 237 226 217 223 222 219 222
221 216 223 229 215 218 255 77 0]
[ 0 3 0 0 0 0 0 0 0 62 145 204 228 207 213 221 218 208 211
218 224 223 219 215 224 244 159 0]
[ 0 0 0 0 18 44 82 107 189 228 220 222 217 226 200 205 211 230 224
234 176 188 250 248 233 238 215 0]
[ 0 57 187 208 224 221 224 208 204 214 208 209 200 159 245 193 206 223 255
255 221 234 221 211 220 232 246 0]
[ 3 202 228 224 221 211 211 214 205 205 205 220 240 80 150 255 229 221 188
154 191 210 204 209 222 228 225 0]
[ 98 233 198 210 222 229 229 234 249 220 194 215 217 241 65 73 106 117 168
219 221 215 217 223 223 224 229 29]
[ 75 204 212 204 193 205 211 225 216 185 197 206 198 213 240 195 227 245 239
223 218 212 209 222 220 221 230 67]
[ 48 203 183 194 213 197 185 190 194 192 202 214 219 221 220 236 225 216 199
206 186 181 177 172 181 205 206 115]
[ 0 122 219 193 179 171 183 196 204 210 213 207 211 210 200 196 194 191 195
191 198 192 176 156 167 177 210 92]
[ 0 0 74 189 212 191 175 172 175 181 185 188 189 188 193 198 204 209 210
210 211 188 188 194 192 216 170 0]
[ 2 0 0 0 66 200 222 237 239 242 246 243 244 221 220 193 191 179 182
182 181 176 166 168 99 58 0 0]
[ 0 0 0 0 0 0 0 40 61 44 72 41 35 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0]]

Habreis notado que todos los valores numericos están entre 0 y 255. Si estamos
entrenando una red neuronal, una buena practica es transformar todos los valores entre 0 y
1, un proceso llamado "normalización" y afortunadamente en Python es fácil normalizar una
lista. Lo puedes hacer de esta manera:
In [5]: training_images = training_images / 255.0
test_images = test_images / 255.0
1. Información sobre el dataset

Una vez tenemos los datos cargados en memoria, vamos a obtener información sobre los
mismos.
Pregunta 1.1 (0.25 puntos) ¿Cuántas imágenes hay de training y de test? ¿Qué tamaño
tienen las imágenes?
In [6]: ### Tu código aquí ###
q_train_images = training_images.shape[0]
q_test_images = test_images.shape[0]
image_height = training_images.shape[1]
image_width = training_images.shape[2]
print('Cantidad de imagenes en el conjunto de entrenamiento:' , q_train_images)

print('Cantidad de imagenes en el conjunto de prueba: ' , q_test_images)
print('Tamaño de las imagenes (w x h): ' , image_width,'x',image_height)
Cantidad de imagenes en el conjunto de entrenamiento: 60000

Cantidad de imagenes en el conjunto de prueba: 10000
Tamaño de las imagenes (w x h): 28 x 28
Tu respuesta aquí
Los sets de entrenamiento y test tienen 60000 y 10000 imágenes respectivamente. Todas
ellas de 28 x 28.
Pregunta 1.2 (0.25 puntos) Realizar una exploración de las variables que contienen los
datos. Describir en qué consiste un example del dataset (qué información se guarda en
cada imagen) y describir qué contiene la información en y.
In [7]: ### Tu código aquí ###
plt.figure(figsize=(10,2))
for i in range(10):
plt.subplot(1,10, i+1)
plt.imshow(training_images[i],cmap='gray')
plt.title(training_labels[i])
plt.axis('off')
plt.show()
labels = len(np.unique(training_labels))
print('Labels únicos: ',labels)
Labels únicos: 10
Tu respuesta aquí
De acuerdo con el ejercicio exploratorio, puede observarse que el dataset esta compuesto
de imágenes de prendas de vestir. Además de esto, en y cuenta con etiquetas que
clasifican dichas prendas en 10 diferentes categorías únicas.
2. Creación del Modelo

Ahora vamos a definir el modelo, pero antes vamos a repasar algunos comandos y
conceptos muy útiles:
Sequential: Eso define una SECUENCIA de capas en la red neuronal
Dense: Añade una capa de neuronas
Flatten: ¿Recuerdas cómo eran las imágenes cuando las imprimiste para poder verlas?
Un cuadrado, Flatten toma ese cuadrado y lo convierte en un vector de una dimensión.
Cada capa de neuronas necesita una función de activación. Normalmente se usa la función
relu en las capas intermedias y softmax en la ultima capa (en problemas de clasificación de
más de dos items)
Relu significa que "Si X>0 devuelve X, si no, devuelve 0", así que lo que hace es pasar
sólo valores 0 o mayores a la siguiente capa de la red.
Softmax toma un conjunto de valores, y escoge el más grande.
Pregunta 2.1 (2 puntos). Utilizando Keras, y preparando los datos de X e y como fuera
necesario, define y entrena una red neuronal que sea capaz de clasificar imágenes de
Fashion MNIST con las siguientes características:
Una hidden layer de tamaños 128, utilizando unidades sigmoid Optimizador Adam.
Durante el entrenamiento, la red tiene que mostrar resultados de loss y accuracy por
cada epoch.
La red debe entrenar durante 10 epochs y batch size de 64.
La última capa debe de ser una capa softmax.
Tu red tendría que ser capaz de superar fácilmente 80% de accuracy.
In [8]: ### Tu código para la red neuronal de la pregunta 2 aquí ###
# Definir el modelo de la red neuronal:

model1 = keras.models.Sequential()
# Agregar capas de entrada, ocultas y salida:
model1.add(keras.layers.Flatten(input_shape=[28,28]))
model1.add(keras.layers.Dense(128, activation = 'sigmoid'))
model1.add(Dense(10, activation='softmax'))
# Compilar el modelo:
model1.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metric
# Iniciar un temporizador
start_time1 = time.time()
# Entrenar el modelo
history1 = model1.fit(training_images, training_labels, epochs=10, batch_size=6
# Detener el temporizador
end_time1 = time.time()
# Calcular la duración del entrenamiento en segundos

training_duration1 = end_time1- start_time1
print('Duración del entrenamiento: {:.2f} segundos'.format(training_duration1))

# Graficar loss y accuracy:

pd.DataFrame(history1.history).plot(figsize=(8,5))
plt.grid(True)
plt.gca().set_ylim(0,1)
plt.show()
Epoch 1/10
938/938 [==============================] - 1s 724us/step - loss: 0.6007 - accu
racy: 0.7997 - val_loss: 0.4760 - val_accuracy: 0.8321
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10
Duración del entrenamiento: 6.25 segundos

Para concluir el entrenamiento de la red neuronal, una buena practica es evaluar el modelo
para ver si la precisión de entrenamiento es real
pregunta 2.2 (0.5 puntos): evalua el modelo con las imagenes y etiquetas test.
In [9]: ### Tu código para la evaluación de la red neuronal de la pregunta 2 aquí ###
#Evaluar el modelo con el conjunto de entrenamiento:

train_loss, train_accuracy = model1.evaluate(training_images, training_labels)
# Evaluar el modelo con el conjunto de prueba:

test_loss, test_accuracy = model1.evaluate(test_images, test_labels)
# Imprimir los resultados

print(f'Pérdida en el conjunto de entrenamiento: {train_loss}')
print(f'Pérdida en el conjunto de prueba: {test_loss}')
print()
print(f'Exactitud en el conjunto de entrenamiento: {test_accuracy}')
print(f'Exactitud en el conjunto de prueba: {train_accuracy}')
1875/1875 [==============================] - 1s 335us/step - loss: 0.2573 - ac

curacy: 0.9067
racy: 0.8791
Pérdida en el conjunto de entrenamiento: 0.25731879472732544
Pérdida en el conjunto de prueba: 0.3334852159023285
Exactitud en el conjunto de entrenamiento: 0.8791000247001648

Exactitud en el conjunto de prueba: 0.9067000150680542
De la prueba anterior, puede observarse que los resultados no presentan un desfase

abrupto entre los valores de test y entrenamiento. Podria considerarse que es correcto el
entrenamiento realizado
Ahora vamos a explorar el código con una serie de ejercicios para alcanzar un grado de
comprensión mayor sobre las redes neuronales y su entrenamiento.
3: Funcionamiento de las predicción de la red neuronal

Sigue los siguientes pasos:
Crea una variable llamada classifications para construir un clasificador con las
imágenes de prueba, para ello puedes utilizar la función predict sobre el conjunto de
test
Imprime con la función print la primera entrada en las clasificaciones.
pregunta 3.1 (0.25 puntos), el resultado al imprimirlo es un vector de números,
¿Por qué crees que ocurre esto, y qué representa este vector de números?
pregunta 3.2 (0.25 puntos)
¿Cúal es la clase de la primera entrada# de la variable classifications? La respuesta
puede ser un número o su etiqueta/clase equivalente.
In [10]: ### Tu código del clasificador de la pregunta 3 aquí ###
# Clasificadores para test:

classifications = model1.predict(test_images)
print(classifications[0])
# Clase predicha:
predicted_class = np.argmax(classifications[0])
print('Clase predicha para la primera entrada:', predicted_class)
313/313 [==============================] - 0s 295us/step

[5.0866270e-06 3.6373063e-07 7.5673879e-06 1.2197461e-05 1.0443733e-05 1.90040
77e-02 2.8072185e-05 2.2354728e-02 2.6640293e-04 9.5831102e-01]
Clase predicha para la primera entrada: 9
Tu respuesta a la pregunta 3.1 aquí:

El vector resultante tiene un tamaño de 10. Por lo que se intuye que se trata de las
probabilidades correspondientes a cada clase/neurona de salida de la red neuronal.
Si además de esto, se tiene en cuenta que la probabilidad mas alta está dada para el valor
correspondiente a la etiqueta 9 del vector, y de acuerdo con la respuesta de la pregunta 1.2,
vemos que la primera imagen corresponde con esta etiqueta, se podría decir que es la
probabilidad de que la primera imagen sea perteneciente a esa clase.

Esto se da porque la red neuronal produce una distribución de probabilidad sobre las
posibles clases.
La clase predicha es la clase: 9. Lo cual es correspondiente con la respuesta de la pregunta
1.2 y con el valor del vector con mayor probabilidad de ocurrencia.
4:lasImpacto variar
capas ocultas el número de neuronas en
En este ejercicio vamos a experimentar con nuestra red neuronal cambiando el numero de
neuronas por 512 y por 1024. Para ello, utiliza la red neuronal de la pregunta 1, y su capa
oculta cambia las 128 neuronas:
**512 neuronas en la capa oculta
**1024 neuronas en la capa oculta
y entrena la red en ambos casos.
In [11]: ### Tu código para 512 neuronas aquí ###


training_duration2 = end_time2- start_time2
localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Activida… 10/57
Epoch 1/10
938/938 [==============================] - 1s 1ms/step - loss: 0.5256 - accura
cy: 0.8168 - val_loss: 0.4551 - val_accuracy: 0.8344
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10
In [12]: #Evaluar el modelo con el conjunto de entrenamiento:

train_loss2, train_accuracy2 = model2.evaluate(training_images, training_labels

test_loss2, test_accuracy2 = model2.evaluate(test_images, test_labels)

print()
print(f'Pérdida en el conjunto de entrenamiento: {train_loss2}')
print(f'Pérdida en el conjunto de prueba: {test_loss2}')
print()
print(f'Exactitud en el conjunto de entrenamiento: {test_accuracy2}')
print(f'Exactitud en el conjunto de prueba: {train_accuracy2}')
1875/1875 [==============================] - 1s 439us/step - loss: 0.2256 - ac

curacy: 0.9170
racy: 0.8855



In [13]: ### Tu código para 1024 neuronas aquí ###


training_duration3 = end_time3 - start_time3

Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10



print()
print()
1875/1875 [==============================] - 1s 581us/step - loss: 0.2331 - ac

curacy: 0.9107
racy: 0.8798


In [15]: # Crear una matriz con una fila y tres columnas para almacenar los gráficos
fig, axs = plt.subplots(1, 3, figsize=(18, 5))

# Modelo 1
df1 = pd.DataFrame(history1.history)
df1.plot(ax=axs[0], title='Modelo 1', grid=True)
axs[0].set_ylim(0, 1)
# Modelo 2
# Modelo 3
plt.tight_layout()
plt.show()
# Comparar los resultados de cada modelo:

results = pd.DataFrame({
'Modelo': ['Modelo 1', 'Modelo 2', 'Modelo 3'],
'Loss': [history1.history['loss'][-1], history2.history['loss'][-1], histo
'Accuracy': [history1.history['accuracy'][-1], history2.history['accuracy']
'Val Loss': [history1.history['val_loss'][-1], history2.history['val_loss']
'Val Accuracy': [history1.history['val_accuracy'][-1], history2.history['va
'Training Duration (s)': [training_duration1, training_duration2, training_
})
print(results)
Modelo Loss Accuracy Val Loss Val Accuracy Training Duration (s)
0 Modelo 1 0.271734 0.900000 0.333485 0.8791 6.249813
1 Modelo 2 0.245740 0.908550 0.320959 0.8855 11.088078
2 Modelo 3 0.236681 0.911817 0.339533 0.8798 18.354863
pregunta 4.1 (0.5 puntos): ¿Cual es el impacto que tiene la red neuronal? Tu respuesta a la
pregunta 4.1 aquí:
Los resultados de Loss y Accuracy aumentan conforme aumenta el número de neuronas en
la red neuronal. Sin embargo, la mejora no es significativa respecto al aumento en el número
de cálculos de cada caso. Se observa también que el incremento en el número de neuronas
tiene incidencia directa sobre el tiempo de procesamiento.

Si ahora entrenais el modelo de esta forma (con 512 y 1024 neuronas en la capa oculta) y
volveis a ejecutar el predictor guardado en la variable classifications, escribir el código del
clasificador del ejercicio 1 de nuevo e imprimid el primer objeto guardado en la variable
classifications.
pregunta 4.2 (0.25 puntos):
¿En que clase esta clasificado ahora la primera prenda de vestir de la variable
classifications?
pregunta 4.3 (0.25 puntos):
¿Porque crees que ha ocurrido esto?
# Obtener clasificaciones para las imágenes de prueba con 512 neuronas:

classifications2 = model2.predict(test_images)
print(classifications2[0])
# Encontrar la clase predicha para la primera entrada en classifications

predicted_class2 = np.argmax(classifications2[0])
# Imprimir la clase predicha

print('Clase predicha para la primera entrada:', predicted_class2)
313/313 [==============================] - 0s 471us/step

[4.0347669e-07 1.6298086e-08 4.2846000e-07 1.2936478e-07 5.1943762e-06 1.70247
22e-02 2.6122300e-06 1.7504783e-02 1.2287662e-05 9.6544933e-01]
# Obtener clasificaciones para las imágenes de prueba con 1024 neuronas:

classifications3 = model3.predict(test_images)
print(classifications3[0])
# Encontrar la clase predicha para la primera entrada en classifications

predicted_class3 = np.argmax(classifications3[0])
# Imprimir la clase predicha

print('Clase predicha para la primera entrada:', predicted_class3)
313/313 [==============================] - 0s 568us/step

[1.5435043e-06 9.4903136e-08 1.9909651e-06 2.1788942e-07 5.0820813e-06 2.56580
54e-02 6.9725311e-06 4.2612754e-02 4.4572353e-06 9.3170887e-01]

Continua clasificado en la etiqueta 9.

Porque el incremento en el número de neuronas ha mejorado los resultados de accuracy y
loss respecto al modelo inicial.Por lo tanto, no deberían haber variaciones en la acumulación
de probabilidad de la etiqueta en el vecto. Al aumentar el número de neuronas, también es
posible que estemos ante un escenario de overfitting.
5: Capa Flatten
En este ejercicio vamos a ver que ocurre cuando quitamos la capa flatten, para ello, escribe
la red neuronal de la pregunta 1 y no pongas la capa Flatten.
pregunta 5 (0.5 puntos): ¿puedes explicar porque da el error que da?
In [18]: ### Tu código de la red neuronal sin capa flatten de la pregunta 6 aquí ###
#model1.add(keras.layers.Flatten(input_shape=[28,28]))
# Entrenar el modelo:
Epoch 1/10

---------------------------------------------------------------------------
InvalidArgumentError Traceback (most recent call last)
Cell In[18], line 17
13 model4.compile(loss='sparse_categorical_crossentropy', optimizer='ada
m', metrics=['accuracy'])
16 # Entrenar el modelo:
---> 17 history4 = model4.fit(training_images, training_labels, epochs=10, bat
ch_size=64, validation_data = (test_images, test_labels))
File ~/anaconda3/lib/python3.10/site-packages/keras/src/utils/traceback_utils.
py:70, in filter_traceback.<locals>.error_handler(*args, **kwargs)
67 filtered_tb = _process_traceback_frames(e.__traceback__)
68 # To get the full stack trace, call:
69 # `tf.debugging.disable_traceback_filtering()`
---> 70 raise e.with_traceback(filtered_tb) from None
71 finally:
72 del filtered_tb
File ~/anaconda3/lib/python3.10/site-packages/tensorflow/python/eager/execute.
py:60, in quick_execute(op_name, num_outputs, inputs, attrs, ctx, name)
53 # Convert any objects of type core_types.Tensor to Tensor.
54 inputs = [
55 tensor_conversion_registry.convert(t)
56 if isinstance(t, core_types.Tensor)
57 else t
58 for t in inputs
59 ]
---> 60 tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_nam
e,
61 inputs, attrs, num_outputs)
62 except core._NotOkStatusException as e:
63 if name is not None:
InvalidArgumentError: Graph execution error:
Detected at node sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWith

Logits/SparseSoftmaxCrossEntropyWithLogits defined at (most recent call last):
File "/Users/jmvt/anaconda3/lib/python3.10/runpy.py", line 196, in _run_modu
le_as_main
File "/Users/jmvt/anaconda3/lib/python3.10/runpy.py", line 86, in _run_code
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/ipykernel_launcher.
py", line 17, in <module>
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/traitlets/config/ap
plication.py", line 992, in launch_instance
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/ipykernel/kernelap
p.py", line 711, in start
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/tornado/platform/as
yncio.py", line 199, in start
File "/Users/jmvt/anaconda3/lib/python3.10/asyncio/base_events.py", line 60

3, in run_forever

6, in _run_once

File "/Users/jmvt/anaconda3/lib/python3.10/asyncio/events.py", line 80, in _
run
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/ipykernel/kernelbas
e.py", line 510, in dispatch_queue
e.py", line 499, in process_one
e.py", line 406, in dispatch_shell
e.py", line 729, in execute_request
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/ipykernel/ipkernel.
py", line 411, in do_execute
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/ipykernel/zmqshell.
py", line 531, in run_cell
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/IPython/core/intera
ctiveshell.py", line 2961, in run_cell
ctiveshell.py", line 3016, in _run_cell
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/IPython/core/async_
helpers.py", line 129, in _pseudo_sync_runner
ctiveshell.py", line 3221, in run_cell_async
ctiveshell.py", line 3400, in run_ast_nodes
ctiveshell.py", line 3460, in run_code
File "/var/folders/dh/xbnl7h7x6dn68sbq_kxqsvc80000gn/T/ipykernel_2778/232782
3463.py", line 17, in <module>
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/keras/src/utils/tra
ceback_utils.py", line 65, in error_handler
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/keras/src/engine/tr
aining.py", line 1783, in fit
aining.py", line 1377, in train_function
aining.py", line 1360, in step_function
aining.py", line 1349, in run_step
aining.py", line 1127, in train_step

aining.py", line 1185, in compute_loss
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/keras/src/engine/co
mpile_utils.py", line 277, in __call__
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/keras/src/losses.p
y", line 143, in __call__
y", line 270, in call
y", line 2454, in sparse_categorical_crossentropy
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/keras/src/backend.p
logits and labels must have the same first dimension, got logits shape [1792,1
0] and labels shape [64]
[[{{node sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWit
hLogits/SparseSoftmaxCrossEntropyWithLogits}}]] [Op:__inference_train_function
_169774]
Tu respuesta a la pregunta 6 aquí:

Al retirar la capa Flatten de la red neuronal, se está removimiento a la parte encargada de
transformar los tensores de las imágenes en vectores. Al darse este caso, se generan
discrepancias entre los valores de entrada y los valores que admiten las capas ocultas para
operar dentro de la red. Es en este sentido, que se puede afirmar, que si no se "aplanan" los
datos que ingresan a la red, estos no podrán ser procesados por las capas siguientes.
6: Número de neuronas de la capa de salida

Considerad la capa final, la de salida de la red neuronal de la pregunta 1.
pregunta 6.1 (0.25 puntos): ¿Por qué son 10 las neuronas de la última capa?
pregunta 6.2 (0.25 puntos): ¿Qué pasaría si tuvieras una cantidad diferente a 10?
Por ejemplo, intenta entrenar la red con 5, para ello utiliza la red neuronal de la pregunta 1 y
cambia a 5 el número de neuronas en la última capa.
In [22]: ### Tu código de la red neuronal con 5 neuronas en la capa de salida de la preg
model_19 = keras.models.Sequential()
model_19.add(keras.layers.Flatten(input_shape=[28,28]))
model_19.add(keras.layers.Dense(128, activation = 'sigmoid'))
model_19.add(Dense(5, activation='softmax'))

# Compilar el modelo
model_19.compile(loss='sparse_categorical_crossentropy', optimizer='adam', met
history_19 = model_19.fit(training_images, training_labels, epochs=10, batch_si
Epoch 1/10
2023-10-22 23:06:12.393444: W tensorflow/core/framework/op_kernel.cc:1839] OP_
REQUIRES failed at sparse_xent_op.cc:103 : INVALID_ARGUMENT: Received a label
value of 9 which is outside the valid range of [0, 5). Label values: 2 2 4 7
7 8 5 3 4 8 8 1 4 2 3 1 1 0 6 3 7 5 6 9 0 8 9 0 8 7 9 5 5 7 9 0 7 4 8 8 1 1 9
3 3 0 5 2 2 6 7 0 3 5 4 3 8 9 5 1 6 3 8 0

---------------------------------------------------------------------------
InvalidArgumentError Traceback (most recent call last)
Cell In[22], line 17
13 model_19.compile(loss='sparse_categorical_crossentropy', optimizer='ad
am', metrics=['accuracy'])
16 # Entrenar el modelo
---> 17 history_19 = model_19.fit(training_images, training_labels, epochs=10,
batch_size=64, validation_data = (test_images, test_labels))
File ~/anaconda3/lib/python3.10/site-packages/keras/src/utils/traceback_utils.
py:70, in filter_traceback.<locals>.error_handler(*args, **kwargs)
67 filtered_tb = _process_traceback_frames(e.__traceback__)
68 # To get the full stack trace, call:
69 # `tf.debugging.disable_traceback_filtering()`
---> 70 raise e.with_traceback(filtered_tb) from None
71 finally:
72 del filtered_tb
File ~/anaconda3/lib/python3.10/site-packages/tensorflow/python/eager/execute.
py:60, in quick_execute(op_name, num_outputs, inputs, attrs, ctx, name)
53 # Convert any objects of type core_types.Tensor to Tensor.
54 inputs = [
55 tensor_conversion_registry.convert(t)
56 if isinstance(t, core_types.Tensor)
57 else t
58 for t in inputs
59 ]
---> 60 tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_nam
e,
61 inputs, attrs, num_outputs)
62 except core._NotOkStatusException as e:
63 if name is not None:
InvalidArgumentError: Graph execution error:
Detected at node sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWith

Logits/SparseSoftmaxCrossEntropyWithLogits defined at (most recent call last):
File "/Users/jmvt/anaconda3/lib/python3.10/runpy.py", line 196, in _run_modu
le_as_main
File "/Users/jmvt/anaconda3/lib/python3.10/runpy.py", line 86, in _run_code
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/ipykernel_launcher.
py", line 17, in <module>
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/traitlets/config/ap
plication.py", line 992, in launch_instance
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/ipykernel/kernelap
p.py", line 711, in start
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/tornado/platform/as
yncio.py", line 199, in start

3, in run_forever

6, in _run_once

File "/Users/jmvt/anaconda3/lib/python3.10/asyncio/events.py", line 80, in _
run
e.py", line 510, in dispatch_queue
e.py", line 499, in process_one
e.py", line 406, in dispatch_shell
e.py", line 729, in execute_request
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/ipykernel/ipkernel.
py", line 411, in do_execute
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/ipykernel/zmqshell.
py", line 531, in run_cell
ctiveshell.py", line 2961, in run_cell
ctiveshell.py", line 3016, in _run_cell
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/IPython/core/async_
helpers.py", line 129, in _pseudo_sync_runner
ctiveshell.py", line 3221, in run_cell_async
ctiveshell.py", line 3400, in run_ast_nodes
ctiveshell.py", line 3460, in run_code
File "/var/folders/dh/xbnl7h7x6dn68sbq_kxqsvc80000gn/T/ipykernel_2778/186461
4145.py", line 17, in <module>
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/keras/src/utils/tra
ceback_utils.py", line 65, in error_handler
aining.py", line 1783, in fit
aining.py", line 1377, in train_function
aining.py", line 1360, in step_function
aining.py", line 1349, in run_step
aining.py", line 1127, in train_step

aining.py", line 1185, in compute_loss
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/keras/src/engine/co
mpile_utils.py", line 277, in __call__
y", line 143, in __call__
y", line 270, in call
File "/Users/jmvt/anaconda3/lib/python3.10/site-packages/keras/src/backend.p
Received a label value of 9 which is outside the valid range of [0, 5). Label
values: 2 2 4 7 7 8 5 3 4 8 8 1 4 2 3 1 1 0 6 3 7 5 6 9 0 8 9 0 8 7 9 5 5 7 9
0 7 4 8 8 1 1 9 3 3 0 5 2 2 6 7 0 3 5 4 3 8 9 5 1 6 3 8 0
[[{{node sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWit
hLogits/SparseSoftmaxCrossEntropyWithLogits}}]] [Op:__inference_train_function
_237854]
Tu respuestas a la pregunta 6.1 aquí:

De manera conceptual, cuando se tratan problemas de clasificación en redes neuronales; el
número de neuronas de salida debe ser correspondiente con el número de clases/etiquetas
unicas dentro del dataset. En este sentido y de acuerdo con la respuesta obtenida en la
pregunta 1.2, si existen 10 etiquetas únicas en el dataset, debe existir la misma cantidad de
neuronas en la capa de salida.
Tu respuestas a la pregunta 6.2 aquí:
Se obtendría un error como el visto anteriormente. Cuando se obtiene el error, el mensaje
específico del caso es este: . Received a label value of 9 which is outside the valid range of
[0, 5). Lo cual indica que basicamente no hay correspondencia entre las etiquetas del
dataset y la cantidad de neuronas dispuestas para alojar la probabilidad de salida de cada
una de ellas.
7:neuronal
Aumento de epoch y su efecto en la red
En este ejercicio vamos a ver el impacto de aumentar los epoch en el entrenamiento.
Usando la red neuronal de la pregunta 1:
Intentad 15 epoch para su entrenamiento, probablemente obtendras un modelo con una
pérdida mucho mejor que el que tiene 5.

Intenta ahora con 30 epoch para su entrenamiento, podrás ver que el valor de la
pérdida deja de disminuir, y a veces aumenta.
¿Porque que piensas que ocurre esto? Explica tu respuesta y da el nombre de este
efecto si lo conoces.
In [23]: ### Tu código para 15 epoch aquí ###


Epoch 1/15
Epoch 2/15
Epoch 3/15
Epoch 4/15
Epoch 5/15
Epoch 6/15
Epoch 7/15
Epoch 8/15
Epoch 9/15
Epoch 10/15
Epoch 11/15
Epoch 12/15
Epoch 13/15
Epoch 14/15
Epoch 15/15



print()
print()

1875/1875 [==============================] - 1s 322us/step - loss: 0.2253 - ac

curacy: 0.9176
racy: 0.8837


In [25]: ### Tu código para 30 epoch aquí ###


Epoch 1/30
Epoch 2/30
Epoch 3/30
Epoch 4/30
Epoch 5/30
Epoch 6/30
Epoch 7/30
Epoch 8/30
Epoch 9/30
Epoch 10/30
Epoch 11/30
Epoch 12/30
Epoch 13/30
Epoch 14/30
Epoch 15/30
Epoch 16/30
Epoch 17/30
Epoch 18/30
Epoch 19/30
Epoch 20/30

Epoch 21/30
Epoch 22/30
Epoch 23/30
Epoch 24/30
Epoch 25/30
Epoch 26/30
Epoch 27/30
Epoch 28/30
Epoch 29/30
Epoch 30/30



print()
print()
1875/1875 [==============================] - 1s 311us/step - loss: 0.1571 - ac

curacy: 0.9445
racy: 0.8854


In [27]: # Crear una matriz con una fila y tres columnas para almacenar los gráficos

# Modelo 1
# Modelo 5
# Modelo 6
plt.tight_layout()
plt.show()
# Comparar los resultados de cada modelo:

'Modelo': ['Modelo 1', 'Modelo 5', 'Modelo 6'],
})
print(results)
0 Modelo 1 0.271734 0.900000 0.333485 0.8791 6.249813
1 Modelo 5 0.235046 0.913783 0.326567 0.8837 9.601142
2 Modelo 6 0.165969 0.940583 0.330657 0.8854 17.750523

El efecto del comportamiento del rendimiento de los modelos, conforme aumenta el numero
de epochs, está dado por el overfitting del modelo. Toda vez que el numero de iteraciones
aumenta, el modelo pierde la capacidad de generalizar casos y se concentra en aprender
los valores que se le suministra a través del set de entrenamiento.
8: Early stop
En el ejercicio anterior, cuando entrenabas con epoch extras, tenías un problema en el que
tu pérdida podía cambiar. Puede que te haya llevado un poco de tiempo esperar a que el
entrenamiento lo hiciera, y puede que hayas pensado "¿no estaría bien si pudiera parar el
entrenamiento cuando alcance un valor deseado?", es decir, una precisión del 85% podría
ser suficiente para ti, y si alcanzas eso después de 3 epoch, ¿por qué sentarte a esperar a
que termine muchas más épocas? Como cualquier otro programa existen formas de parar la
ejecución
A partir del código de ejemplo, hacer una nueva función que tenga en cuenta la perdida
(loss) y que pueda parar el código para evitar que ocurra el efeto secundario que vimos en
el ejercicio 5.
In [28]: ### Ejemplo de código
class myCallback(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if(logs.get('accuracy')> 0.85):
print("\nAlcanzado el 85% de precisión, se cancela el entrenamien
self.model.stop_training = True
Ejercicio 8 (0.75 puntos): Completa el siguiente código con una clase callback que una
vez alcanzado el 40% de perdida detenga el entrenamiento.
In [29]: import tensorflow as tf
print(tf.__version__)
class MyLossCallback(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if logs.get('loss') <= 0.4:
print("\nPérdida menor o igual al 40%, se cancela el entrenamiento
self.model.stop_training = True
callbacks = MyLossCallback()
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_dat
training_images = training_images / 255.0

test_images = test_images / 255.0
model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
tf.keras.layers.Dense(512, activation=tf.nn
tf.keras.layers.Dense(10, activation=tf.nn
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=50, callbacks=[callbacks])

2.14.0
Epoch 1/50
1875/1875 [==============================] - 2s 787us/step - loss: 0.4755 - ac
curacy: 0.8313
Epoch 2/50
1819/1875 [============================>.] - ETA: 0s - loss: 0.3619 - accurac
y: 0.8677
Pérdida menor o igual al 40%, se cancela el entrenamiento!!
1875/1875 [==============================] - 2s 804us/step - loss: 0.3609 - ac
curacy: 0.8680
<keras.src.callbacks.History at 0x14fb52e90>
Out[29]:
9. Unidades de activación
En este ejercicio, vamos a evaluar la importancia de utilizar las unidades de activación
adecuadas. Como hemos visto en clase, funciones de activación como sigmoid han dejado
de utilizarse en favor de otras unidades como ReLU.
Ejercicio 9 (0.75 puntos): Partiendo de una red sencilla como la desarrollada en el Trabajo
1, escribir un breve análisis comparando la utilización de unidades sigmoid y ReLU (por
ejemplo, se pueden comentar aspectos como velocidad de convergencia, métricas
obtenidas...). Explicar por qué pueden darse estas diferencias. Opcionalmente, comparar
con otras activaciones disponibles en Keras.
Pista: Usando redes más grandes se hace más sencillo apreciar las diferencias. Es mejor
utilizar al menos 3 o 4 capas densas.
In [30]: ## Tu código y comentarios de texto aquí
## Puedes incluir tantas celdas como quieras
## No olvides utilizar celdas de Markdown para texto
from tensorflow import keras

model7.add(keras.layers.Dense(128, activation='relu')) # Cambio de 'sigmoid' a
model7.add(keras.layers.Dense(10, activation='softmax'))


Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10



print()
print()

1875/1875 [==============================] - 1s 308us/step - loss: 0.2443 - ac
curacy: 0.9086
racy: 0.8813


In [32]: model8 = keras.models.Sequential()

model8.add(keras.layers.Dense(128, activation='relu'))
# Agregar dos capas densas adicionales



Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10



print()
print()
1875/1875 [==============================] - 1s 359us/step - loss: 0.2108 - ac

curacy: 0.9201
racy: 0.8868


In [34]: model9 = keras.models.Sequential()

# Agregar cuatro capas densas adicionales



Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10



print()
print()
1875/1875 [==============================] - 1s 386us/step - loss: 0.2250 - ac

curacy: 0.9128
racy: 0.8778


In [36]: # Crear una figura con una fila y tres columnas


# Modelo 1
df1.plot(ax=axs[0], title= 'Modelo 1: Sigmoid, 1 Capa', grid=True)
# Modelo 7
df7.plot(ax=axs[1], title= 'Modelo 7: ReLU, 1 Capa', grid=True)
# Modelo 8
df8.plot(ax=axs[2], title= 'Modelo 8: ReLU, 3 Capas', grid=True)
# Modelo 9
df9.plot(ax=axs[3], title='Modelo 9: ReLU, 5 Capas', grid=True)
plt.tight_layout()
plt.show()
# Crear un DataFrame con los resultados de pérdida y precisión de cada modelo

'Modelo': ['Modelo 1', 'Modelo 7', 'Modelo 8', 'Modelo 9'],
})
print(results)
0 Modelo 1 0.271734 0.900000 0.333485 0.8791 6.249813
1 Modelo 7 0.248859 0.907900 0.342542 0.8813 5.982485
2 Modelo 8 0.232111 0.911650 0.331654 0.8868 8.669376
3 Modelo 9 0.243188 0.907767 0.339001 0.8778 11.254771
Se obtienen mejores resultados con la implementación de 3 capas. Existe la posibilidad de

que con la utilización de un número mayor de estas se comience a presentar overfitting en
el modelo, comprometiendo los resultados obtenidos con este.
10. Inicialización de parámetros

En este ejercicio, vamos a evaluar la importancia de una correcta inicialización de
parámetros en una red neuronal.
Ejercicio 10 (0.75 puntos): Partiendo de una red similar a la del ejercicio anterior (usando
ya ReLUs), comentar las diferencias que se aprecian en el entrenamiento al utilizar distintas
estrategias de inicialización de parámetros. Para ello, inicializar todas las capas con las
siguientes estrategias, disponibles en Keras, y analizar sus diferencias:
Inicialización con ceros.
Inicialización con una variable aleatoria normal.
Inicialización con los valores por defecto de Keras para una capa Dense (estrategia
glorot uniform)
# Crear el modelo y compilarlo con inicialización en ceros

model10 = tf.keras.models.Sequential()

model10.add(tf.keras.layers.Flatten(input_shape=[28, 28]))
# Capa oculta con inicialización en ceros

model10.add(tf.keras.layers.Dense(128, activation='relu', kernel_initializer='z
# Capa de salida
model10.add(tf.keras.layers.Dense(10, activation='softmax', kernel_initializer=
model10.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metri
history10 = model10.fit(training_images, training_labels, epochs=10, batch_size


print('Duración del entrenamiento: {:.2f} segundos'.format(training_duration10)
Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10

train_loss10, train_accuracy10 = model10.evaluate(training_images, training_lab


print()
print()
1875/1875 [==============================] - 1s 322us/step - loss: 2.3026 - ac

curacy: 0.1000
racy: 0.1000



Se puede observar que bajo esta inicialización en ceros, la red prácticamente no aprende.
Los resultados de accuracy son muy bajos respecto a otras inicializaciones, así como los
resultados de loss son demasiado altos.
In [39]: # Crear el modelo y compilarlo con inicialización aleatoria normal

# Capa oculta con inicialización aleatoria normal

model11.add(tf.keras.layers.Dense(128, activation='relu', kernel_initializer='
# Capa de salida con inicialización aleatoria normal

model11.add(tf.keras.layers.Dense(10, activation='softmax', kernel_initializer=


Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10



print()
print()
1875/1875 [==============================] - 1s 316us/step - loss: 0.2339 - ac

curacy: 0.9139
racy: 0.8844


In [41]: # Crear el modelo y compilarlo con la inicialización por defecto de Keras


# Capa oculta con inicialización por defecto

model12.add(tf.keras.layers.Dense(128, activation='relu'))
# Capa de salida con inicialización por defecto

model12.add(tf.keras.layers.Dense(10, activation='softmax'))


Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10



print()
print()
1875/1875 [==============================] - 1s 315us/step - loss: 0.2421 - ac

curacy: 0.9090
racy: 0.8781


In [43]: # Crear un DataFrame con los resultados de pérdida y precisión de cada modelo

'Accuracy': [history1.history['accuracy'][-1], history10.history['accuracy
'Training Duration (s)': [training_duration1, training_duration10, training
})
print(results)
Modelo Loss Accuracy Training Duration (s)

0 Modelo 1 0.271734 0.900000 6.249813
1 Modelo 10 2.302737 0.096600 5.966293
2 Modelo 11 0.249916 0.907583 5.789916
3 Modelo 12 0.249700 0.906683 5.780377
De acuerdo con las implementaciones anteriores, puede observarse que el mejor

rendimiento se obtiene por medio de la incialización con valores por defecto en keras, sin
embargo, la direfencia es poca respecto a la inicialización con valores aleatorios. Se resalta
también que con la inicialización de los valores en cero, el modelo practicamente no
aprende, toda vez que el accuracy no supera al 10% y la perdida tiene valores superiores al
resto de las implementaciones por 10x.
11. Optimizadores
Ejercicio 11 (0.75 puntos): Partiendo de una red similar a la del ejercicio anterior (utilizando
la mejor estrategia de inicialización observada), comparar y analizar las diferencias que se
observan al entrenar con varios de los optimizadores vistos en clase, incluyendo SGD como
optimizador básico (se puede explorar el espacio de hiperparámetros de cada optimizador,
aunque para optimizadores más avanzados del estilo de adam y RMSprop es buena idea
dejar los valores por defecto provistos por Keras).
# Crear el modelo y compilarlo con la inicialización por defecto de Keras


# Capa oculta con inicialización por defecto (Glorot uniform)

# Capa de salida con inicialización por defecto (Glorot uniform)

model13.compile(loss='sparse_categorical_crossentropy', optimizer = tf.keras.op


Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10



print()

print()
1875/1875 [==============================] - 1s 315us/step - loss: 0.4220 - ac

curacy: 0.8539
racy: 0.8387








Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10



print()
print()
1875/1875 [==============================] - 1s 305us/step - loss: 0.2404 - ac

curacy: 0.9110
racy: 0.8796









Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10



print()
print()
1875/1875 [==============================] - 1s 304us/step - loss: 0.2735 - ac

curacy: 0.8975
racy: 0.8682



'Loss': [history12.history['loss'][-1], history13.history['loss'][-1], hist
'Accuracy': [history12.history['accuracy'][-1], history13.history['accuracy
'Val Loss': [history12.history['val_loss'][-1], history13.history['val_loss
'Val Accuracy': [history12.history['val_accuracy'][-1], history13.history[
'Training Duration (s)': [training_duration12, training_duration13, trainin
})
print(results)
Modelo Loss Accuracy Val Loss Val Accuracy \

0 Modelo 12 0.249700 0.906683 0.341834 0.8781
1 Modelo 13 0.416376 0.856183 0.460938 0.8387
2 Modelo 14 0.246506 0.909333 0.339676 0.8796
3 Modelo 15 0.255326 0.907633 0.403503 0.8682
Training Duration (s)

0 5.780377
1 5.242360
2 5.855921
3 6.713767
Partimos del mejor resultado del caso anterior, el cual utiliza la función de activación ReLU.
Sobre este modelo, se varía los optimizadores entre SGD, Adam y RMSprop. De los
anteriores, los tiempos de ejecución no son particularmente diferentes entre si, los
resultados tampoco tienen variaciones importantes, salvo el caso de la aplicación SGD, el
cual obtiene los peores resultados tanto en accuracy como en Loss
A continuación, se resumirá el resultato de todos los procesos de modelado. De tal forma
que pueda apreciarse una comparativa entre todos.
RESUMEN DE RESULTADOS*
'Modelo': ['Modelo 1: Base', 'Modelo 2: 512 Neuronas', 'Modelo 3: 1024 Neur
'Modelo 6: 30 Epochs','Modelo 7: Activación ReLU','Modelo 8: ReL
'Modelo 11: Inicialización - Aleatoria', 'Modelo 12: Inicializac
'Loss': [history1.history['loss'][-1],history2.history['loss'][-1],history3
history5.history['loss'][-1],history6.history['loss'][-1],
history7.history['loss'][-1],history8.history['loss'][-1],history9
history10.history['loss'][-1],history11.history['loss'][-1],histo
history13.history['loss'][-1], history14.history['loss'][-1], hist
'Accuracy': [history1.history['accuracy'][-1],history2.history['accuracy']
history5.history['accuracy'][-1],history6.history['accuracy']
history7.history['accuracy'][-1],history8.history['accuracy']
history10.history['accuracy'][-1],history11.history['accuracy
history13.history['accuracy'][-1], history14.history['accuracy
history5.history['val_loss'][-1], history6.history['val_loss']
history7.history['val_loss'][-1], history8.history['val_loss']
history10.history['val_loss'][-1], history11.history['val_loss
history13.history['val_loss'][-1], history14.history['val_loss
history5.history['val_accuracy'][-1], history6.history['val
history7.history['val_accuracy'][-1], history8.history['val
history10.history['val_accuracy'][-1], history11.history['v
history13.history['val_accuracy'][-1], history14.history['v
'Training Duration (s)': [training_duration1,training_duration2,training_du
training_duration5,training_duration6,
training_duration7,training_duration8,training_du
training_duration10,training_duration11,training_
training_duration13, training_duration14, trainin
})
print(results.to_string(justify='right'))
Modelo Loss Accuracy Val Loss Val A

ccuracy Training Duration (s)
0 Modelo 1: Base 0.271734 0.900000 0.333485
0.8791 6.249813
1 Modelo 2: 512 Neuronas 0.245740 0.908550 0.320959
0.8855 11.088078
2 Modelo 3: 1024 Neuronas 0.236681 0.911817 0.339533
0.8798 18.354863
3 Modelo 5: 15 Epochs 0.235046 0.913783 0.326567
0.8837 9.601142
4 Modelo 6: 30 Epochs 0.165969 0.940583 0.330657
0.8854 17.750523
5 Modelo 7: Activación ReLU 0.248859 0.907900 0.342542
0.8813 5.982485
6 Modelo 8: ReLU, 3 Capas ocultas 0.232111 0.911650 0.331654
0.8868 8.669376
7 Modelo 9: ReLU, 5 Capas ocultas 0.243188 0.907767 0.339001
0.8778 11.254771
8 Modelo 10: Inicialización - Ceros 2.302737 0.096600 2.302596
0.1000 5.966293
9 Modelo 11: Inicialización - Aleatoria 0.249916 0.907583 0.333132
0.8844 5.789916
10 Modelo 12: Inicialización - Keras 0.249700 0.906683 0.341834
0.8781 5.780377
11 Modelo 13: Optimizador - SGD 0.416376 0.856183 0.460938
0.8387 5.242360
12 Modelo 14: Optimizador - Adam 0.246506 0.909333 0.339676
0.8796 5.855921
13 Modelo 15: Optimizador - RMSprop 0.255326 0.907633 0.403503
0.8682 6.713767
De acuerdo con la tabla anterior, puede verse que casi todas las variaciones hechas al
modelo 1 (inicial) tienen incidencia positiva sobre la precisión del mismo. Algunos a
expensas de la multiplicación por 2x o 3x, lo cual connota un aumento en el costo
computacional para la solución.
Los mejores resultados se observan en el aumento a 30 epochs, manejo de 512 neuronas y
con la implementación de 3 capas ocultas.
12. Regularización y red final (1.25 puntos)

Ejercicio 12 (1 punto): Entrenar una red final que sea capaz de obtener una accuracy en el
validation set cercana al 90%. Para ello, combinar todo lo aprendido anteriormente y utilizar

técnicas de regularización para evitar overfitting. Algunos de los elementos que pueden
tenerse en cuenta son los siguientes.
Número de capas y neuronas por capa
Optimizadores y sus parámetros
Batch size
Unidades de activación
Uso de capas dropout, regularización L2, regularización L1...
Early stopping (se puede aplicar como un callback de Keras, o se puede ver un poco "a
ojo" cuándo el modelo empieza a caer en overfitting y seleccionar el número de epochs
necesarias)
Batch normalization
Si los modelos entrenados anteriormente ya se acercaban al valor requerido de accuracy,
probar distintas estrategias igualmente y comentar los resultados.
Explicar brevemente la estrategia seguida y los modelos probados para obtener el modelo
final, que debe verse entrenado en este Notebook. No es necesario guardar el
entrenamiento de todos los modelos que se han probado, es suficiente con explicar cómo
se ha llegado al modelo final.
In [52]: ## Tu modelo y comentarios de texto aquí

# Agregar dos capas densas adicionales

model20.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.opti



Epoch 1/50
Epoch 2/50
Epoch 3/50
Epoch 4/50
Epoch 5/50
Epoch 6/50
Epoch 7/50
Epoch 8/50
Epoch 9/50
Epoch 10/50
Epoch 11/50
Epoch 12/50
Epoch 13/50
Epoch 14/50
Epoch 15/50
Epoch 16/50
Epoch 17/50
Epoch 18/50
Epoch 19/50
Epoch 20/50
Epoch 21/50
Epoch 22/50
Epoch 23/50
Epoch 24/50
Epoch 25/50
Epoch 26/50
Epoch 27/50
Epoch 28/50
Epoch 29/50
Epoch 30/50
Epoch 31/50
Epoch 32/50
Epoch 33/50
Epoch 34/50
Epoch 35/50
Epoch 36/50
Epoch 37/50
Epoch 38/50
Epoch 39/50
Epoch 40/50
Epoch 41/50
Epoch 42/50
Epoch 43/50
Epoch 44/50
Epoch 45/50
Epoch 46/50
Epoch 47/50
Epoch 48/50
Epoch 49/50
Epoch 50/50



print()
print()
1875/1875 [==============================] - 1s 648us/step - loss: 0.2269 - ac

curacy: 0.9346
racy: 0.8803


Para obtener el resultado anterior, se combino una colección de las variables modificadas
que mejores incidencias tuvieron sobre los modelos anteriores; buscando balancear la
relación costo/beneficio. Se contempló trabajar ReLU como unidad de activación, con 512
neuronas y 3 capas ocultas, además de esto, se implementaron 50 epochs, en materia de
optimizador se empleó RMSprop y para la inicialización de los datos se utilizaron los valores
por defecto de Keras.
Después de todo lo anterior, los resultados no distan demasiado a los obtenidos en los
modelos anteriores. No se alcanza el 90% de precisión, con la configuración actual y a
partir del epoch 21 los datos comienzan a aumentar y disminuir, sin poder alcanzar nunca
un 90% de precisión. Podría decirse que a partir de este punto puede inferirse algún nivel
de sobreajuste en la red.
In [ ]:

Actividad - 1 - JupyterLab

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Actividad - 1 - JupyterLab

Cargado por

Copyright:

Formatos disponibles

22/10/23, 23:31 Actividad_1_Redes_Neuronales_Artificiales_ANN

import matplotlib.pyplot as plt

In [4]: import numpy as np

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Actividad… 2/57

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Actividad… 3/57

1. Información sobre el dataset

print('Cantidad de imagenes en el conjunto de entrenamiento:' , q_train_images)

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Actividad… 4/57

Cantidad de imagenes en el conjunto de entrenamiento: 60000

2. Creación del Modelo

# Definir el modelo de la red neuronal:

# Agregar capas de entrada, ocultas y salida:

model1.add(keras.layers.Dense(128, activation = 'sigmoid'))

# Calcular la duración del entrenamiento en segundos

print('Duración del entrenamiento: {:.2f} segundos'.format(training_duration1))

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Actividad… 6/57

# Graficar loss y accuracy:

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Actividad… 7/57

#Evaluar el modelo con el conjunto de entrenamiento:

# Evaluar el modelo con el conjunto de prueba:

# Imprimir los resultados

1875/1875 [==============================] - 1s 335us/step - loss: 0.2573 - ac

Exactitud en el conjunto de entrenamiento: 0.8791000247001648

De la prueba anterior, puede observarse que los resultados no presentan un desfase

3: Funcionamiento de las predicción de la red neuronal

# Clasificadores para test:

print('Clase predicha para la primera entrada:', predicted_class)

313/313 [==============================] - 0s 295us/step

Tu respuesta a la pregunta 3.1 aquí:

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Actividad… 9/57

# Definir el modelo de la red neuronal:

# Agregar capas de entrada, ocultas y salida:

model2.add(keras.layers.Dense(512, activation = 'sigmoid'))

# Calcular la duración del entrenamiento en segundos

print('Duración del entrenamiento: {:.2f} segundos'.format(training_duration2))

In [12]: #Evaluar el modelo con el conjunto de entrenamiento:

# Evaluar el modelo con el conjunto de prueba:

# Imprimir los resultados

1875/1875 [==============================] - 1s 439us/step - loss: 0.2256 - ac

Pérdida en el conjunto de entrenamiento: 0.2255670130252838

Exactitud en el conjunto de entrenamiento: 0.8855000138282776

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Activida… 11/57

In [13]: ### Tu código para 1024 neuronas aquí ###

# Definir el modelo de la red neuronal:

# Agregar capas de entrada, ocultas y salida:

model3.add(keras.layers.Dense(1024, activation = 'sigmoid'))

# Calcular la duración del entrenamiento en segundos

print('Duración del entrenamiento: {:.2f} segundos'.format(training_duration3))

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Activida… 12/57

In [14]: #Evaluar el modelo con el conjunto de entrenamiento:

# Evaluar el modelo con el conjunto de prueba:

# Imprimir los resultados

1875/1875 [==============================] - 1s 581us/step - loss: 0.2331 - ac

Pérdida en el conjunto de entrenamiento: 0.23314720392227173

Exactitud en el conjunto de entrenamiento: 0.879800021648407

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Activida… 13/57

# Comparar los resultados de cada modelo:

localhost:8888/lab/tree/OneDrive - UNIR/UNIR/MASTER/INTELIGENCIA ARTIFICIAL/SISTEMAS COGNITIVOS ARTIFICIALES/ACTIVIDAD 1/Activida… 14/57

# Obtener clasificaciones para las imágenes de prueba con 512 neuronas:

# Encontrar la clase predicha para la primera entrada en classifications

# Imprimir la clase predicha

313/313 [==============================] - 0s 471us/step

In [17]: ### Tu código del clasificador de la pregunta 5 aquí ###