IA con Python: aprendizaje profundo

Artificial Neural Network (ANN) es un sistema informático eficiente, cuyo tema central se toma prestado de la analogía de las redes neuronales biológicas. Las redes neuronales son un tipo de modelo para el aprendizaje automático. A mediados de la década de 1980 y principios de la de 1990, se realizaron avances arquitectónicos muy importantes en las redes neuronales. En este capítulo, aprenderá más sobre Deep Learning, un enfoque de IA.

El aprendizaje profundo surgió del explosivo crecimiento computacional de una década como un competidor serio en el campo. Por lo tanto, el aprendizaje profundo es un tipo particular de aprendizaje automático cuyos algoritmos se inspiran en la estructura y función del cerebro humano.

Aprendizaje automático frente a aprendizaje profundo

El aprendizaje profundo es la técnica de aprendizaje automático más poderosa en estos días. Es tan poderoso porque aprenden la mejor manera de representar el problema mientras aprenden cómo resolverlo. A continuación, se muestra una comparación de aprendizaje profundo y aprendizaje automático:

Dependencia de datos

El primer punto de diferencia se basa en el rendimiento de DL y ML cuando aumenta la escala de datos. Cuando los datos son grandes, los algoritmos de aprendizaje profundo funcionan muy bien.

Dependencia de la máquina

Los algoritmos de aprendizaje profundo necesitan máquinas de alta gama para funcionar perfectamente. Por otro lado, los algoritmos de aprendizaje automático también pueden funcionar en máquinas de gama baja.

Extracción de características

Los algoritmos de aprendizaje profundo pueden extraer características de alto nivel e intentar aprender de las mismas también. Por otro lado, se requiere un experto para identificar la mayoría de las características extraídas por el aprendizaje automático.

Momento de ejecución

El tiempo de ejecución depende de los numerosos parámetros utilizados en un algoritmo. El aprendizaje profundo tiene más parámetros que los algoritmos de aprendizaje automático. Por lo tanto, el tiempo de ejecución de los algoritmos DL, especialmente el tiempo de entrenamiento, es mucho más que los algoritmos ML. Pero el tiempo de prueba de los algoritmos DL es menor que el de los algoritmos ML.

Enfoque para la resolución de problemas

El aprendizaje profundo resuelve el problema de principio a fin, mientras que el aprendizaje automático utiliza la forma tradicional de resolver el problema, es decir, dividiéndolo en partes.

Red neuronal convolucional (CNN)

Las redes neuronales convolucionales son las mismas que las redes neuronales ordinarias porque también están formadas por neuronas que tienen pesos y sesgos que se pueden aprender. Las redes neuronales ordinarias ignoran la estructura de los datos de entrada y todos los datos se convierten en una matriz 1-D antes de introducirlos en la red. Este proceso se adapta a los datos normales; sin embargo, si los datos contienen imágenes, el proceso puede resultar complicado.

CNN resuelve este problema fácilmente. Tiene en cuenta la estructura 2D de las imágenes cuando las procesa, lo que les permite extraer las propiedades específicas de las imágenes. De esta forma, el objetivo principal de las CNN es pasar de los datos de imagen sin procesar en la capa de entrada a la clase correcta en la capa de salida. La única diferencia entre un NN ordinario y un CNN está en el tratamiento de los datos de entrada y en el tipo de capas.

Descripción general de la arquitectura de las CNN

Arquitectónicamente, las redes neuronales ordinarias reciben una entrada y la transforman a través de una serie de capas ocultas. Cada capa está conectada a la otra capa con la ayuda de neuronas. La principal desventaja de las redes neuronales ordinarias es que no escalan bien a imágenes completas.

La arquitectura de las CNN tiene neuronas dispuestas en 3 dimensiones llamadas ancho, alto y profundidad. Cada neurona de la capa actual está conectada a un pequeño parche de la salida de la capa anterior. Es similar a superponer un×filtrar en la imagen de entrada. UsaMfiltros para asegurarse de obtener todos los detalles. EstasM Los filtros son extractores de características que extraen características como bordes, esquinas, etc.

Capas utilizadas para construir CNN

Las siguientes capas se utilizan para construir CNN:

• Input Layer - Toma los datos de la imagen sin procesar tal como están.

• Convolutional Layer- Esta capa es el componente básico de las CNN que realiza la mayoría de los cálculos. Esta capa calcula las convoluciones entre las neuronas y los distintos parches de la entrada.

• Rectified Linear Unit Layer- Aplica una función de activación a la salida de la capa anterior. Agrega no linealidad a la red para que se pueda generalizar bien a cualquier tipo de función.

• Pooling Layer- La agrupación nos ayuda a mantener solo las partes importantes a medida que avanzamos en la red. La capa de agrupación opera de forma independiente en cada segmento de profundidad de la entrada y la redimensiona espacialmente. Utiliza la función MAX.

• Fully Connected layer/Output layer - Esta capa calcula las puntuaciones de salida en la última capa. La salida resultante es del tamaño×× , donde L es el número de clases del conjunto de datos de entrenamiento.

Instalación de paquetes de Python útiles

Puedes usar Keras, que es una API de redes neuronales de alto nivel, escrita en Python y capaz de ejecutarse sobre TensorFlow, CNTK o Theno. Es compatible con Python 2.7-3.6. Puede obtener más información al respecto enhttps://keras.io/.

Utilice los siguientes comandos para instalar keras:

