DC

About
Blog

Peritaje autom�tico de veh�culos con Redes Convolucionales (Mask R-CNN)

Inicio / Peritaje autom�tico de veh�culos con Redes Convolucionales (Mask R-

CNN)

Peritaje autom�tico de veh�culos con Redes Convolucionales (Mask R-CNN)

David Cerezal Landa

5 minutos de lectura

Una red neuronal convolucional (Convolutional Neural Networks en ingl�s, con los
acr�nimos CNNs o ConvNets) es un caso concreto de redes neuronales Deep Learning,
estas han tenido un auge exponencial recientemente dado sus excelentes resultados,
pero ya se conocen desde los a�os 90.

Para hacernos una idea intuitiva de c�mo funcionan estas redes neuronales, pensemos
en c�mo nosotros reconocemos las cosas. Por ejemplo, si vemos una cara, la
reconocemos porque tiene orejas, ojos, una nariz, cabello, etc. Entonces vamos
asimilando en nuestra cabeza qu� rasgos cumple y asignamos una probabilidad de que
sea una cara. Por ejemplo, si vemos una posible cara de noche, pero la mitad de
ella esta oscura puede que dudemos al decidir mentalmente si se trata de una
persona o no, dado que no vemos claramente los rasgos suficientes de una cara. Las
redes convolucionales hacen algo similar, dar una posibilidad de que el objeto que
buscamos sea el que ve en la imagen.
Inicio - Mask R-CNN

El objetivo de este post es construir un modelo CNN con m�scaras de regi�n (Mask R-
CNN) que pueda detectar el �rea de da�o en un autom�vil. El problema de una red CNN
es que puede encontrar miles de objetos y regiones, para paliar este problema se
crearon las R-CNN. En R-CNN, la CNN est� obligada a enfocarse en una sola regi�n,
porque de esa manera se minimiza la interferencia de otros objetos. Las regiones en
el R-CNN se detectan mediante un algoritmo de b�squeda selectiva seguido de cambio
de tama�o, de modo que las regiones tengan el mismo tama�o antes de que se env�en a
un CNN para la clasificaci�n y la regresi�n del cuadro delimitador. Es decir, una
R-CNN busca en n-regiones y se enfoca en encontrar el objeto-target, de ah� que nos
sirva de manera id�nea para este caso. Por ejemplo, los primeros casos de uso de
estas redes R-CNN son en la conducci�n aut�noma, ya que sirven de manera
espectacular para la detecci�n de coches en una carretera; procesar� diferentes
regiones en busca de los n-coches de la imagen.

</br></br>
Inicio - C�mo crear una R-CNN

Una buena forma de imaginar una R-CNN es por medio de la combinaci�n de una faster-
R-CNN y una Fully Conected CNN. La primera Faster R-CNN, buscar� las regi�n en la
cual cree que esta el objeto, y la clase de estas, la Fully conected CNN,
encontrar� el objeto en esa regi�n.

</br></br>

En el siguiente ejemplo, podemos ver claramente como en el primero paso, la Faster

R-CNN nos devuelve la regi�n en la que se encuentra el jugador principal, con su
respectiva etiqueta de clasificaci�n, y en el siguiente paso la Fully Conected CNN
encontrar� este objeto.

</br></br>

Para crear una m�scara R-CNN personalizada, aprovecharemos el repositorio

Matterport Github. El �ltimo repositorio de TensorFlow Object Detection tambi�n
ofrece la opci�n de crear Mask R-CNN, pero se recomienda utilizar esta librer�a ya
que sino te encontrar�s con muchos problemas que algui�n ya se revolvi� en
resolver.
Recopilaci�n del Data-set

Se utilizar�n 60 im�genes de coches da�ados obtenidos de google. Estas im�genes se

necesita que tengan el �rea del da�o perimetrada, para ello se crear� un Dataset
con estos datos ya espec�ficados.

</br></br>
Train del modelo

Primero traemos las librer�as necesarias para entrenar este modelo antes citadas y
definimos tambi�n los directorios de los pesos ya entrenamos de COCO. Esta es un
dataset de todo tipo de im�genes las cuales han sido entrenadas, y tenemos los
pesos de ese entrenamiento. Esto nos servir� de punto de partida para entrenar el
modelo usando el transfer learning.

import os
import sys
import json
import datetime
import numpy as np
import skimage.draw
import cv2
from mrcnn.visualize import display_instances
import matplotlib.pyplot as plt

from mrcnn.config import Config

from mrcnn import model as modellib, utils

# Path to trained weights file

COCO_WEIGHTS_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")

En la siguiente funci�n importaremos el dataset. Se trabaja con la b�squeda del

objeto "damage", para ello se a�aden cierta metadata a cada imagen para que luego
la librer�a pueda trabajar con ella. Es el caso, de esta clase damage, o los
atributos de Width y height del shape.

def load_custom(self, dataset_dir, subset):

# Add classes. We have only one class to add.
self.add_class("damage", 1, "damage")

# Train or validation dataset?

assert subset in ["train", "val"]
dataset_dir = os.path.join(dataset_dir, subset)

# We mostly care about the x and y coordinates of each region

annotations1 = json.load(open(os.path.join(dataset_dir,
"via_region_data.json")))
# print(annotations1)
annotations = list(annotations1.values()) # don't need the dict keys
 annotations = [a for a in annotations if a['regions']]

