¿Cómo normalizar, centrar y estandarizar píxeles de imagen en Keras?

La parte más crucial para un modelo de red neuronal de aprendizaje profundo es el ‘conjunto de datos’, o directamente las imágenes en el conjunto de datos si el modelo se usa para la detección de objetos/imágenes, etc. Los valores de píxeles en las imágenes deben escalarse correctamente antes del desarrollo. del modelo de red neuronal.

Keras es una biblioteca de aprendizaje profundo en Python, utilizada en redes neuronales para entrenar los modelos. Keras admite escalar las imágenes durante el entrenamiento del modelo. En los siguientes ejemplos, se usará ‘ImageDataGenerator’, que es una clase en la biblioteca de Keras. Proporcionará una técnica para escalar los valores de píxeles de la imagen antes del modelado.

La técnica de escalado de píxeles consta de tres tipos principales, compatibles con la clase ImageDataGenerator:

• Normalización de píxeles : escala los valores de los píxeles en un rango de 0-1.
• Centrado de píxeles : escala los valores de los píxeles para tener una media de 0.
• Estandarización de píxeles : escala los valores de los píxeles para que tengan una media de 0 y una varianza de unidad (1).

El escalado de píxeles se realiza especificando algunos argumentos para ImageDataGenerator:

datagen = ImageDataGenerator(…)

Cálculo de las estadísticas de escalado en el conjunto de datos de entrenamiento:

datagen.fit(trenX)

Montaje de la red neuronal en el generador de datos:

tren_iterador = datagen.flow(trenX, treny)

modelo.fit_generator(tren_iterador, …)

Creando un iterador por lotes separado para entrenar y validar en el generador de datos que realizará la misma escala de píxeles:

tren_iterador = datagen.flow(trenX, treny)

val_iterator = datagen.flow(valX, valy)

modelo.fit_generator(tren_iterador, validación_datos=val_iterador, …)

 Iterador por lotes para el conjunto de datos de prueba después de ajustar el modelo:

test_iterator = datagen.flow(testX, irritable)

pérdida = model.evaluate_generator(test_iterator, …)

Conjunto de datos utilizado:

En los próximos ejemplos, para normalizar, centrar y estandarizar los píxeles de la imagen en la biblioteca Keras, se usará el conjunto de datos MSIST . Consta de 60.000 imágenes en escala de grises del conjunto de trenes y 10.000 conjuntos de prueba adicionales de imágenes en escala de grises que consisten en los dígitos de ‘0-9’ en diferentes orientaciones. Enlace al conjunto de datos MNIST . Tipos de imágenes utilizadas en el conjunto de datos:

Normalización de píxeles de imagen en K eras

Al cambiar la escala de los valores de píxeles del rango 0-255 al rango 0-1, se puede usar la clase ImageDataGenerator. El rango en la escala 0-1 se conoce como Normalización . Se deben seguir los siguientes pasos para normalizar los píxeles de la imagen:

• Se puede escalar píxeles en el rango 0-1 configurando el argumento de cambio de escala dividiendo el valor máximo del píxel por el valor mínimo del píxel: 1/255 = 0.0039
• Creación de iteradores usando el generador para conjuntos de datos de prueba y entrenamiento. En este caso, se utilizarán tamaños de lote de 64. Significa que 64 imágenes pasarán por el proceso de entrenamiento en cada época.
• La normalización de píxeles se puede confirmar tomando el primer lote de imágenes escaladas y verificando los valores mínimo y máximo del píxel.
• Para usar el generador de datos para ajustar y evaluar el modelo, se define un modelo de red neuronal de convolución (CNN) y ejecutamos cinco épocas con 60 000 imágenes por lote, equivalente a 938 lotes por época.
• Ahora, evaluando el modelo en el conjunto de datos de prueba que tiene 10,000 imágenes distribuidas en lotes de tamaño 64, equivalente a 157 pasos en una época.

Ejemplo:

# import required modules
from keras.datasets import mnist
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Dense
from keras.layers import Flatten
from keras.preprocessing.image import ImageDataGenerator
  
# loading the image dataset
(trainX, trainY), (testX, testY) = mnist.load_data()
  
# reshaping the dataset to have a single channel
width, height, channels = trainX.shape[1], trainX.shape[2], 1
trainX = trainX.reshape((trainX.shape[0], width, height, channels))
testX = testX.reshape((testX.shape[0], width, height, channels))
trainY = to_categorical(trainY)
testY = to_categorical(testY)
  