pip install keras

En conda entorno, puede utilizar el siguiente comando:

conda install –c conda-forge keras

Construyendo un regresor lineal usando ANN

En esta sección, aprenderá a construir un regresor lineal utilizando redes neuronales artificiales. Puedes usarKerasRegressorlograr esto. En este ejemplo, estamos usando el conjunto de datos de precios de la vivienda de Boston con 13 números para propiedades en Boston. El código Python para el mismo se muestra aquí:

Importe todos los paquetes necesarios como se muestra:

import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold

Ahora, cargue nuestro conjunto de datos que está guardado en el directorio local.

dataframe = pandas.read_csv("/Usrrs/admin/data.csv", delim_whitespace = True, header = None)
dataset = dataframe.values

Ahora, divida los datos en variables de entrada y salida, es decir, X e Y -

X = dataset[:,0:13]
Y = dataset[:,13]

Dado que usamos redes neuronales de referencia, defina el modelo:

def baseline_model():

Ahora, cree el modelo de la siguiente manera:

model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initializer = 'normal', 
   activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))

A continuación, compile el modelo:

model_regressor.compile(loss='mean_squared_error', optimizer='adam')
return model_regressor

Ahora, corrija la semilla aleatoria para la reproducibilidad de la siguiente manera:

seed = 7
numpy.random.seed(seed)

El objeto contenedor de Keras para usar en scikit-learn como se llama estimador de regresión KerasRegressor. En esta sección, evaluaremos este modelo con un conjunto de datos estandarizados.

estimator = KerasRegressor(build_fn = baseline_model, nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_splits = 10, random_state = seed)
baseline_result = cross_val_score(estimator, X, Y, cv = kfold)
print("Baseline: %.2f (%.2f) MSE" % (Baseline_result.mean(),Baseline_result.std()))

La salida del código que se muestra arriba sería la estimación del rendimiento del modelo en el problema para los datos invisibles. Será el error cuadrático medio, incluido el promedio y la desviación estándar en los 10 pliegues de la evaluación de validación cruzada.

Clasificador de imágenes: una aplicación de aprendizaje profundo

Las redes neuronales convolucionales (CNN) resuelven un problema de clasificación de imágenes, es decir, a qué clase pertenece la imagen de entrada. Puede utilizar la biblioteca de aprendizaje profundo de Keras. Tenga en cuenta que estamos utilizando el conjunto de datos de entrenamiento y prueba de imágenes de gatos y perros del siguiente enlacehttps://www.kaggle.com/c/dogs-vs-cats/data.

Importe las bibliotecas y paquetes importantes de keras como se muestra:

El siguiente paquete llamado secuencial inicializará las redes neuronales como red secuencial.

from keras.models import Sequential

El siguiente paquete llamado Conv2D se utiliza para realizar la operación de convolución, el primer paso de CNN.

from keras.layers import Conv2D

El siguiente paquete llamado MaxPoling2D se utiliza para realizar la operación de agrupación, el segundo paso de CNN.

from keras.layers import MaxPooling2D

El siguiente paquete llamado Flatten es el proceso de convertir todas las matrices 2D resultantes en un solo vector lineal largo y continuo.

from keras.layers import Flatten

El siguiente paquete llamado Dense se utiliza para realizar la conexión completa de la red neuronal, el cuarto paso de CNN.

from keras.layers import Dense

Ahora, cree un objeto de la clase secuencial.

S_classifier = Sequential()

Ahora, el siguiente paso es codificar la parte de convolución.

S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))

aquí relu es la función rectificadora.

Ahora, el siguiente paso de CNN es la operación de agrupación en los mapas de características resultantes después de la parte de convolución.

S-classifier.add(MaxPooling2D(pool_size = (2, 2)))

Ahora, convierta todas las imágenes agrupadas en un vector continuo utilizando halagador:

S_classifier.add(Flatten())

A continuación, cree una capa completamente conectada.

S_classifier.add(Dense(units = 128, activation = 'relu'))

Aquí, 128 es el número de unidades ocultas. Es una práctica común definir el número de unidades ocultas como la potencia de 2.

Ahora, inicialice la capa de salida de la siguiente manera:

S_classifier.add(Dense(units = 1, activation = 'sigmoid'))

Ahora, compile la CNN, hemos construido ...

S_classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

Aquí, el parámetro del optimizador es elegir el algoritmo de descenso de gradiente estocástico, el parámetro de pérdida es elegir la función de pérdida y el parámetro de métrica es elegir la métrica de rendimiento.

Ahora, realice aumentos de imagen y luego ajuste las imágenes a las redes neuronales:

train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)

training_set = 
   train_datagen.flow_from_directory(”/Users/admin/training_set”,target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

test_set = 
   test_datagen.flow_from_directory('test_set',target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

Ahora, ajuste los datos al modelo que hemos creado:

classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs = 
25,validation_data = test_set,validation_steps = 2000)

Aquí, steps_per_epoch tiene el número de imágenes de entrenamiento.

Ahora que el modelo ha sido entrenado, podemos usarlo para la predicción de la siguiente manera:

from keras.preprocessing import image

test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg', 
target_size = (64, 64))

test_image = image.img_to_array(test_image)

test_image = np.expand_dims(test_image, axis = 0)

result = classifier.predict(test_image)

training_set.class_indices

if result[0][0] == 1:
prediction = 'dog'

else:
   prediction = 'cat'