Curso de Keras: Clasificacion por regresión

La regresión es un algoritmo supervisado de aprendizaje automático que genera un resultado previsto que es continuo en lugar de discreto. Eso significa que puede ser un número entero o un rango de datos, como puede ser el número de ventas durante un período de tiempo, en lugar de un elemento absoluto, como puede ser decir si hay un gato en una foto o no. 

Hay dos tipos principales de regresión. simple y multivariable. La regresión lineal simple utiliza conjuntos de datos donde hay dos características o columnas que tienen datos numéricos relacionados. Como por ejemplo el número de ventas de una compañía en una columna y la temperatura en la otra. El resultado de la predicción es una estimación de las ventas en relación con la temperatura en ese momento. Podría ser que a medida que baja la temperatura, las ventas aumenten. (por ejemplo las ventas de abrigos en unos grandes almacenes)

Nota de Tensorflow. Si en vez de anaconda o CNTK  queremos trabajar con Tensorflow-colaboratory y tenemos problemas con las versiones: #Para determinar que versión de tensor flow estamos utilizando: !pip show tensorflow #Para ver la versión actual de tensorflow: !pip install -–upgrade tensorflow # Para ejecutar una versión específica: !pip install tensorflow==2.0

Fotos similares a esta.

La regresión multivariable  agrega columnas adicionales al conjunto de datos, como la cantidad de precipitación en el día. Y la precipitación puede ser nieve o lluvia dependiendo de la temperatura. Y los resultados podrían indicar que cuando llueve, disminuyen las ventas. Este ejemplo simple muestra una regresión y una predicción usando conjuntos de números generados aleatoriamente. 

Vamos a realizar un ejemplo con tensorflow en un cuaderno de Colaboratory

Y a continuación ponemos :

#importación de paquetes

from tensorflow.keras import layers

from tensorflow import keras 

import tensorflow as tf

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from sklearn.datasets import make_regression

from sklearn.preprocessing import MinMaxScaler

from numpy import array

Estas son bibliotecas importantes que necesitaremos. 

A continuación crearemos un conjunto de datos. 

Utilizaremos la función make_regression. y especificaremos algunos números escalares, como MinMaxScalar. Las funciones específicas no son tan relevantes, solo es necesario entender que estamos tratando de crear un conjunto de datos con cierta aleatoriedad. 

#Creamos el dataset.

X,y=make_regression(n_samples=1000,n_features=2,noise=0.2,random_state=1)

scalarX,scalarY=MinMaxScaler(),MinMaxScaler()

scalarX.fit(X)

scalarY.fit(y.reshape(1000,1))

X=scalarX.transform(X)

y=scalarY.transform(y.reshape(1000,1))

model=Sequential()

model.add(Dense(4,input_dim=2,activation='relu'))

model.add(Dense(4,activation='relu'))

model.add(Dense(1,activation='linear'))

model.compile(loss='mse',optimizer='sgd')

model.fit(X,y,epochs=50,verbose=1)

Ejecutamos el modelo. Este es una red neuronal secuencial con tres capas, cuatro unidades en la entrada en la capa oculta y una unidad en la capa de salida.

Compilamos el modelo. En este caso, vamos a utilizar la función de pérdida de error cuadrático medio y el optimizador de sgd. Eso es lo que significa MSE, es un error cuadrado medio. 

xpred, a = make_regression(n_samples=3, n_features=2, noise=0.1, random_state=1)

xpred =scalarX.transform(xpred)

ypred = model.predict(xpred)

for i in range(len(xpred)):

   print("X=%s, Predicted=%s" % (xpred[i], ypred[i]))

A continuación crearemos  el conjunto de datos de predicción real. Ponemos otras tres líneas de código, en la primera escribimos  xpred,  a = make_regression()

y ponemos tres muestras, dos características y especificamos el ruido como 0.1, finalmente el estado aleatorio es 1. 