# confirming scale of pixel values
print('Train min=%.3f, max=%.3f' % (trainX.min(), trainX.max()))
print('Test min=%.3f, max=%.3f' % (testX.min(), testX.max()))
  
# creating the image data generator [1.0/255.0 = 0.00392156862]
datagen = ImageDataGenerator(rescale=1.0/255.0)
  
# preparing an iterator for scaling images
train_iterator = datagen.flow(trainX, trainY, batch_size=64)
test_iterator = datagen.flow(testX, testY, batch_size=64)
print('Batches train=%d, test=%d' % (len(train_iterator),
                                     len(test_iterator)))
# confirming- the scaling works
batchX, batchy = train_iterator.next()
print('Batch shape=%s, min=%.3f, max=%.3f' % (batchX.shape, batchX.min(),
                                              batchX.max()))
# defining the model
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(width, height,
                                                             channels)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))
  
# compiling the model
model.compile(optimizer='adam', loss='categorical_crossentropy',
              metrics=['accuracy'])
  
# fitting the model with generator
model.fit_generator(train_iterator, steps_per_epoch=len(train_iterator),
                    epochs=5)
  
# evaluating the model
_, acc = model.evaluate_generator(test_iterator, steps=len(test_iterator),
                                  verbose=0)
print('Test Accuracy: %.3f' % (acc * 100))

Después de ejecutar el script anterior, descargará el conjunto de datos MNIST del sitio web de Amazon-AWS. Llevará algún tiempo descargar el conjunto de datos.

Al recuperar el primer lote que contiene 64 imágenes de tamaño 28*28 y valores de píxel en el rango 0-1.

El modelo se evalúa sobre el conjunto de datos de prueba, aplicando la técnica de normalización.

La precisión del modelo de red neuronal resulta ser del 98,07 % .

Centrado de píxeles de imagen en Keras

Los píxeles de la imagen se centran calculando los valores medios de los píxeles y luego restándolos de cada imagen. Esta técnica se conoce como Centrado . Esto tiene el efecto de centrar los valores de distribución de píxeles en cero, lo que significa que las imágenes centradas tendrán valores de píxel de ‘media cero’. Se deben seguir los siguientes pasos para centrar los píxeles de la imagen:

• Usar los métodos estadísticos para calcular los valores medios de píxeles en la clase ImageDataGenerator en el conjunto de datos de entrenamiento.
• Los valores medios de píxeles en Keras no requieren ninguna estadística. Se le conoce como centrado de muestra en Keras.
• Después de que se calculan las estadísticas, se realiza el centrado de características.
• La media de un lote de imágenes se calcula en el iterador de lotes. La media tiene un valor cercano a cero, no exactamente cero.
• Configuración del tamaño del lote en el conjunto de datos de entrenamiento. Puede ser cualquier valor cercano a cero.

Ejemplo:

# import required modules
from keras.datasets import mnist
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Dense
from keras.layers import Flatten
from keras.preprocessing.image import ImageDataGenerator
  
# loading the dataset
(trainX, trainY), (testX, testY) = mnist.load_data()
  
# reshaping the dataset to have a single channel
width, height, channels = trainX.shape[1], trainX.shape[2], 1
trainX = trainX.reshape((trainX.shape[0], width, height, channels))
testX = testX.reshape((testX.shape[0], width, height, channels))
trainY = to_categorical(trainY)
testY = to_categorical(testY)
  
# creating image data generator for centering images
datagen = ImageDataGenerator(featurewise_center=True)
  
# calculating the mean of the training dataset
datagen.fit(trainX)
  
# preparing iterators to scale images
train_iterator = datagen.flow(trainX, trainY, batch_size=64)
test_iterator = datagen.flow(testX, testY, batch_size=64)
print('Batches train=%d, test=%d' % (len(train_iterator),
                                     len(test_iterator)))
  
# defining the model
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(width, height,
                                                             channels)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))
  
# compiling the model
model.compile(optimizer='adam', loss='categorical_crossentropy',
              metrics=['accuracy'])
  
# fitting the model with the generator
model.fit_generator(train_iterator, steps_per_epoch=len(train_iterator),
                    epochs=5)
  
# evaluating the model
_, acc = model.evaluate_generator(test_iterator, steps=len(test_iterator),
                                  verbose=0)
print('Test Accuracy: %.3f' % (acc * 100))

