proyecto.py

import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.preprocessing.image import img_to_array, load_img
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping
from sklearn.decomposition import PCA
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, f1_score, confusion_matrix, classification_report
import os
import matplotlib.pyplot as plt
import seaborn as sns
import tkinter as tk
from tkinter import filedialog

# --- CONFIGURACION ---
BASE_DIR = 'Synthetic_DB_CAS'  # Nombre corregido de la DB
CLASSES = ['confused', 'distracted', 'fatigued', 'joyful', 'neutral']
NUM_CLASSES = len(CLASSES)

# Rutas a los splits
TRAIN_DIR = os.path.join(BASE_DIR, 'train')
VAL_DIR = os.path.join(BASE_DIR, 'val')
TEST_DIR = os.path.join(BASE_DIR, 'test')

# --- FUNCIONES DE PREPROCESAMIENTO ---

def preprocess_fisherfaces(img_array):
    """Escala de grises, 100x100, estandarizacion."""
    # Estandarizar (media 0, varianza 1)
    standardized_img = (img_array - np.mean(img_array)) / (np.std(img_array) + 1e-6)
    return standardized_img.flatten()

def preprocess_mobilenet(img_array):
    """Normalizacion para MobileNet [0, 1]."""
    return img_array / 255.0

# --- CARGA DE DATOS ---

def load_images_from_directory(directory, target_size, is_rgb, model_type):
    """Carga imagenes recorriendo las subcarpetas de clases."""
    X = []
    y = []
    
    label_map = {cls: i for i, cls in enumerate(CLASSES)}
    
    print(f"Cargando datos desde: {directory} ({model_type})")
    
    if not os.path.exists(directory):
        print(f"ERROR: La carpeta {directory} no existe.")
        return np.array([]), np.array([])

    for class_name in CLASSES:
        class_path = os.path.join(directory, class_name)
        if not os.path.isdir(class_path):
            continue
            
        label_index = label_map[class_name]
        files_list = os.listdir(class_path)
        
        for filename in files_list:
            img_path = os.path.join(class_path, filename)
            try:
                color_mode = 'rgb' if is_rgb else 'grayscale'
                img = load_img(img_path, color_mode=color_mode, target_size=target_size)
                img_array = img_to_array(img)
                
                if model_type == 'mobilenet':
                    processed = preprocess_mobilenet(img_array)
                else: # fisherfaces
                    img_np = np.squeeze(img_array) 
                    processed = preprocess_fisherfaces(img_np)
                
                X.append(processed)
                y.append(label_index)
            except Exception as e:
                pass 
                
    return np.array(X), np.array(y)

# --- VISUALIZACION ---

def plot_history(history, model_name):
    """Grafica curvas de Accuracy y Loss."""
    acc = history.history['accuracy']
    val_acc = history.history['val_accuracy']
    loss = history.history['loss']
    val_loss = history.history['val_loss']
    epochs_range = range(len(acc))

    plt.figure(figsize=(12, 5))
    plt.subplot(1, 2, 1)
    plt.plot(epochs_range, acc, label='Training Accuracy')
    plt.plot(epochs_range, val_acc, label='Validation Accuracy')
    plt.legend(loc='lower right')
    plt.title(f'{model_name} - Accuracy')
    plt.grid(True)

    plt.subplot(1, 2, 2)
    plt.plot(epochs_range, loss, label='Training Loss')
    plt.plot(epochs_range, val_loss, label='Validation Loss')
    plt.legend(loc='upper right')
    plt.title(f'{model_name} - Loss')
    plt.grid(True)
    plt.show()

def plot_confusion_matrix_custom(y_true, y_pred, title):
    """Genera la Matriz de Confusion visual."""
    cm = confusion_matrix(y_true, y_pred)
    plt.figure(figsize=(8, 6))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
                xticklabels=CLASSES, yticklabels=CLASSES)
    plt.xlabel('Prediccion')
    plt.ylabel('Verdad (Ground Truth)')
    plt.title(f'Matriz de Confusion: {title}')
    plt.show()