xpred, a = make_regression (n_samples = 3, n_features = 2, noise = 0.1, random_state = 1)

Esto es solo para hacer una predicción, y podemos poner los valores que consideremos oportunos, después escribimos scalarX.transform, y por transformamos la variable creada en la primera línea. 

xpred = scalarX. transform (xpred)

Y finalmente, nuestra predicción que es model.predict, donde el xpred transformado de la línea 1 nuevamente. 

ypred = model. predict(xpred)

Estas tres líneas se escriben una sobre la otra como podemos ver a continuación.

xpred, a = make_regression (n_samples = 3, n_features = 2, noise = 0.1, random_state = 1)

xpred = scalarX. transform (xpred)

ypred = model. predict(xpred)

Imprimimos estos resultados, para el rango i, la longitud de la predicción es x, y por lo que podemos teclear:

print ("X =% s, Predicted =% s"% (xpred [i], ypred [i]))

Esto puede llevar tiempo, la salida será en realidad los rangos de datos devueltos y los resultados predichos. Esto ayuda a evaluar el rendimiento del modelo y determinar la precisión del resultado. Finalmente, obtenemos nuestro resultado con nuestras predicciones.

Clasificación de imágenes

Un uso común del aprendizaje profundo (deep learning) con redes neuronales es la clasificación de imágenes. Consiste en tomar un conjunto de datos compuesto por imágenes y pasarlas a través de la red neuronal para su clasificación  o/y etiquetado. Esta misma metodología se puede aplicar a las entradas de audio, lo que permite el reconocimiento de voz.

El aprendizaje profundo es muy eficiente para clasificar objetos e imágenes cuando tiene tres o más capas de redes neuronales. Más en la red capas significa que se pueden extraer más características, lo que significa que aumenta la probabilidad de éxito.

La capacitación de una red significa proporcionar un conjunto de datos lo suficientemente grande para la máquina. De modo que esta  comprenda las características que forman parte de un solo tipo, o etiqueta, de datos, como identificar las diferencias entre un gato y un perro. Cuantas más imágenes de cada elemento este sujeta la máquina, más precisa será para predecir la categoría correcta. Esto se conoce como aprendizaje supervisado. Cada imagen de un gato está etiquetada como tal. Y cada imagen de un perro está etiquetada como un perro.

Cuando se completa el entrenamiento y el proceso, se puede presentar una nueva imagen de un perro o un gato en el conjunto de datos de prueba. Y la máquina se encargará de categorizar qué imagen pertenece a qué clase.

Cuando un ordenador lee una imagen, cada neurona en cada capa procesa un área pequeña de la imagen. Convierte los datos al tipo de representación numérica funcional. En el caso de que la imagen sea RGB,  significa que la imagen es en color, y a cada pixel se le asigna un número entre 0 y 255. Esto significa que se convierte una imagen en una matriz de números.

Cuando se procesa una nueva imagen, se compara la matriz de la imagen con las que ya ha aprendido. Si los números están en una secuencia cerrada, se asigna un peso a ese resultado. Cuanto más cercana sea la secuencia al modelo, más precisa será la tasa de predicción.

Una red neuronal convolucional, o CNN, es una red neuronal que tiene una capa de convolución al principio. Son el tipo más utilizado para la clasificación de imágenes. Esta es la capa que divide una imagen en piezas o mosaicos más pequeños para su procesamiento.

Vamos a importar algunas bibliotecas y crear algunos conjuntos de datos. Importaremos algunos paquetes.

#importación de paquetes

from __future__ import print_function

import tensorflow.keras

Como va a ser un gráfico, importaremos la trama.

from tensorflow.keras.datasets import cifar10

from tensorflow.keras.preprocessing.image import ImageDataGenerator

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Dropout, Activation , Flatten

from tensorflow.keras.layers import Conv2D, MaxPooling2D

import os

import matplotlib.pyplot as plt

