Clasificador-superficial_PERROSyGATOS_FULL

Esta es una vista previa del archivo. Inicie sesión para ver el archivo original

# -*- coding: utf-8 -*-
"""
"Clasificador de perros y gatos CON RED NEURONAL SECUENCIAL"
Alumno:Eduardo Antonio Rodriguez Guerra
"""
#Importamos librerias 
import tensorflow as tf
#para importar y trabajar el datset
from keras.preprocessing.image import ImageDataGenerator
#Para ingresar en forma de arreglo todas las iamgenes del entrenamiento en una sola variable
import numpy as np
from keras.preprocessing import image
#libreria para imprimir la imagen, ademas de elaborar un test luego del entrenamiento
import matplotlib.pyplot as plt
#Preparamos los datos para entrenaiento 
entrenamiento_formato = ImageDataGenerator(rescale = 1./255,#Teniendo 0-255 mapeamos como 0-1
 shear_range = 0.2,
 zoom_range = 0.2,#Imagen de tamano cuadrado
 horizontal_flip = True)
prueba_formato = ImageDataGenerator(rescale = 1./255)#Teniendo 0-255 mapeamos como 0-1
SET_ENTRENAMIENTO = entrenamiento_formato.flow_from_directory(r'C:\Users\DELL 7280\Documents\LALO TEC LAGUNA\NOVENO SEMESTRE\Inteligencia artificial\Perros y GATOS\Datos entrenamiento',
 target_size = (100, 100),
 batch_size = 32,
 class_mode = 'binary')
#direccion de las imagenes, cada carpeta es un grupo semantico, n este caso esa carpeta tiene otras 2 carpeta en las que se clasifican imaenes, perros o gatos
#tamano de la imagen 100 pixeles por 100 pixeles
#Imagenes por grupito para entrenamiento entre menor sea el numero el entrenamiento sera mejor
#binario., ya que la claificacion solo tendra dos posibles categorias
SET_PRUEBA= prueba_formato.flow_from_directory(r'C:\Users\DELL 7280\Documents\LALO TEC LAGUNA\NOVENO SEMESTRE\Inteligencia artificial\Perros y GATOS\Datos entrenamiento',
 target_size = (100, 100),
 batch_size = 32,
 class_mode = 'binary')
#Construccion de la arquitectura
modeloDenso = tf.keras.models.Sequential([
 tf.keras.layers.Flatten(input_shape=(100, 100, 3)),#input_shape=(100, 100, 1)
 tf.keras.layers.Dense(233, activation='relu'),
 tf.keras.layers.Dense(233, activation='relu'),
 tf.keras.layers.Dense(233, activation='relu'),
 tf.keras.layers.Dense(1, activation='sigmoid')
])
"""
La primera capa de esta red, tf.keras.layers.Flatten, transforma el formato de las imagenes de un arreglo bi-dimensional 
(de 28 por 28 pixeles) a un arreglo uni dimensional (de 28*28 pixeles = 784 pixeles). Observe esta capa como una capa no apilada 
de filas de pixeles en la misma imagen y alineandolo. Esta capa no tiene parametros que aprender; solo reformatea el set de datos.
"""
#Compilar modelos. Usar crossentropy binario ya que tenemos solo 2 opciones (perro o gato)
modeloDenso.compile(optimizer='adam',
 loss='binary_crossentropy',
 metrics=['accuracy'])
#Preparamos los parametros del entrenamiento
modeloDenso.fit(SET_ENTRENAMIENTO,
 steps_per_epoch = 602/32,#NUMERO TOTAL DE DATOS/IMAGENES DE CADA GRUPITO
 epochs = 350,
 validation_data = SET_PRUEBA,
 validation_steps = 10)#callbacks=[tensorboardDenso]
#Probamos y estimamos la efectividad
sample_training_images, _ = next(SET_PRUEBA)
result = modeloDenso.predict(sample_training_images)
#print(result)
prediction = np.where(result >= 0.15, 'dog', 'cat') #Consideramos umbral de 0.23
#Imprimimos el numero total de muestras con su respectiva prediccion, para modificar el tamano 
#acudir al .subplots
def plotImages(images_arr):
 fig, axes = plt.subplots(5, 7, figsize=(30,30))
 axes = axes.flatten()
 for i, (img, ax) in enumerate(zip( images_arr, axes)):
 ax.imshow(img)#, cmap="gray"
 #ax.axis('off')
 ax.set_xlabel(prediction[i],fontsize=60)
 plt.tight_layout()
 plt.show()
 
plotImages(sample_training_images[0:34])
_, accuracy = modeloDenso.evaluate(SET_PRUEBA)
print('Accuracy: %.2f' % (accuracy*100))
from tensorflow.keras.models import save_model
#Guardamos en formato.h5, toda la informacion dentro de la variable modelo en este caso la estructura y los pesos de la red neuronal, luego del entremiento ideal para guardar buenos resultados
save_model(modeloDenso, "Clasificador_secuencial_cats_dogs.h5")
"""
____________________________________________________________________________________
Arquitectura convolucional
"""
#Crear los modelos iniciales
#Usan sigmoid como salida (en lugar de softmax) para mostrar como podria funcionar con dicha funcion de activacion.
#Sigmoid regresa siempre datos entre 0 y 1. Realizamos el entrenamiento para al final considerar que si la respuesta se
#acerca a 0, es un gato, y si se acerca a 1, es un perro.
modeloCNN = tf.keras.models.Sequential([
 tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(100, 100, 3)),
 tf.keras.layers.MaxPooling2D(2, 2),
 tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
 tf.keras.layers.MaxPooling2D(2, 2),
 tf.keras.layers.Conv2D(128, (3,3), activation='relu'),
 tf.keras.layers.MaxPooling2D(2, 2),
 tf.keras.layers.Dropout(0.5),
 tf.keras.layers.Flatten(),
 tf.keras.layers.Dense(250, activation='relu'),
 tf.keras.layers.Dense(1, activation='sigmoid')
])
modeloCNN.compile(optimizer='adam',
 loss='binary_crossentropy',
 metrics=['accuracy'])
modeloCNN.fit(SET_ENTRENAMIENTO,
 steps_per_epoch = 602/32,#NUMERO TOTAL DE DATOS/IMAGENES DE CADA GRUPITO
 epochs = 30,
 validation_data = SET_PRUEBA,
 validation_steps = 10)
#Probamos y estimamos la efectividad
sample_training_images, _ = next(SET_PRUEBA)
result = modeloCNN.predict(sample_training_images)
#print(result)
prediction = np.where(result >= 0.35, 'dog', 'cat') 
#Imprimimos el numero total de muestras con su respectiva prediccion, para modificar el tamano 
#acudir al .subplots
def plotImages(images_arr):
 fig, axes = plt.subplots(5, 7, figsize=(30,30))
 axes = axes.flatten()
 for i, (img, ax) in enumerate(zip( images_arr, axes)):
 ax.imshow(img)#, cmap="gray"
 #ax.axis('off')
 ax.set_xlabel(prediction[i],fontsize=60)
 plt.tight_layout()
 plt.show()
 
plotImages(sample_training_images[0:34])
_, accuracy = modeloCNN.evaluate(SET_PRUEBA)
print('Accuracy: %.2f' % (accuracy*100))
from tensorflow.keras.models import save_model
#Guardamos en formato.h5, toda la informacion dentro de la variable modelo en este caso la estructura y los pesos de la red neuronal, luego del entremiento ideal para guardar buenos resultados
save_model(modeloCNN, "Clasificador_CONVOLUCIONAL_cats_dogs.h5")