Update app.py

app.py

@@ -1,47 +1,47 @@
 import gradio as gr
-from transformers import AutoModel, AutoFeatureExtractor, AutoConfig
 import torch
+from torchvision import models, transforms
 from PIL import Image
+import json
 
-# Carga el modelo y el extractor de características
-model_name = "CarPeAs/reconocimiento-facial"
+# Cargar la configuración
+with open("reconocimiento_facial/config.json") as f:
+    config = json.load(f)
 
-# Intentar cargar la configuración del modelo primero
-config = AutoConfig.from_pretrained(model_name)
+# Definir las etiquetas de las clases
+class_labels = ["Angry", "Disgust", "Fear", "Happy", "Sad", "Surprise", "Neutral"]
 
-# Imprimir la configuración del modelo para verificar su contenido
-print(config)
+# Crear el modelo y ajustar la última capa
+model = models.resnet50()
+model.fc = torch.nn.Linear(model.fc.in_features, len(class_labels))  # len(class_labels) = 7
 
-# Usar la clase correcta basada en la configuración del modelo
-if config.model_type in ['vit', 'beit', 'deit', 'resnet', 'convnext', 'swin']:
-    model = AutoModelForImageClassification.from_pretrained(model_name)
-else:
-    model = AutoModel.from_pretrained(model_name)
+# Cargar los pesos del modelo
+model.load_state_dict(torch.load("reconocimiento_facial/pytorch_model.bin"))
+model.eval()
 
-feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
+# Preprocesamiento de imágenes
+transform = transforms.Compose([
+    transforms.Resize((config["image_size"], config["image_size"])),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=config["transformations"]["Normalize"]["mean"], std=config["transformations"]["Normalize"]["std"])
+])
 
-# Función de inferencia
-def reconocer_emocion(image):
-    # Convierte la imagen a tensor
-    inputs = feature_extractor(images=image, return_tensors="pt")
+def predict(image):
+    image = transform(image).unsqueeze(0)
     with torch.no_grad():
-        outputs = model(**inputs)
-    # Asumiendo que las emociones están en las etiquetas de salida del modelo
-    logits = outputs.logits
-    emotion = torch.argmax(logits, dim=-1).item()
-    emociones = ["Feliz", "Triste", "Enojado", "Sorprendido", "Neutral"]
-    return emociones[emotion]
-
-# Interfaz de Gradio
+        output = model(image)
+        _, predicted = torch.max(output, 1)
+        predicted_class = class_labels[predicted.item()]
+    return predicted_class
+
+# Crear la interfaz de Gradio
 iface = gr.Interface(
-    fn=reconocer_emocion,
-    inputs=gr.inputs.Image(type="pil"),
-    outputs=gr.outputs.Textbox(label="Emoción Reconocida"),
-    title="Reconocimiento Facial de Emociones",
-    description="Carga una imagen y el modelo reconocerá la emoción expresada en el rostro."
+    fn=predict,
+    inputs=gr.Image(type="pil"),
+    outputs=gr.Textbox(label="Predicted Expression"),
+    title="Reconocimiento Facial de Expresiones",
+    description="Sube una imagen de una cara para clasificar la expresión facial en una de las siete categorías: Enfadado, Disgustado, Miedo, Feliz, Triste, Sorprendido y Neutral."
 )
 
-# Ejecuta la aplicación
-if __name__ == "__main__":
-    iface.launch()
-
+# Ejecutar la interfaz
+iface.launch()