Después de ejecutar el script anterior, descargará el conjunto de datos MNIST del sitio web de Amazon-AWS. Llevará algún tiempo descargar el conjunto de datos.

Se recuperan las imágenes centradas de un solo lote y podemos ver claramente que el valor medio de píxel es muy cercano a cero. El valor de píxel medio cero confirma el efecto deseado de centrado.

El rendimiento de la red neuronal comienza mal y no mejora. Los píxeles de valor centrados tienen un rango de -277 a 277. Las redes neuronales generalmente se entrenan con más eficiencia con entradas más pequeñas. Por lo tanto, la Normalización debe realizarse antes del Centrado para obtener mejores resultados.

La precisión del modelo de red neuronal resulta ser del 99,12 % .

Estandarización de píxeles de imagen en Keras

La estandarización es una técnica que escala los datos y asume que la distribución de los datos es gaussiana y cambia la distribución de los datos para tener una ‘media cero’ y una ‘desviación estándar de la unidad (1)’. Los datos con este tipo de distribución se conocen como Gaussiana estándar. Esta técnica es fructífera cuando el conjunto de datos de la red neuronal suma cero y tiene valores de entrada más pequeños en el rango de -3,0 a 3,0.

Las imágenes estandarizadas se obtienen restando los valores de píxeles medios de sus valores de píxeles individuales y luego dividiéndolos por la desviación estándar de los valores de píxeles. Se deben seguir los siguientes pasos para estandarizar los píxeles de la imagen:

• Cálculo de la media y la desviación estándar de los valores de píxel.
• Uso de estadísticas para estandarizar cada imagen. En Keras, se denomina estandarización por muestreo.
• Crear un lote de 64 imágenes que tengan una desviación estándar de la unidad media cero para que la muestra se acerque al Gaussiano estándar.
• Ejecutar la prueba en todo el conjunto de datos para confirmar que la media está cerca de cero y la desviación estándar está cerca de 1.
• Aplicar escalado de píxeles mientras ajusta y evalúa la red neuronal.

Ejemplo:

# import required modules
from keras.datasets import mnist
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Dense
from keras.layers import Flatten
from keras.preprocessing.image import ImageDataGenerator
  
# loading the dataset
(trainX, trainY), (testX, testY) = mnist.load_data()
  
# reshaping the dataset to have a single channel
width, height, channels = trainX.shape[1], trainX.shape[2], 1
trainX = trainX.reshape((trainX.shape[0], width, height, channels))
testX = testX.reshape((testX.shape[0], width, height, channels))
trainY = to_categorical(trainY)
testY = to_categorical(testY)
  
# creating the image data generator to standardize images
datagen = ImageDataGenerator(featurewise_center=True,
                             featurewise_std_normalization=True)
  
# calculating the mean on the training dataset
datagen.fit(trainX)
  
# preparing iterators to scale images
train_iterator = datagen.flow(trainX, trainY, batch_size=64)
test_iterator = datagen.flow(testX, testY, batch_size=64)
print('Batches train=%d, test=%d' % (len(train_iterator),
                                     len(test_iterator)))
  
# defining the model
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu',
                 input_shape=(width, height, channels)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))
  
# compiling the  model
model.compile(optimizer='adam', loss='categorical_crossentropy',
              metrics=['accuracy'])
  
# fitting the model with the generator
model.fit_generator(train_iterator, steps_per_epoch=len(train_iterator),
                    epochs=5)
  
# evaluating the model
_, acc = model.evaluate_generator(test_iterator, steps=len(test_iterator),
                                  verbose=0)
print('Test Accuracy: %.3f' % (acc * 100))

Después de ejecutar el script anterior, descargará el conjunto de datos MNIST del sitio web de Amazon-AWS. Llevará algún tiempo descargar el conjunto de datos.

Se recupera un solo lote que consta de 64 imágenes estandarizadas, la media y la desviación estándar están cerca de 0,0 y 1,0, respectivamente, como la gaussiana estándar esperada. 

La clase ImageDataGenerator estandariza imágenes y calcula funciones estadísticas en el conjunto de trenes, ajustando y evaluando así el modelo.

La precisión del modelo de red neuronal resulta ser del 99,34 % .

Estas son las técnicas discutidas para normalizar, centrar y estandarizar los valores de píxeles de la imagen utilizando la biblioteca de aprendizaje profundo de código abierto de Keras.