# =============================================================================
# BLOQUE 1: ENTRENAMIENTO MOBILENET (Deep Learning)
# =============================================================================
print("\n=== INICIANDO MODELO MOBILENET (RGB 224x224) ===")

X_train_mb, y_train_mb = load_images_from_directory(TRAIN_DIR, (224, 224), True, 'mobilenet')
X_val_mb, y_val_mb = load_images_from_directory(VAL_DIR, (224, 224), True, 'mobilenet')
X_test_mb, y_test_mb = load_images_from_directory(TEST_DIR, (224, 224), True, 'mobilenet')

model_mb = None 

if len(X_train_mb) > 0:
    y_train_cat = tf.keras.utils.to_categorical(y_train_mb, NUM_CLASSES)
    y_val_cat = tf.keras.utils.to_categorical(y_val_mb, NUM_CLASSES)

    base_model = MobileNetV2(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
    base_model.trainable = False
    
    x = base_model.output
    x = GlobalAveragePooling2D()(x)
    x = Dense(128, activation='relu')(x)
    predictions = Dense(NUM_CLASSES, activation='softmax')(x)
    
    model_mb = Model(inputs=base_model.input, outputs=predictions)
    
    print("Entrenando MobileNet (Capas superiores)...")
    model_mb.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    
    history_mb = model_mb.fit(
        X_train_mb, y_train_cat,
        epochs=10,
        validation_data=(X_val_mb, y_val_cat),
        verbose=1
    )

    plot_history(history_mb, 'MobileNetV2')
    
    print("\n--- Evaluacion MobileNet en Test Set ---")
    y_pred_probs = model_mb.predict(X_test_mb)
    y_pred_mb = np.argmax(y_pred_probs, axis=1)
    
    print("Accuracy:", accuracy_score(y_test_mb, y_pred_mb))
    print(classification_report(y_test_mb, y_pred_mb, target_names=CLASSES))
    plot_confusion_matrix_custom(y_test_mb, y_pred_mb, 'MobileNetV2')
else:
    print("No se encontraron datos de entrenamiento para MobileNet.")

# =============================================================================
# BLOQUE 2: ENTRENAMIENTO FISHERFACES (PCA + LDA)
# =============================================================================
print("\n=== INICIANDO MODELO FISHERFACES (Grayscale 100x100) ===")

X_train_ff, y_train_ff = load_images_from_directory(TRAIN_DIR, (100, 100), False, 'fisherfaces')
X_test_ff, y_test_ff = load_images_from_directory(TEST_DIR, (100, 100), False, 'fisherfaces')

if len(X_train_ff) > 0:
    print(f"Dimensiones Fisherfaces Train: {X_train_ff.shape}")
    
    n_components_pca = min(150, X_train_ff.shape[0] - 1)
    
    fisher_pipeline = Pipeline([
        ('pca', PCA(n_components=n_components_pca, whiten=True)),
        ('lda', LDA(n_components=NUM_CLASSES - 1)),
        ('clf', SVC(kernel='linear', class_weight='balanced'))
    ])
    
    print("Entrenando Fisherfaces...")
    fisher_pipeline.fit(X_train_ff, y_train_ff)
    
    print("\n--- Evaluacion Fisherfaces en Test Set ---")
    y_pred_ff = fisher_pipeline.predict(X_test_ff)
    
    print("Accuracy:", accuracy_score(y_test_ff, y_pred_ff))
    print(classification_report(y_test_ff, y_pred_ff, target_names=CLASSES))
    plot_confusion_matrix_custom(y_test_ff, y_pred_ff, 'Fisherfaces (PCA+LDA)')
else:
    print("No se encontraron datos para Fisherfaces.")

# =============================================================================
# BLOQUE 3: VALIDACION CON VIDEOS REALES (SELECCION LOCAL)
# =============================================================================
print("\n" + "="*60)
print("=== FASE 2: VALIDACION CON VIDEOS REALES ===")
print("="*60)

FPS_TARGET = 1  # 1 frame por segundo

if model_mb is not None:
    print("\nINSTRUCCIONES:")
    print("1. Se abrira una ventana de explorador de archivos.")
    print("2. Selecciona TODOS los videos que quieras probar.")
    print("3. Luego, el programa te pedira la etiqueta real para cada uno.")
    print("-" * 60)
    
    # Abrir ventana de seleccion de archivos (Tkinter)
    root = tk.Tk()
    root.withdraw() # Ocultar la ventana principal de Tkinter
    root.attributes('-topmost', True) # Asegurar que la ventana salga al frente
    print("Esperando seleccion de archivos...")
    
    file_paths = filedialog.askopenfilenames(
        title='Selecciona tus videos de prueba',
        filetypes=[("Archivos de video", "*.mp4 *.avi *.mov *.mkv *.webm")]
    )
    
    if not file_paths:
        print("No se seleccionaron archivos. Finalizando.")
    else:
        print(f"Se seleccionaron {len(file_paths)} videos.")

        # Iterar sobre los videos seleccionados
        for video_path in file_paths:
            video_filename = os.path.basename(video_path)
            print(f"\nProcesando archivo: {video_filename}")
            
            # --- PREGUNTA INTERACTIVA ---
            print(f"¿Cual es la emocion REAL (Ground Truth) del video '{video_filename}'?")
            print(f"Opciones validas: {CLASSES}")
            
            etiqueta_input = input("Escribe la etiqueta aqui: ").strip().lower()
            
            # Validar entrada
            if etiqueta_input not in CLASSES:
                print(f"Error: '{etiqueta_input}' no es una clase valida.")
                etiqueta_real_valida = False
            else:
                etiqueta_real_valida = True
                real_idx = CLASSES.index(etiqueta_input)

            # Extraccion y Prediccion
            cap = cv2.VideoCapture(video_path)
            fps = cap.get(cv2.CAP_PROP_FPS)
            frame_interval = int(fps / FPS_TARGET) if fps > FPS_TARGET else 1
            
            predictions_frame = []
            frame_count = 0
            extracted_count = 0
            
            while cap.isOpened():
                ret, frame = cap.read()
                if not ret: break
                
                if frame_count % frame_interval == 0:
                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                    face = cv2.resize(frame_rgb, (224, 224))
                    
                    img_array = img_to_array(face)
                    processed = preprocess_mobilenet(img_array)
                    processed = np.expand_dims(processed, axis=0) # Batch de 1
                    
                    preds = model_mb.predict(processed, verbose=0)
                    predictions_frame.append(preds[0])
                    extracted_count += 1
                
                frame_count += 1
            cap.release()
            
            if extracted_count > 0:
                predictions_frame = np.array(predictions_frame)
                
                # Promedio de probabilidades
                avg_preds = np.mean(predictions_frame, axis=0)
                final_pred_idx = np.argmax(avg_preds)
                final_pred_label = CLASSES[final_pred_idx]
                
                print("\n" + "-"*40)
                print(f"RESULTADOS: {video_filename}")
                print("-"*40)
                
                if etiqueta_real_valida:
                    print(f"Etiqueta Real (Tu input): {etiqueta_input.upper()}")
                else:
                    print(f"Etiqueta Real (Tu input): NO VALIDA")
                    
                print(f"Prediccion del Modelo:    {final_pred_label.upper()}")
                
                print("\nProbabilidades promedio (Confianza):")
                for i, cls in enumerate(CLASSES):
                    prob = avg_preds[i] * 100
                    marcador = "<--" if i == final_pred_idx else ""
                    print(f"{cls:10s}: {prob:6.2f}% {marcador}")
                
                if etiqueta_real_valida:
                    if final_pred_idx == real_idx:
                        print("\n---> [CONCLUSION: PREDICCION CORRECTA]")
                    else:
                        print("\n---> [CONCLUSION: PREDICCION INCORRECTA]")
            else:
                print("Error: No se pudieron extraer frames validos del video.")

else:
    print("Error: El modelo MobileNet no se entreno correctamente. Revisa los datos de entrenamiento.")

print("\n=== PROCESO TERMINADO ===")