El artículo trata sobre la creación de un clasificador de imágenes para identificar gatos contra perros usando TFLearn en Python. El problema está aquí alojado en kaggle .
El aprendizaje automático es ahora uno de los temas más candentes en todo el mundo. Bueno, incluso se puede decir que es la nueva electricidad en el mundo actual. Pero para ser precisos, qué es Machine Learning, bueno, es solo una forma de enseñarle a la máquina al alimentar una gran cantidad de datos. Para saber más sobre el aprendizaje automático y sus algoritmos, puede consultar algunos enlaces que se proporcionan en las secciones de referencia de este artículo.
Hoy, crearemos un clasificador de imágenes propio que puede distinguir si una imagen dada es de un perro o un gato o cualquier otra cosa, dependiendo de los datos de su alimentación. Para lograr nuestro objetivo, utilizaremos uno de los famosos algoritmos de aprendizaje automático que se utilizan para la clasificación de imágenes, es decir, la red neuronal convolucional (o CNN).
Entonces, básicamente, ¿qué es CNN? Como sabemos, es un algoritmo de aprendizaje automático para que las máquinas comprendan las características de la imagen con previsión y recuerden las características para adivinar si el nombre de la nueva imagen se envía a la máquina. Dado que no es un artículo que explique CNN, agregaré algunos enlaces al final si están interesados en cómo funciona y se comporta CNN.
Entonces, después de revisar todos esos enlaces, veamos cómo crear nuestro propio clasificador de imágenes de gato contra perro. Para el conjunto de datos usaremos el conjunto de datos Kaggle de cat-vs-dog:
Ahora, después de obtener el conjunto de datos, debemos preprocesarlos un poco y proporcionar etiquetas a cada una de las imágenes que se proporcionan allí durante el entrenamiento del conjunto de datos. Para hacerlo, podemos ver que el nombre de cada imagen del conjunto de datos de entrenamiento comienza con «gato» o «perro», así que lo usaremos a nuestro favor y luego usamos un codificador en caliente para que la máquina entienda las etiquetas (gato [1, 0] o perro [0, 1]).
def label_img(img):
word_label = img.split('.')[-3]
# DIY One hot encoder
if word_label == 'cat': return [1, 0]
elif word_label == 'dog': return [0, 1]
Bibliotecas requeridas:
- TFLearn : biblioteca de aprendizaje profundo que presenta una API de nivel superior para TensorFlow utilizada para crear capas de nuestra CNN
- tqdm : haga que sus bucles muestren instantáneamente un medidor de progreso inteligente, solo por el diseño simple
- numpy – Para procesar las arrays de imagen
- open-cv : para procesar la imagen, como convertirla a escala de grises, etc.
- os : para acceder al sistema de archivos para leer la imagen del tren y el directorio de prueba de nuestras máquinas
- random – Para barajar los datos para superar el sesgo
- matplotlib : para mostrar el resultado de nuestro resultado predictivo.
- tensorflow : solo para usar el tensorboard para comparar la curva de pérdida y adam con nuestros datos de resultados o el registro obtenido.
TRAIN_DIR y TEST_DIR deben configurarse de acuerdo con la conveniencia del usuario y jugar con los hiperparámetros básicos como época, tasa de aprendizaje, etc. para mejorar la precisión. He convertido la imagen a escala de grises para que solo tengamos que lidiar con la array 2D; de lo contrario, es difícil aplicar CNN directamente a la array 3D, especialmente no recomendada para principiantes. A continuación se muestra el código que está muy comentado o, de lo contrario, puede encontrar el código aquí en mi cuenta de GitHub desde este enlace .
Python3
# Python program to create
# Image Classifier using CNN
# Importing the required libraries
import cv2
import os
import numpy as np
from random import shuffle
from tqdm import tqdm
'''Setting up the env'''
TRAIN_DIR = 'E:/dataset / Cats_vs_Dogs / train'
TEST_DIR = 'E:/dataset / Cats_vs_Dogs / test1'
IMG_SIZE = 50
LR = 1e-3
'''Setting up the model which will help with tensorflow models'''
MODEL_NAME = 'dogsvscats-{}-{}.model'.format(LR, '6conv-basic')
'''Labelling the dataset'''
def label_img(img):
word_label = img.split('.')[-3]
# DIY One hot encoder
if word_label == 'cat': return [1, 0]
elif word_label == 'dog': return [0, 1]
'''Creating the training data'''
def create_train_data():
# Creating an empty list where we should store the training data
# after a little preprocessing of the data
training_data = []
# tqdm is only used for interactive loading
# loading the training data
for img in tqdm(os.listdir(TRAIN_DIR)):
# labeling the images
label = label_img(img)
path = os.path.join(TRAIN_DIR, img)
# loading the image from the path and then converting them into
# grayscale for easier covnet prob
img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
# resizing the image for processing them in the covnet
img = cv2.resize(img, (IMG_SIZE, IMG_SIZE))
# final step-forming the training data list with numpy array of the images
training_data.append([np.array(img), np.array(label)])
# shuffling of the training data to preserve the random state of our data
shuffle(training_data)
# saving our trained data for further uses if required
np.save('train_data.npy', training_data)
return training_data
'''Processing the given test data'''
# Almost same as processing the training data but
# we dont have to label it.
def process_test_data():
testing_data = []
for img in tqdm(os.listdir(TEST_DIR)):
path = os.path.join(TEST_DIR, img)
img_num = img.split('.')[0]
img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
img = cv2.resize(img, (IMG_SIZE, IMG_SIZE))
testing_data.append([np.array(img), img_num])
shuffle(testing_data)
np.save('test_data.npy', testing_data)
return testing_data
'''Running the training and the testing in the dataset for our model'''
train_data = create_train_data()
test_data = process_test_data()
# train_data = np.load('train_data.npy')
# test_data = np.load('test_data.npy')
'''Creating the neural network using tensorflow'''
# Importing the required libraries
import tflearn
from tflearn.layers.conv import conv_2d, max_pool_2d
from tflearn.layers.core import input_data, dropout, fully_connected
from tflearn.layers.estimator import regression
import tensorflow as tf
tf.reset_default_graph()
convnet = input_data(shape =[None, IMG_SIZE, IMG_SIZE, 1], name ='input')
convnet = conv_2d(convnet, 32, 5, activation ='relu')
convnet = max_pool_2d(convnet, 5)
convnet = conv_2d(convnet, 64, 5, activation ='relu')
convnet = max_pool_2d(convnet, 5)
convnet = conv_2d(convnet, 128, 5, activation ='relu')
convnet = max_pool_2d(convnet, 5)
convnet = conv_2d(convnet, 64, 5, activation ='relu')
convnet = max_pool_2d(convnet, 5)
convnet = conv_2d(convnet, 32, 5, activation ='relu')
convnet = max_pool_2d(convnet, 5)
convnet = fully_connected(convnet, 1024, activation ='relu')
convnet = dropout(convnet, 0.8)
convnet = fully_connected(convnet, 2, activation ='softmax')
convnet = regression(convnet, optimizer ='adam', learning_rate = LR,
loss ='categorical_crossentropy', name ='targets')
model = tflearn.DNN(convnet, tensorboard_dir ='log')
# Splitting the testing data and training data
train = train_data[:-500]
test = train_data[-500:]
'''Setting up the features and labels'''
# X-Features & Y-Labels
X = np.array([i[0] for i in train]).reshape(-1, IMG_SIZE, IMG_SIZE, 1)
Y = [i[1] for i in train]
test_x = np.array([i[0] for i in test]).reshape(-1, IMG_SIZE, IMG_SIZE, 1)
test_y = [i[1] for i in test]
'''Fitting the data into our model'''
# epoch = 5 taken
model.fit({'input': X}, {'targets': Y}, n_epoch = 5,
validation_set =({'input': test_x}, {'targets': test_y}),
snapshot_step = 500, show_metric = True, run_id = MODEL_NAME)
model.save(MODEL_NAME)
'''Testing the data'''
import matplotlib.pyplot as plt
# if you need to create the data:
# test_data = process_test_data()
# if you already have some saved:
test_data = np.load('test_data.npy')
fig = plt.figure()
for num, data in enumerate(test_data[:20]):
# cat: [1, 0]
# dog: [0, 1]
img_num = data[1]
img_data = data[0]
y = fig.add_subplot(4, 5, num + 1)
orig = img_data
data = img_data.reshape(IMG_SIZE, IMG_SIZE, 1)
# model_out = model.predict([data])[0]
model_out = model.predict([data])[0]
if np.argmax(model_out) == 1: str_label ='Dog'
else: str_label ='Cat'
y.imshow(orig, cmap ='gray')
plt.title(str_label)
y.axes.get_xaxis().set_visible(False)
y.axes.get_yaxis().set_visible(False)
plt.show()
La imagen de salida no será muy clara ya que toda la imagen se reduce a 50X50 para que una máquina procese rápido a través del compromiso entre velocidad y pérdida.
Y para acceder al tensorboard, use el siguiente comando en su cmd (usuario de Windows).
tensorboard --logdir=foo:C:\Users\knapseck\Desktop\Dev\Cov_Net\log
Producción:
Enlaces de referencia para principiantes en aprendizaje automático:
- Aprendizaje automático GeeksforGeeks
- Siraj Raval – Youtube
- Curso de aprendizaje automático de Andrew Ng en Coursera
- Aprendizaje automático: un enfoque probabilístico por Kevin Murphy
- Comunidad Reddit para Machine Learning.
Enlaces de referencia para CNN:
- Cuaderno Jupyter – Conv_Net
- Wikipedia – Redes Neuronales Convolucionales
- Curso Stanford – cs231n
Publicación traducida automáticamente
Artículo escrito por Subhajit Saha y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA