V1

README.md

@@ -1,8 +1,8 @@
 ---
-title: D2AS MasterIA
-emoji: 👁
-colorFrom: indigo
-colorTo: green
+title: MasterIA Unir
+emoji: 🦀
+colorFrom: pink
+colorTo: indigo
 sdk: gradio
 sdk_version: 3.40.1
 app_file: app.py

app.py

@@ -0,0 +1,362 @@
+""" 
+|Función para preprocesar una imagen antes de la predicción------------------------------------------
+|                                                                                         LIBRERIAS |
+|___________________________________________________________________________________________________| 
+"""
+
+# Machine Learning
+import tensorflow as tf  # TensorFlow para el aprendizaje automático
+from tensorflow.keras.models import load_model  # load_model de Keras para cargar modelos guardados
+from tensorflow.keras.preprocessing.image import img_to_array  #  img_to_array de Keras para convertir imágenes en arrays
+from tensorflow.keras.applications.mobilenet_v2 import preprocess_input  # preprocess_input de Keras para preprocesar imágenes
+ 
+# Procesamiento (imágenes y operaciones)
+import cv2  # OpenCV para el procesamiento de imágenes
+import numpy as np  # NumPy para manipulación de matrices y vectores
+import os  # Importa el módulo os para interactuar con el sistema operativo
+from revelado.revelado import calculate_ela, calculate_difference_image, apply_auto_contrast, equalize_histogram_color  #  funciones personalizadas del módulo revelado
+ 
+#Interfaz y aplicación web
+import gradio as gr  #  Biblioteca Gradio para crear la interfaz
+from gradio.outputs import Image  #  Clase Image de Gradio para mostrar imágenes en la interfaz
+from flask import Flask, redirect  # Flask y redirect de Flask para la aplicación web
+import threading  #Threading para ejecutar tareas en hilos separados
+from gradio import Interface
+import matplotlib.pyplot as plt
+from gradio.components import Image as GrImage, Label, Dropdown, Image as GrImageOut
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+from tensorflow.keras.applications.mobilenet import preprocess_input
+#Mapa de calor
+from PIL import Image
+import numpy as np
+from tf_keras_vis.gradcam import GradcamPlusPlus
+from tf_keras_vis.utils.model_modifiers import ReplaceToLinear
+from tf_keras_vis.utils import normalize
+ 
+#_______________________________________________
+# Importar la clase Flask de Flask para la aplicación web
+app = Flask(__name__)
+
+# Título y descripción de la interfaz
+title = "Master Inteligencia Artificial. EdenAIs."
+description = "Una aplicación para realizar predicciones sobre imágenes"
+
+# Cargar el modelo guardado
+model_clase_unica = load_model("model.h5")
+model_dos_clases = load_model("paper.h5")
+ 
+
+""" 
+|Función para preprocesar una imagen antes de la predicción------------------------------------------
+|                                                                                         FUNCIONES |
+|___________________________________________________________________________________________________| 
+"""
+ 
+
+  # Función para preprocesar una imagen antes de la predicción
+def preprocess_image(image):
+    """
+    Tipo de función: Preprocesamiento de imagen
+    Parámetros de entrada: image (objeto imagen)
+    Parámetros de salida: imagen_preprocesada (arreglo numpy)
+    Descripción: Convierte una imagen en un arreglo numpy, expande las dimensiones
+                 y aplica preprocesamiento necesario para el modelo.
+    """
+    # Convertir la imagen en un arreglo numpy
+    image_array = img_to_array(image)
+    
+    # Expandir las dimensiones del arreglo para que coincida con la entrada esperada por el modelo
+    image_array = np.expand_dims(image_array, axis=0)
+    
+    # Preprocesar la imagen
+    imagen_preprocesada = preprocess_input(image_array)
+    
+    return imagen_preprocesada
+
+
+""" 
+|Función para guardar la imagen original en la carpeta de entrada------------------------------------
+|                                                                                         FUNCIONES |
+|___________________________________________________________________________________________________| 
+"""
+
+def guardar_imagen_original(imagen, input_folder):
+    """
+    Tipo de función: Guardar imagen
+    Parámetros de entrada: imagen (objeto imagen), input_folder (ruta de la carpeta de entrada)
+    Parámetros de salida: Ninguno
+    Descripción: Guarda la imagen original en la carpeta de entrada con la máxima calidad.
+    """
+    # Obtener la extensión de archivo original de la imagen
+    filename = "original_image.jpg"
+    
+    # Guardar la imagen en la carpeta de entrada con la máxima calidad
+    cv2.imwrite(os.path.join(input_folder, filename), imagen, [cv2.IMWRITE_JPEG_QUALITY, 100])
+    
+
+""" 
+|Función para realizar predicciones sobre una imagenes-----------------------------------------------
+|                                                                                           FUNCION |
+|___________________________________________________________________________________________________| 
+"""
+#Función para crear el mapa de calor para una clase
+def generate_heatmap(original_image, processed_image, model):
+    # Convert the original image to the required format
+    original_image_color = Image.fromarray(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGBA)).resize((300, 300))
+    original_image_gray = original_image_color.convert("L").convert("RGBA")
+
+    # Prepare the processed image
+    processed_image_resized = cv2.resize(processed_image, (300, 300))
+    processed_image_preprocessed = preprocess_image(processed_image_resized)
+      # Define the scoring function for the detected class
+    def score_for_class(output):
+        return output[:, 0]  # Score for the detected class  
+    # Get the predicted probabilities
+    probabilities = model.predict(processed_image_preprocessed)[0]
+    percentage_class_1 = int(probabilities[0] * 100)
+    percentage_class_0 = 100 - percentage_class_1
+
+    # Create an instance of GradcamPlusPlus
+    
+    gradcam = GradcamPlusPlus(model, model_modifier=ReplaceToLinear(), clone=True)
+
+ 
+    # Get the Grad-CAM heatmap for the detected class
+ 
+    cam_class = gradcam(score_for_class, processed_image_preprocessed) # Use preprocessed image
+    cam_class = normalize(cam_class)
+
+    # Reduce the heatmap dimensionality to 2D and scale to 8-bit valueçs
+    cam_class = np.uint8(255 * np.squeeze(cam_class))
+
+    # Save the heatmap and load as an RGBA image
+    plt.imsave('temporal.png', cam_class)
+    cam_image = Image.open('temporal.png').convert("RGBA")
+   
+    # Superimpose the heatmap on the original grayscale image
+    superimposed_image_class = Image.blend(original_image_gray, cam_image, alpha=0.5)
+    # Tamaño final deseado
+    final_height, final_width = 300, 300
+    # Concatenate the original image, processed image, and heatmaps
+    # Redimensionar todas las imágenes a la misma altura
+    # Convertir la imagen PIL a una matriz NumPy
+    original_image_color_array = np.array(original_image_color)
+
+    if original_image_color_array.shape[2] == 4:
+        original_image_color_array = cv2.cvtColor(original_image_color_array, cv2.COLOR_RGBA2RGB)
+
+ 
+    processed_image_array = np.array(processed_image)
+ 
+    superimposed_image_class_array = np.array(superimposed_image_class)
+    if superimposed_image_class_array.shape[2] == 4:
+        superimposed_image_class_array = cv2.cvtColor(superimposed_image_class_array, cv2.COLOR_RGBA2RGB)
+
+    # Redimensionar todas las imágenes a las mismas dimensiones
+    original_image_color_resized = cv2.resize(original_image_color_array, (final_width, final_height))
+    processed_image_resized = cv2.resize(processed_image_array, (final_width, final_height))
+    superimposed_image_class_resized = cv2.resize(superimposed_image_class_array, (final_width, final_height))
+
+    # Concatenar las imágenes redimensionadas
+    final_image = np.hstack([original_image_color_resized, processed_image_resized, superimposed_image_class_resized])
+    # Verificar la imagen procesada
+    print("Processed Image Resized Shape:", processed_image_resized.shape)
+    # Verificar el modelo
+    print("Model Summary:", model.summary())
+
+    def score_for_class(output):
+        score = output[:, 0]  # Score for the detected class
+        print("Score Shape:", score.shape)
+        return score
+
+    # Return the final concatenated image
+    return final_image
+
+def cargar_y_preprocesar_imagen(imagen_path, target_size=(300, 300)):
+    # Crear una instancia de ImageDataGenerator con las mismas configuracion para el conjunto de entrenamiento
+    datagen =  ImageDataGenerator(rescale=1.0/255.)  
+    
+    # Cargar la imagen
+    img = load_img(imagen_path, target_size=target_size)
+
+    # Convertir la imagen a un array y expandimos las dimensiones para que pueda ser procesada por el ImageDataGenerator
+    img = img_to_array(img)
+    img = np.expand_dims(img, axis=0)
+
+    # Usar el ImageDataGenerator para procesar la imagen
+    img = datagen.flow(img, batch_size=1)
+
+    # El ImageDataGenerator retorna un generador, así que usamos next() para obtener la imagen procesada
+    img = next(img)
+
+    # Devolver la imagen procesada
+    return img[0] 
+#Generamos el mapa de calor para dos clases
+def generate_heatmap_2_classes(original_image, processed_image, model):
+    # Convertir la imagen original al formato requerido y redimensionar
+    # original_image_color = Image.fromarray(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGBA)).resize((300, 300))
+    original = Image.open("img.png").resize((300, 300)).convert("RGBA")
+    original_image_color = Image.open("img.png").resize((300, 300)).convert("RGBA")
+ 
+    # Leer la imagen procesada desde el archivo "img.png"
+    processed_image = cargar_y_preprocesar_imagen("img.png")
+    image = np.expand_dims(processed_image, axis=0)  # Añade una dimensión extra para el batch
+
+    # Obtén las probabilidades de pertenencia a cada clase
+    probabilities = model.predict(image)[0]
+ 
+    # Crear una instancia de GradcamPlusPlus
+    gradcam = GradcamPlusPlus(model, model_modifier=ReplaceToLinear(), clone=True)
+     # Obtén las probabilidades de pertenencia a cada clase
+    probabilities = model.predict(image)[0]
+    percentage_human = int(probabilities[0] * 100)
+    percentage_synthetic = int(probabilities[1] * 100)
+  
+    # Definir funciones de puntuación para ambas clases
+    def score_for_human(output):
+        return output[:, 0]  # Puntuación para la clase "humana"
+
+    def score_for_synthetic(output):
+        return output[:, 1]  # Puntuación para la clase "sintética"
+
+    # Obtén los mapas de calor de Grad-CAM para cada clase
+    cam_human = gradcam(score_for_human, image)
+    cam_human = normalize(cam_human)
+    cam_synthetic = gradcam(score_for_synthetic, image)
+    cam_synthetic = normalize(cam_synthetic)
+
+   # Reduce la dimensionalidad de los mapas de calor a 2D y escálalos a valores de 8 bits
+    cam_human = np.uint8(255 * np.squeeze(cam_human))
+    cam_synthetic = np.uint8(255 * np.squeeze(cam_synthetic))
+
+    images_combined = [original_image_color]
+    for cam in [cam_human, cam_synthetic]:
+        # Guardar el mapa de calor
+        plt.imsave('temporal.png', cam)
+
+        # Cargar el mapa de calor y convertirlo a RGBA
+        cam_image = Image.open('temporal.png').convert("RGBA")
+
+        # Superponer el mapa de calor a la imagen original
+        superimposed_image = Image.blend(original, cam_image, alpha=0.5)
+
+        # Guardar la imagen en la lista de imágenes a combinarse
+        images_combined.append(superimposed_image)
+
+    # Concatenar las imágenes y guardar la imagen final
+    final_image = Image.fromarray(np.hstack([np.array(im) for im in images_combined]))
+
+    return final_image
+
+def hacer_predicciones(modelo_seleccionado, imagen):
+    """
+    Tipo de función: Predicción
+    Parámetros de entrada: imagen (objeto imagen)
+    Parámetros de salida: diccionario de predicciones, imagen procesada (objeto imagen)
+    Descripción: Realiza predicciones sobre la imagen utilizando el modelo cargado.
+                 Devuelve un diccionario con las probabilidades de cada clase y la imagen procesada.
+    """
+    if modelo_seleccionado == "Modelo 1 Clase":
+        model = model_clase_unica
+    else:
+        model = model_dos_clases
+
+    print(modelo_seleccionado)
+ 
+    original_image = cv2.cvtColor(imagen, cv2.COLOR_RGB2BGR)
+
+    num = 1
+    difference_image = calculate_difference_image(imagen, num)
+    difference_image2 = apply_auto_contrast(difference_image)
+    cv2.imwrite("img.png", difference_image2)
+    processed_image = cv2.imread("img.png")
+    imagen_resized = cv2.resize(processed_image, (300, 300))
+    imagen_preprocesada = preprocess_image(imagen_resized)
+    
+    if modelo_seleccionado == "Modelo 1 Clase":
+        predicciones = model.predict(imagen_preprocesada).tolist()[0]
+        probabilidad_clase_1 = predicciones[0]
+        probabilidad_clase_0 = 1 - probabilidad_clase_1
+        final_image = generate_heatmap(original_image, processed_image, model)
+    else:
+        # Usar la función cargar_y_preprocesar_imagen para el preprocesamiento correcto
+        #processed_image_preprocessed = cargar_y_preprocesar_imagen("img.jpg")
+        gradcam = GradcamPlusPlus(model, model_modifier=ReplaceToLinear(), clone=True)
+        imagen_path = "img.png"
+        # Convertir la imagen PIL en una matriz NumPy
+        imagen = cargar_y_preprocesar_imagen(imagen_path)
+        image = np.expand_dims(imagen, axis=0)  # Añade una dimensión extra para el batch
+
+        probabilities = model.predict(image)[0]
+        print (probabilities)
+        probabilidad_clase_0 = int(probabilities[0] * 100)
+        probabilidad_clase_1 = int(probabilities[1] * 100)
+        predicted_label = np.argmax(probabilities)
+        print(predicted_label)
+        
+        def score_for_human(output):
+            return output[:, 0]
+
+        def score_for_synthetic(output):
+            return output[:, 1]
+         
+        gradcam = GradcamPlusPlus(model, model_modifier=ReplaceToLinear(), clone=True)
+        cams = [gradcam(score_func, image) for score_func in [score_for_human, score_for_synthetic]]
+        cams = [normalize(cam) for cam in cams]
+        cams = [np.uint8(255 * np.squeeze(cam)) for cam in cams]
+        # Convertir la imagen PIL a una matriz NumPy
+     
+ 
+        final_image = generate_heatmap_2_classes(original_image, image, model)
+
+    return {"Arte Manual": probabilidad_clase_0/100, "Arte Sintetico": probabilidad_clase_1/100}, final_image
+"""
+|Función para generar gradio en un hilo separado----------------------------------------------------
+|                                                                                         FUNCIONES |
+|___________________________________________________________________________________________________| 
+"""
+
+def run_gradio():
+    """
+    Tipo de función: Ejecución Gradio
+    Parámetros de entrada: Ninguno
+    Parámetros de salida: Ninguno
+    Descripción: Ejecuta la interfaz Gradio en un hilo separado.
+    """
+    output = iface.process([imagen])  # Ejecutar el procesamiento de la imagen
+    predicciones = output[0]
+    final_image = output[1]
+
+    # Guardar la imagen en una ubicación accesible
+    cv2.imwrite("output_img.jpg", final_image)
+#___________________________________________________________________________________________________
+
+# Crear una entrada de imagen en Gradio
+im = GrImage(shape=(None, None), image_mode='RGB', invert_colors=False, source="upload")
+model_selector = Dropdown(choices=["Modelo 1 Clase", "Modelo 2 Clases"], label="Selecciona un modelo")
+
+# Crear una interfaz de Gradio con una entrada de imagen
+iface = Interface(
+    fn=hacer_predicciones,
+    inputs=[model_selector, im],
+    outputs=[Label(), GrImageOut(type="numpy")],
+    title=title,
+    description=description,
+    allow_flagging="never"
+)
+
+# Lanzar la aplicación Gradio en un hilo separado
+threading.Thread(target=run_gradio).start()
+
+# Lanzar la interfaz Gradio
+iface.launch(share=False)
+
+# Definir la función de ruta en Flask
+@app.route('/')
+def index():
+    return redirect(iface.launch(share=True))
+
+# Ejecutar la aplicación Flask
+if __name__ == '__main__':
+    app.run()

model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b46ef335d599ad864fa38d1dc11bab6d46eff7b7ee9c15da9e550e0cf93d8fe8
+size 25106800

paper.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a5ac1775bca55bfda417b01475b931648d1feceb17c9da0087a27ecc9803e50
+size 49603640

requirements.txt

@@ -0,0 +1,10 @@
+Flask==2.2.5
+huggingface-hub==0.15.1
+keras==2.11.0
+opencv-python==4.8.0.74
+Pillow==9.3.0
+tensorflow==2.11.0
+transformers==4.30.2
+matplotlib
+numpy
+tf-keras-vis=0.8.5

revelado/revelado.py

@@ -0,0 +1,56 @@
+import os
+import cv2 as cv2
+import numpy as np
+from PIL import Image
+from io import BytesIO
+from pylab import *
+import re
+from PIL import Image, ImageChops, ImageEnhance
+
+def convert_to_ela_image(filename, quality=90):
+    im = Image.open(filename).convert('RGB')
+    resaved_im = im
+    ela_im = ImageChops.difference(im, resaved_im)
+    extrema = ela_im.getextrema()
+    max_diff = max([ex[1] for ex in extrema])
+    if max_diff == 0:
+        max_diff = 1
+    scale = 255.0 / max_diff
+    
+    ela_im = ImageEnhance.Brightness(ela_im).enhance(scale)
+    return ela_im
+def calculate_ela(original_image, quality=90):
+   
+    # Comprimir y descomprimir la imagen
+    buffer = BytesIO()
+    Image.fromarray(original_image).save(buffer, format="JPEG", quality=quality)
+    compressed_image = np.array(Image.open(buffer))
+
+    # Calcular la diferencia absoluta
+    ela_image = cv2.absdiff(original_image, compressed_image)
+
+    # Escalar las diferencias para mejorar la visibilidad
+    ela_image = cv2.normalize(ela_image, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)
+
+    return ela_image
+
+def calculate_difference_image(original_image, n):
+    
+    ela_image = calculate_ela(original_image)
+    auto_contrast_image = apply_auto_contrast(original_image)
+    difference_image = cv2.absdiff(original_image, auto_contrast_image)
+    difference_image = cv2.absdiff(difference_image, ela_image)
+    return difference_image
+
+def apply_auto_contrast(image, clip_limit=2.0, tile_grid_size=(8, 8)):
+    channels = cv2.split(image)
+    clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)
+    contrast_enhanced_channels = [clahe.apply(channel) for channel in channels]
+    contrast_enhanced_image = cv2.merge(contrast_enhanced_channels)
+    return contrast_enhanced_image
+
+def equalize_histogram_color(image):
+    channels = cv2.split(image)
+    equalized_channels = [cv2.equalizeHist(channel) for channel in channels]
+    equalized_image = cv2.merge(equalized_channels)
+    return equalized_image