Ejecutamos estas instrucciones y continuamos con estas.

#importamos el dataset

(x_train, y_train), (x_test, y_test) = cifar10.load_data()

#etiquetamos las imágenes

y_train = keras.utils.to_categorical(y_train, 10)

y_test =  keras.utils.to_categorical(y_test, 10)

x_train = x_train.astype('float32')

x_test = x_test.astype('float32')

x_train /= 255

x_test /= 255

El paquete cifar10  consta de aproximadamente 60,000 imágenes y 10 clases. Lo último que hicimos fue aplicar algunas etiquetas a los conjuntos de datos. Así que podemos ver que y_train, y_test, son solo etiquetas aplicadas. Vamos a trazar cuatro imágenes ahora. 

plt.subplot(894)

plt.imshow(x_train[10], cmap=plt.get_cmap('gray'))

plt.subplot(234)

plt.imshow(x_train[11], cmap=plt.get_cmap('gray'))

plt.subplot(654)

plt.imshow(x_train[12], cmap=plt.get_cmap('gray'))

plt.subplot(751)

plt.imshow(x_train[13], cmap=plt.get_cmap('gray'))

Y ponemos  plt. show () 

plt.show()

En este punto, hemos cargado nuestro conjunto de datos. Creamos una red neuronal con estas instrucciones.

model = Sequential()

model.add(Conv2D(32, (3,3), padding = 'same', input_shape=x_train.shape[1:]))

model.add(Activation('relu'))

model.add(Conv2D(32, (3,3)))

model.add(Activation('relu'))

model.add(MaxPooling2D(pool_size=(2,2)))            

model.add(Dropout(0.25))  

model.add(Conv2D(64, (3,3), padding = 'same'))

model.add(Activation('relu'))

model.add(Conv2D(64, (3,3)))

model.add(Activation('relu'))

model.add(MaxPooling2D(pool_size=(2,2)))   

model.add(Dropout(0.25))   

model.add(Flatten())

model.add(Dense(512))

model.add(Activation('relu'))

model.add(Dropout(0.25))   

model.add(Dense(10))

model.add(Activation('softmax'))

Esta red neuronal que acabamos de crear, tiene muchas capas, proporcionando multitud de funciones, estas funciones son un intento de normalizar las imágenes que acabamos de ver, creando convolución y muestreando la entrada.

Estas tareas son tentativas, tendremos que jugar variando diferentes parámetros y probar que combinación da mejores resultados. Crearemos variaciones de esta red. Compilamos y ajustamos la red de nuevo.

# compilamos el modelo de red neuronal utilizando el optimizador rmsprop y la función de pérdida categórica crossentropy

model.compile(loss='categorical_crossentropy',optimizer='rmsprop', metrics=['accuracy'])

#montamos el modelo

model.fit(x_train,y_train, batch_size=32, epochs =1, validation_data=(x_test,y_test), shuffle = True)

#Evaluamos la ejecución de la red neuronal

scores = model.evaluate(x_test, y_test, verbose = 1)

print ('test.loss', scores[0])

print ('Test.accuracy:', scores[1])

Compilamos utilizando el optimizador rmsprop. 

Agregamos la notación de texto, y rellenamos una función de pérdida. Estamos entrenando 50.000 muestras, y ejecutaremos la validación sobre 10.000. Esto puede llevar algo de tiempo.

Mientras se está ejecutando, la pérdida y precisión fluctúan a medida que transcurre cada época. Cuando termina podemos evaluar el rendimiento de nuestro modelo de red neuronal.

Sabemos que la red neuronal se ha entrenado usando el conjunto de 50.000 imágenes. Y lo que estamos haciendo es probar contra un conjunto de 10.000. Para mejorar el rendimiento, podemos utilizar conjuntos de datos más grandes, más épocas o más capas.  finalmente, para este caso nuestra precisión de prueba fue de 0.5892.