Jonathan Quiza

Follow

May 11, 2018 · 4 min read

Mas Adelante mostrare un ejemplo en kaggle para clasificar imágenes de flores y esta devolverá una estimación de la categoría de imagen.

¿Qué es Inception-v3?

El modelo de aprendizaje profundo Ha sido desarrollado por Google.
Elegimos este modelo debido a su alto rendimiento de clasificación y porque está fácilmente disponible en TensorFlow.

1. ¿Qué son las redes neuronales convolucionales?

Las redes neuronales convolucionales son muy similares a las redes neuronales ordinarias como el perceptron multicapa que vimos en el artículo anterior, se componen de neuronas que tienen pesos y sesgos que pueden aprender. Cada neurona recibe algunas entradas, realiza un producto escalar y luego aplica una función de activación.

Al igual que en el perceptron multicapa también vamos a tener una función de pérdida o costo sobre la última capa, la cual estará totalmente conectada. Lo que diferencia a las redes neuronales convolucionales es que suponen explícitamente que las entradas son imágenes, lo que nos permite codificar ciertas propiedades en la arquitectura; permitiendo ganar en eficiencia y reducir la cantidad de parámetros en la red.

De esta forma las redes neuronales convolucionales son capaces de modelar complejas variaciones y comportamientos dando predicciones bastantes precisas.

2. Construyendo un clasificador CNN usando PySpark

Paso 2.1
Fuentes de Datos Kaggle

Ahora,usaremos el set de datos de aquí, que es una competencia, se le pide tomar imágenes de prueba y reconocer qué puntos de referencia
“Flowers Recognition”

Paso 2.2
Dataset

Ahora, tendremos que descargar las imágenes, como es un csv , se tendrá que crear un función para la descarga de las imágenes, por este lado uso “Google Cloud Dataproc” donde alojare las imágenes.
2.2.1.- train_csv lo puede obtener de aquí
2.2.2.- test_csv lo puedes obtener de aquí
2.2.3.- completo puedes obtener de aquí

Paso 2.3
Detalle de la clasificación

Ahora tendremos que tener las imágenes en una carpeta llamada: “flower_images”

Paso 2.4
Importación de librerias

from pyspark.ml.image import ImageSchema
from pyspark.sql import SparkSession
from pyspark.sql import functions as F
from pyspark.sql.types import *
from pyspark.ml.classification import LogisticRegression
from pyspark.ml import Pipeline
from sparkdl import DeepImageFeaturizer
import pandas as pd
from pyspark.sql import Row
spark = SparkSession.builder.appName('APP_CNN').getOrCreate()

Paso 2.5
Leyendo Imágenes

img_dir = “flower_images/”
flower_df_0 = ImageSchema.readImages(img_dir+ “/0/”).withColumn(“label”, F.lit(0))
flower_df_1 = ImageSchema.readImages(img_dir+ “/1/”).withColumn(“label”, F.lit(1))
flower_df_2 = ImageSchema.readImages(img_dir+ “/2/”).withColumn(“label”, F.lit(2))
flower_df_3 = ImageSchema.readImages(img_dir+ “/3/”).withColumn(“label”, F.lit(3))
flower_df_4 = ImageSchema.readImages(img_dir+ “/4/”).withColumn(“label”, F.lit(4))
flower_df_5 = ImageSchema.readImages(img_dir+ “/5/”).withColumn(“label”, F.lit(5))
flower_df_6 = ImageSchema.readImages(img_dir+ “/6/”).withColumn(“label”, F.lit(6))
flower_df_7 = ImageSchema.readImages(img_dir+ “/7/”).withColumn(“label”, F.lit(7))
flower_df_8 = ImageSchema.readImages(img_dir+ “/8/”).withColumn(“label”, F.lit(8))
flower_df_9 = ImageSchema.readImages(img_dir+ “/9/”).withColumn(“label”, F.lit(9))

Paso 2.6
Partición de los Datos

flower_train_0, flower_test_0 = flower_df_0.randomSplit([0.6, 0.4])
flower_train_1, flower_test_1 = flower_df_1.randomSplit([0.6, 0.4])
flower_train_2, flower_test_2 = flower_df_2.randomSplit([0.6, 0.4])
flower_train_3, flower_test_3 = flower_df_3.randomSplit([0.6, 0.4])
flower_train_4, flower_test_4 = flower_df_4.randomSplit([0.6, 0.4])
flower_train_5, flower_test_5 = flower_df_5.randomSplit([0.6, 0.4])
flower_train_6, flower_test_6 = flower_df_6.randomSplit([0.6, 0.4])
flower_train_7, flower_test_7 = flower_df_7.randomSplit([0.6, 0.4])
flower_train_8, flower_test_8 = flower_df_8.randomSplit([0.6, 0.4])
flower_train_9, flower_test_9 = flower_df_9.randomSplit([0.6, 0.4])

Paso 2.7
Unión de los Datos estamos concadenado el dataframe hacia abajo de todas las
imágenes.

train_df = flower_train_0.union(flower_train_1)
train_df = train_df.union(flower_train_2)
train_df = train_df.union(flower_train_3)
train_df = train_df.union(flower_train_4)
train_df = train_df.union(flower_train_5)
train_df = train_df.union(flower_train_6)
train_df = train_df.union(flower_train_7)
train_df = train_df.union(flower_train_8)
train_df = train_df.union(flower_train_9)test_df = flower_test_0.union(flower_test_1)
test_df = test_df.union(flower_test_2)
test_df = test_df.union(flower_test_3)
test_df = test_df.union(flower_test_4)
test_df = test_df.union(flower_test_5)
test_df = test_df.union(flower_test_6)
test_df = test_df.union(flower_test_7)
test_df = test_df.union(flower_test_8)
test_df = test_df.union(flower_test_9)

Paso 2.8
Usando DeepImageFeaturizer con Tensorflow con el modelo de InceptionV3

featurizer = DeepImageFeaturizer(inputCol="image", outputCol="features", modelName="InceptionV3")
lr = LogisticRegression(maxIter=25, regParam=0.05, elasticNetParam=0.3, labelCol="label")
p = Pipeline(stages=[featurizer, lr])
p_model = p.fit(train_df)
df2 = p_model.transform(test_df)

Paso 2.9
visualizando resultados

df_p = df2.select(“features”,”rawPrediction”,”prediction”, “label”)
df_p1 = df_p.toPandas()

Paso 2.10
Evaluación del Modelo

evaluator = MulticlassClassificationEvaluator(metricName=”accuracy”)
print(“Training set accuracy = “ + str(evaluator.evaluate(predictionAndLabels)))

Conclusiones resulto un modelo regular pero todavía , se hacer tunning del modelo con una validación cruzada a la red con la ayuda de TFImageTransformer.
Pero esto ya lo veremos en otra red con spark RestNet50 para un siguiente ejemplo.

Introducir esto tipo de modelos como las redes convolucionales, han tenido un impacto directo en la industria tecnológica y sus aplicaciones van desde detección de Imágenes, reconocimiento del audio, vehículos autónomos y un largo número de aplicaciones.

Espero le hayas gustado esta publicación sobre redes neuronales con PySpark CNN InceptionV3 de tensorflow

linkedin: