# [Link]
com/gkoehler/digit-recognition-with-keras
# imports for array-handling and plotting
import numpy as np
import matplotlib
# [Link]('agg')
import [Link] as plt
# let's keep our keras backend tensorflow quiet
import os
[Link]['TF_CPP_MIN_LOG_LEVEL'] = '3'
# for testing on CPU
# [Link]['CUDA_VISIBLE_DEVICES'] = ''
# keras imports for the dataset and building our neural network
from [Link] import mnist
from [Link] import Sequential, load_model
from [Link] import Dense, Dropout, Activation
from [Link] import to_categorical
2. Instalación de rarEle para extraer todos los archivos necesarios para el desarrollo de la
práctica desde un archivo .rar.
!pip install rarfile
Collecting rarfile
Downloading [Link] (4.4 kB)
Downloading [Link] (29 kB)
Installing collected packages: rarfile
Successfully installed rarfile-4.2
3. Implementación de rarEle para extraer los archivos del rar [Link] en la carpeta data.
import rarfile
import os
# Path to the uploaded RAR file
rar_file_path = '/content/[Link]'
# Directory where you want to extract the files
extract_to_directory = '/content/data'
[Link](extract_to_directory, exist_ok=True)
# Extract the RAR file
with [Link](rar_file_path) as rf:
[Link](extract_to_directory)
# Verify extraction
print("Extracted files:")
print([Link](extract_to_directory))
Extracted files:
['pistaches']
4. Se cargan y normalizan imágenes desde un directorio para un modelo de clasiEcación
multi-clase.
from [Link] import ImageDataGenerator
lado = 128
# Directory where the images are stored after extraction
image_directory = '/content/data/pistaches'
# Create an ImageDataGenerator instance
datagen = ImageDataGenerator(rescale=1./255) # Normalize the images
# Load images from the directory
generator = datagen.flow_from_directory(
directory=image_directory,
target_size=(lado, lado), # Adjust this based on your model's input size
batch_size=32,
class_mode='categorical' # Use 'categorical' for multi-class classification
)
Found 2148 images belonging to 2 classes.
5. Instalación la versión ligera de OpenCV, sin interfaz gráEca, para procesamiento de
imágenes.
!pip install opencv-python-headless
Requirement already satisfied: opencv-python-headless in /usr/local/lib/python3.1
Requirement already satisfied: numpy>=1.21.2 in /usr/local/lib/python3.10/dist-pa
_. Carga, conversión a escala de grises, normalización y división de imágenes en conjuntos
de entrenamiento y prueba para clasiEcación multi-clase.
import numpy as np
import os
from [Link] import load_img, img_to_array
from sklearn.model_selection import train_test_split
def load_images_from_directory(directory, target_size=(lado, lado)):
images = []
labels = []
class_names = [Link](directory)
class_names.sort() # Ensure consistent ordering
class_indices = {name: idx for idx, name in enumerate(class_names)}
for class_name in class_names:
class_path = [Link](directory, class_name)
for img_name in [Link](class_path):
img_path = [Link](class_path, img_name)
img = load_img(img_path, target_size=target_size)
img_array = img_to_array(img)
[Link](img_array)
[Link](class_indices[class_name])
return [Link](images), [Link](labels), class_names
# Load images and labels
image_directory = '/content/data/pistaches'
X, y, class_names = load_images_from_directory(image_directory)
print("Cantidad de clases: ",class_names)
print("Tamaño de X: ",[Link]) # Verify the shape of the resulting array
#Convert the images to gray scale
import cv2
import numpy as np
X_gray = [Link]([[Link](img, cv2.COLOR_RGB2GRAY) for img in X])
# Ensure the grayscale images have shape (num_samples, 28, 28)
print(X_gray.shape) # Should be (num_samples, 28, 28)
# Normalize images
X = [Link]('float32') / 255.0
# Split the data into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X_gray, y, test_size=0.2, random_s
# Convert labels to categorical if needed
from [Link] import to_categorical
y_train = to_categorical(y_train, num_classes=len(class_names))
y_test = to_categorical(y_test, num_classes=len(class_names))
print("Tamaño de datos de entrenamiento X:", X_train[0].shape)
print("Tamaño de datos de entrenamiento Y:", y_train[0])
print("Tamaño de datos de prueba X:", X_test[0].shape)
print("Tamaño de datos de pryeba Y:", y_test[0])
Cantidad de clases: ['Kirmizi_Pistachio', 'Siirt_Pistachio']
Tamaño de X: (2148, 128, 128, 3)
(2148, 128, 128)
Tamaño de datos de entrenamiento X: (128, 128)
Tamaño de datos de entrenamiento Y: [0. 1.]
Tamaño de datos de prueba X: (128, 128)
Tamaño de datos de pryeba Y: [1. 0.]
7. Conversión de etiquetas categóricas a escalares y visualización de las primeras etiquetas
del conjunto de entrenamiento y prueba.
y_train_scalar = [Link](y_train, axis=1)
y_test_scalar = [Link](y_test, axis=1)
# Print the shape and first few labels
print("y_train_scalar shape:", y_train_scalar.shape)
print("First few scalar labels:", y_train_scalar[:5])
print("y_train_scalar shape:", y_test_scalar.shape)
print("First few scalar labels:", y_test_scalar[:5])
y_train_scalar shape: (1718,)
First few scalar labels: [1 0 0 0 1]
y_train_scalar shape: (430,)
First few scalar labels: [0 1 0 0 0]
a. Visualización de imágenes de entrenamiento con sus etiquetas correspondientes en una
cuadrícula de 3x3.
fig = [Link]()
[Link]("datos")
for i in range(9):
[Link](3, 3, i + 1)
plt.tight_layout()
[Link](X_train[i], cmap='gray', interpolation='none')
[Link]("Pistache type: {}".format(y_train_scalar[i]))
[Link]([])
[Link]([])
[Link]()
9. Visualización de una imagen de entrenamiento y su distribución de valores de píxeles en
escala de grises.
fig = [Link]()
[Link](2, 1, 1)
[Link](X_train[4], cmap='gray', interpolation='none')
[Link]("Pistache: {}".format(y_train_scalar[5]))
[Link]([])
[Link]([])
[Link](2, 1, 2)
[Link](X_train[0].reshape(lado*lado))
[Link]("Pixel Value Distribution")
[Link]()
10. Impresión de las dimensiones de los conjuntos de datos de entrenamiento y prueba antes
de remodelar y normalizar.
# let's print the shape before we reshape and normalize
print("X_train shape", X_train.shape)
print("y_train shape", y_train.shape)
print("X_test shape", X_test.shape)
print("y_test shape", y_test.shape)
X_train shape (1718, 128, 128)
y_train shape (1718, 2)
X_test shape (430, 128, 128)
y_test shape (430, 2)
11. Redimensionamiento y normalización de datos de entrenamiento y prueba para
prepararlos para el entrenamiento del modelo.
# building the input vector from the lado*lado pixels
X_train = X_train.reshape(X_train.shape[0], lado*lado)
X_test = X_test.reshape(X_test.shape[0], lado*lado)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# normalizing the data to help with the training
X_train /= 255
X_test /= 255
# print the final input shape ready for training
print("Train matrix shape", X_train.shape)
print("Test matrix shape", X_test.shape)
Train matrix shape (1718, 16384)
Test matrix shape (430, 16384)
12. Impresión de la distribución de etiquetas escalar en el conjunto de entrenamiento.
print([Link](y_train_scalar, return_counts=True))
(array([0, 1]), array([988, 730]))
13. CodiEcación one-hot de etiquetas escalar para conjuntos de entrenamiento y prueba, con
impresión de formas antes y después.
# one-hot encoding using keras' numpy-related utilities
n_classes = ([Link](y_train_scalar).shape)[0]
print("Total number of outputs : ", n_classes)
print("Shape before one-hot encoding: ", y_train_scalar.shape)
Y_train = to_categorical(y_train_scalar, n_classes)
Y_test = to_categorical(y_test_scalar, n_classes)
print("Shape after one-hot encoding: ", Y_train.shape)
Total number of outputs : 2
Shape before one-hot encoding: (1718,)
Shape after one-hot encoding: (1718, 2)
14. Construcción de un modelo secuencial con capas densas, activaciones ReLU, y dropout
para clasiEcación.
# building a linear stack of layers with the sequential model
model = Sequential()
[Link](Dense(1024, input_shape=(lado*lado,)))
[Link](Activation('relu'))
[Link](Dropout(0.2))
[Link](Dense(1024)))
[Link](Activation('relu'))
[Link](Dropout(0.2))
[Link](Dense(n_classes))
[Link](Activation('softmax'))
15. Impresión del resumen del modelo para revisar la estructura y parámetros de la red
neuronal.
# model summary
print([Link]())
Model: "sequential_2"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━
┃ Layer (type) ┃ Output Shape ┃ Pa
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━
│ dense_6 (Dense) │ (None, 512) │ 8,38
├──────────────────────────────────────┼─────────────────────────────┼───────────
│ activation_6 (Activation) │ (None, 512) │
├──────────────────────────────────────┼─────────────────────────────┼───────────
│ dropout_4 (Dropout) │ (None, 512) │
├──────────────────────────────────────┼─────────────────────────────┼───────────
│ dense_7 (Dense) │ (None, 512) │ 26
├──────────────────────────────────────┼─────────────────────────────┼───────────
│ activation_7 (Activation) │ (None, 512) │
├──────────────────────────────────────┼─────────────────────────────┼───────────
│ dropout_5 (Dropout) │ (None, 512) │
├──────────────────────────────────────┼─────────────────────────────┼───────────
│ dense_8 (Dense) │ (None, 2) │
├──────────────────────────────────────┼─────────────────────────────┼───────────
│ activation_8 (Activation) │ (None, 2) │
└──────────────────────────────────────┴─────────────────────────────┴───────────
Total params: 8,652,802 (33.01 MB)
Trainable params: 8,652,802 (33.01 MB)
Non-trainable params: 0 (0.00 B)
None
1_. Impresión de las dimensiones de las matrices de etiquetas y datos de entrenamiento y
prueba.
print("Y_train shape:", Y_train.shape)
print("Y_test shape:", Y_test.shape)
print("Y_train shape:", X_train.shape)
print("Y_test shape:", X_test.shape)
Y_train shape: (1718, 2)
Y_test shape: (430, 2)
Y_train shape: (1718, 16384)
Y_test shape: (430, 16384)
17. Compilación, entrenamiento y guardado de un modelo secuencial con historial de métricas
y ruta de guardado.
# compiling the sequential model
[Link](loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam')
# training the model and saving metrics in history
history = [Link](X_train, Y_train,
batch_size=128, epochs=20,
verbose=2,
validation_data=(X_test, Y_test))
# saving the model
save_dir = "/content/models"
model_name = 'keras_mnist.h5'
model_path = [Link](save_dir, model_name)
[Link](model_path)
print('Saved trained model at %s ' % model_path)
Epoch 1/20
14/14 - 9s - 651ms/step - accuracy: 0.6304 - loss: 2.1023 - val_accuracy: 0.7442
Epoch 2/20
14/14 - 7s - 472ms/step - accuracy: 0.7416 - loss: 0.6398 - val_accuracy: 0.7884
Epoch 3/20
14/14 - 5s - 332ms/step - accuracy: 0.8056 - loss: 0.4311 - val_accuracy: 0.8279
Epoch 4/20
14/14 - 6s - 406ms/step - accuracy: 0.8225 - loss: 0.3956 - val_accuracy: 0.8209
Epoch 5/20
14/14 - 8s - 580ms/step - accuracy: 0.8300 - loss: 0.3751 - val_accuracy: 0.8372
Epoch 6/20
14/14 - 7s - 472ms/step - accuracy: 0.8475 - loss: 0.3644 - val_accuracy: 0.7930
Epoch 7/20
14/14 - 3s - 246ms/step - accuracy: 0.8271 - loss: 0.3671 - val_accuracy: 0.8116
Epoch 8/20
14/14 - 5s - 322ms/step - accuracy: 0.8446 - loss: 0.3565 - val_accuracy: 0.8558
Epoch 9/20
14/14 - 6s - 445ms/step - accuracy: 0.8434 - loss: 0.3554 - val_accuracy: 0.8558
Epoch 10/20
14/14 - 4s - 280ms/step - accuracy: 0.8341 - loss: 0.3512 - val_accuracy: 0.8419
Epoch 11/20
14/14 - 3s - 195ms/step - accuracy: 0.8440 - loss: 0.3439 - val_accuracy: 0.8535
Epoch 12/20
14/14 - 3s - 193ms/step - accuracy: 0.8527 - loss: 0.3283 - val_accuracy: 0.8651
Epoch 13/20
14/14 - 4s - 263ms/step - accuracy: 0.8533 - loss: 0.3185 - val_accuracy: 0.7698
Epoch 14/20
14/14 - 4s - 289ms/step - accuracy: 0.8463 - loss: 0.3380 - val_accuracy: 0.8372
Epoch 15/20
14/14 - 5s - 384ms/step - accuracy: 0.8469 - loss: 0.3180 - val_accuracy: 0.7953
Epoch 16/20
14/14 - 6s - 423ms/step - accuracy: 0.8609 - loss: 0.3114 - val_accuracy: 0.8628
Epoch 17/20
14/14 - 4s - 287ms/step - accuracy: 0.8690 - loss: 0.3037 - val_accuracy: 0.8302
Epoch 18/20
14/14 - 5s - 374ms/step - accuracy: 0.8690 - loss: 0.3027 - val_accuracy: 0.8093
Epoch 19/20
14/14 - 5s - 377ms/step - accuracy: 0.8638 - loss: 0.3064 - val_accuracy: 0.7977
Epoch 20/20
14/14 - 5s - 337ms/step - accuracy: 0.8504 - loss: 0.3021 - val_accuracy: 0.8465
WARNING:absl:You are saving your model as an HDF5 file via `[Link]()` or `ker
Saved trained model at /content/models/keras_mnist.h5
1a. Visualización de la precisión y pérdida del modelo durante el entrenamiento y validación en
gráEcos de dos paneles.
# plotting the metrics
fig = [Link]()
[Link](2, 1, 1)
[Link]([Link]['accuracy'])
[Link]([Link]['val_accuracy'])
[Link]('model accuracy')
[Link]('accuracy')
[Link]('epoch')
[Link](['train', 'test'], loc='lower right')
[Link](2, 1, 2)
[Link]([Link]['loss'])
[Link]([Link]['val_loss'])
[Link]('model loss')
[Link]('loss')
[Link]('epoch')
[Link](['train', 'test'], loc='upper right')
plt.tight_layout()
[Link]()
19. Carga del modelo guardado y evaluación de pérdida y precisión en el conjunto de prueba.
mnist_model = load_model('/content/models/keras_mnist.h5')
loss_and_metrics = mnist_model.evaluate(X_test, Y_test, verbose=2)
print("Test Loss", loss_and_metrics[0])
print("Test Accuracy", loss_and_metrics[1])
WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be b
14/14 - 1s - 37ms/step - accuracy: 0.8465 - loss: 0.3686
Test Loss 0.3686353862285614
Test Accuracy 0.8465116024017334
20. Generación de predicciones en el conjunto de prueba y análisis de clasiEcaciones
correctas e incorrectas.
# create predictions on the test set
predict_x = mnist_model.predict(X_test)
predicted_classes = [Link](predict_x, axis=1)
# see which we predicted correctly and which not
correct_indices = [Link](predicted_classes == y_test_scalar)[0]
incorrect_indices = [Link](predicted_classes != y_test_scalar)[0]
print()
print(len(correct_indices), " classified correctly")
print(len(incorrect_indices), " classified incorrectly")
14/14 ━━━━━━━━━━━━━━━━━━━━ 0s 20ms/step
364 classified correctly
66 classified incorrectly
21. Visualización de las primeras 9 predicciones correctas e incorrectas en una cuadrícula de
6x3.
# adapt figure size to accomodate 18 subplots
[Link]['[Link]'] = (7, 14)
figure_evaluation = [Link]()
# plot 9 correct predictions
for i, correct in enumerate(correct_indices[:9]):
[Link](6, 3, i + 1)
[Link](X_test[correct].reshape(lado, lado), cmap='gray', interpolation='none')
[Link](
"Predicted: {}, Truth: {}".format(predicted_classes[correct],
y_test_scalar[correct]))
[Link]([])
[Link]([])
# plot 9 incorrect predictions
for i, incorrect in enumerate(incorrect_indices[:9]):
[Link](6, 3, i + 10)
[Link](X_test[incorrect].reshape(lado, lado), cmap='gray', interpolation='none
[Link](
"Predicted {}, Truth: {}".format(predicted_classes[incorrect],
y_test_scalar[incorrect]))
[Link]([])
[Link]([])
figure_evaluation.show()