# Add images
for a in annotations:
polygons = [r['shape_attributes'] for r in a['regions'].values()]

image_path = os.path.join(dataset_dir, a['filename'])

image = skimage.io.imread(image_path)
height, width = image.shape[:2]

self.add_image(
"damage", ## for a single class just add the name here
image_id=a['filename'], # use file name as a unique image id
path=image_path,
width=width, height=height,
polygons=polygons)

Funci�n de creaci�n de una m�scara pasada una imagen, crear� una m�scara con las
caracter�sticas de alto x ancho que le pasemos, lo devolver� en el formato
adecuado.

def load_mask(self, image_id):

image_info = self.image_info[image_id]
if image_info["source"] != "damage":
return super(self.__class__, self).load_mask(image_id)

info = self.image_info[image_id]
mask = np.zeros([info["height"], info["width"], len(info["polygons"])],
dtype=np.uint8)
for i, p in enumerate(info["polygons"]):
# Get indexes of pixels inside the polygon and set them to 1
rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'])
mask[rr, cc, i] = 1

return mask.astype(np.bool), np.ones([mask.shape[-1]], dtype=np.int32)

Para la posterior visualizaci�n del los objetos detectados crearemos una funci�n
que se encargar� de pintar la regi�n que ha encontrado en la imagen en cuesti�n.

def color_splash(image, mask):

gray = skimage.color.gray2rgb(skimage.color.rgb2gray(image)) * 255
# We're treating all instances as one, so collapse the mask into one layer
mask = (np.sum(mask, -1, keepdims=True) >= 1)

if mask.shape[0] > 0:
splash = np.where(mask, image, gray).astype(np.uint8)
else:
splash = gray
return splash

Este ser� la funci�n train del modelo, como ya viene pre-entrenada con los pesos de
COCO no ser� necesario entrenarla mucho, lo haremos s�lo con 10 veces.

def train(model):
# Training dataset.
dataset_train = CustomDataset()
dataset_train.load_custom(args.dataset, "train")
dataset_train.prepare()
 # Validation dataset
dataset_val = CustomDataset()
dataset_val.load_custom(args.dataset, "val")
dataset_val.prepare()
model.train(dataset_train, dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=10,
layers='heads')

Train principal

Crearemos primero un modelo de MaskRCNN provisto por la librer�a de Matterport.

En este caso cargaremos los pesos pre-entrenados de la librer�a de COCO.
Primero entrenaremos el modelo
A posteriori podemos pasarle una imagen y ver el resultado con la funci�n de
detect_and_color_splash

# Create model
if args.command == "train":
model = modellib.MaskRCNN(mode="training", config=config,
model_dir=args.logs)
else:
model = modellib.MaskRCNN(mode="inference", config=config,
model_dir=args.logs)

weights_path = COCO_WEIGHTS_PATH

if args.weights.lower() == "coco":
# Exclude the last layers because they require a matching
# number of classes
model.load_weights(weights_path, by_name=True, exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc",
"mrcnn_bbox", "mrcnn_mask"])
else:
model.load_weights(weights_path, by_name=True)

if args.command == "train":
train(model)
elif args.command == "splash":
detect_and_color_splash(model, image_path=args.image,
video_path=args.video)

Para entrenar este modelo, y hacer lo que hemos citado en los pasos anterior
ejecutaremos el siguiente comando:

## Train a new model starting from pre-trained COCO weights

python3 custom.py train --dataset=/path/to/datasetfolder --weights=coco

Al acabar podemos obtener predicciones de este tipo

Mask-RCNN es la siguiente evoluci�n de los modelos de detecci�n de objetos ya que

permiten la detecci�n con mejor precisi�n.

Referencias

1.- Las explicaciones se han obtenido de analitics vidhya

2.- El c�digo de priya-dwivedi github

David Cerezal Landa
David Cerezal Landa

Admin del Mono al ordenador. Me fuerzo a escribir porque mi mente es demasiado

volatil.

Etiquetas: CNN Mask R-CNN Peritaje de coches Python

Actualizado: June 15, 2019

Compartir
Anterior
Siguiente
Comentar
Podr�as ver tambi�n
Plantilla �rbol geneal�gico

David Cerezal Landa

menos de 1 minutos de lectura

Esta �ltima semana he estado creando un peque�o proyecto para el cumplea�os de mi

padre, se trata de un �rbol geneal�gico. Como he visto que por la red no ci...
Predictor de precios de mercado - General Motors - Parte III

David Cerezal Landa

menos de 1 minutos de lectura

Como hemos comentado en los posts anteriores, en este set de diferentes notebooks
trataremos de hacer un an�lisis de la serie temporal de lo...
Predictor de precios de mercado - General Motors - Parte II

David Cerezal Landa

menos de 1 minutos de lectura

Como hemos comentado en los posts anteriores, en este set de diferentes notebooks
trataremos de hacer un an�lisis de la serie temporal de lo...
Predictor de precios de mercado - General Motors - Parte I

David Cerezal Landa

menos de 1 minutos de lectura

Desde hace tiempo los economistas han estudiado e intentado comprender los
movimientos de los precios en la bolsa de valores, debido a que l...

Seguir:

Twitter Linkedin GitHub Flickr

Feed

� 2020 Del Mono al Ordenador. Powered by Jekyll & Minimal Mistakes.